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 {
     var test_stage2 = b.addTest("src/test.zig");
     test_stage2.setBuildMode(mode);
-    test_stage2.addPackagePath("stage2_tests", "test/stage2/test.zig");
+    test_stage2.addPackagePath("test_cases", "test/cases.zig");
     const fmt_build_zig = b.addFmt(&[_][]const u8{"build.zig"});
 @@ -113,11 +113,15 @@ pub fn build(b: *Builder) !void {
         if (is_stage1) {
             exe.addIncludeDir("src");
             exe.addIncludeDir("deps/SoftFloat-3e/source/include");
+            test_stage2.addIncludeDir("src");
+            test_stage2.addIncludeDir("deps/SoftFloat-3e/source/include");
             // This is intentionally a dummy path. stage1.zig tries to @import("compiler_rt") in case
             // of being built by cmake. But when built by zig it's gonna get a compiler_rt so that
             // is pointless.
             exe.addPackagePath("compiler_rt", "src/empty.zig");
             exe.defineCMacro("ZIG_LINK_MODE", "Static");
+            test_stage2.defineCMacro("ZIG_LINK_MODE", "Static");
             const softfloat = b.addStaticLibrary("softfloat", null);
             softfloat.setBuildMode(.ReleaseFast);
 @@ -126,10 +130,15 @@ pub fn build(b: *Builder) !void {
             softfloat.addIncludeDir("deps/SoftFloat-3e/source/8086");
             softfloat.addIncludeDir("deps/SoftFloat-3e/source/include");
             softfloat.addCSourceFiles(&softfloat_sources, &[_][]const u8{ "-std=c99", "-O3" });
             exe.linkLibrary(softfloat);
+            test_stage2.linkLibrary(softfloat);
             exe.addCSourceFiles(&stage1_sources, &exe_cflags);
             exe.addCSourceFiles(&optimized_c_sources, &[_][]const u8{ "-std=c99", "-O3" });
+            test_stage2.addCSourceFiles(&stage1_sources, &exe_cflags);
+            test_stage2.addCSourceFiles(&optimized_c_sources, &[_][]const u8{ "-std=c99", "-O3" });
         }
         if (cmake_cfg) |cfg| {
             // 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 {
                 b.addSearchPrefix(cfg.cmake_prefix_path);
             }
-            try addCmakeCfgOptionsToExe(b, cfg, tracy, exe);
+            try addCmakeCfgOptionsToExe(b, cfg, exe);
-            try addCmakeCfgOptionsToExe(b, cfg, tracy, test_stage2);
+            try addCmakeCfgOptionsToExe(b, cfg, test_stage2);
         } else {
             // Here we are -Denable-llvm but no cmake integration.
             try addStaticLlvmOptionsToExe(exe);
 @@ -233,7 +242,9 @@ pub fn build(b: *Builder) !void {
     const is_darling_enabled = b.option(bool, "enable-darling", "[Experimental] Use Darling to run cross compiled macOS tests") orelse false;
     const glibc_multi_dir = b.option([]const u8, "enable-foreign-glibc", "Provide directory with glibc installations to run cross compiled tests that link glibc");
+    test_stage2.addBuildOption(bool, "enable_logging", enable_logging);
     test_stage2.addBuildOption(bool, "skip_non_native", skip_non_native);
+    test_stage2.addBuildOption(bool, "skip_compile_errors", skip_compile_errors);
     test_stage2.addBuildOption(bool, "is_stage1", is_stage1);
     test_stage2.addBuildOption(bool, "omit_stage2", omit_stage2);
     test_stage2.addBuildOption(bool, "have_llvm", enable_llvm);
 @@ -243,7 +254,8 @@ pub fn build(b: *Builder) !void {
     test_stage2.addBuildOption(u32, "mem_leak_frames", mem_leak_frames * 2);
     test_stage2.addBuildOption(bool, "enable_darling", is_darling_enabled);
     test_stage2.addBuildOption(?[]const u8, "glibc_multi_install_dir", glibc_multi_dir);
-    test_stage2.addBuildOption([]const u8, "version", version);
+    test_stage2.addBuildOption([:0]const u8, "version", try b.allocator.dupeZ(u8, version));
+    test_stage2.addBuildOption(std.SemanticVersion, "semver", semver);
     const test_stage2_step = b.step("test-stage2", "Run the stage2 compiler tests");
     test_stage2_step.dependOn(&test_stage2.step);
 @@ -339,9 +351,6 @@ pub fn build(b: *Builder) !void {
     }
     // tests for this feature are disabled until we have the self-hosted compiler available
     // toolchain_step.dependOn(tests.addGenHTests(b, test_filter));
-    if (!skip_compile_errors) {
-        toolchain_step.dependOn(tests.addCompileErrorTests(b, test_filter, modes));
-    }
     const std_step = tests.addPkgTests(
         b,
 @@ -383,7 +392,6 @@ const exe_cflags = [_][]const u8{
 fn addCmakeCfgOptionsToExe(
     b: *Builder,
     cfg: CMakeConfig,
-    tracy: ?[]const u8,
     exe: *std.build.LibExeObjStep,
 ) !void {
     exe.addObjectFile(fs.path.join(b.allocator, &[_][]const u8{
 @@ -397,7 +405,7 @@ fn addCmakeCfgOptionsToExe(
     addCMakeLibraryList(exe, cfg.lld_libraries);
     addCMakeLibraryList(exe, cfg.llvm_libraries);
-    const need_cpp_includes = tracy != null;
+    const need_cpp_includes = true;
     // System -lc++ must be used because in this code path we are attempting to link
     // against system-provided LLVM, Clang, LLD.
 @@ -486,9 +494,9 @@ fn addCxxKnownPath(
     if (need_cpp_includes) {
         // I used these temporarily for testing something but we obviously need a
         // more general purpose solution here.
-        //exe.addIncludeDir("/nix/store/b3zsk4ihlpiimv3vff86bb5bxghgdzb9-gcc-9.2.0/lib/gcc/x86_64-unknown-linux-gnu/9.2.0/../../../../include/c++/9.2.0");
+        //exe.addIncludeDir("/nix/store/fvf3qjqa5qpcjjkq37pb6ypnk1mzhf5h-gcc-9.3.0/lib/gcc/x86_64-unknown-linux-gnu/9.3.0/../../../../include/c++/9.3.0");
-        //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");
+        //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");
-        //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");
+        //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");
     }
 }

doc/docgen.zig+34-14

 @@ -8,6 +8,7 @@ const Progress = std.Progress;
 const print = std.debug.print;
 const mem = std.mem;
 const testing = std.testing;
+const Allocator = std.mem.Allocator;
 const max_doc_file_size = 10 * 1024 * 1024;
 @@ -326,7 +327,7 @@ const Action = enum {
     Close,
 };
-fn genToc(allocator: *mem.Allocator, tokenizer: *Tokenizer) !Toc {
+fn genToc(allocator: *Allocator, tokenizer: *Tokenizer) !Toc {
     var urls = std.StringHashMap(Token).init(allocator);
     errdefer urls.deinit();
 @@ -630,7 +631,7 @@ fn genToc(allocator: *mem.Allocator, tokenizer: *Tokenizer) !Toc {
     };
 }
-fn urlize(allocator: *mem.Allocator, input: []const u8) ![]u8 {
+fn urlize(allocator: *Allocator, input: []const u8) ![]u8 {
     var buf = std.ArrayList(u8).init(allocator);
     defer buf.deinit();
 @@ -649,7 +650,7 @@ fn urlize(allocator: *mem.Allocator, input: []const u8) ![]u8 {
     return buf.toOwnedSlice();
 }
-fn escapeHtml(allocator: *mem.Allocator, input: []const u8) ![]u8 {
+fn escapeHtml(allocator: *Allocator, input: []const u8) ![]u8 {
     var buf = std.ArrayList(u8).init(allocator);
     defer buf.deinit();
 @@ -695,7 +696,7 @@ test "term color" {
     testing.expectEqualSlices(u8, "A<span class=\"t32\">green</span>B", result);
 }
-fn termColor(allocator: *mem.Allocator, input: []const u8) ![]u8 {
+fn termColor(allocator: *Allocator, input: []const u8) ![]u8 {
     var buf = std.ArrayList(u8).init(allocator);
     defer buf.deinit();
 @@ -789,8 +790,15 @@ fn isType(name: []const u8) bool {
     return false;
 }
-fn tokenizeAndPrintRaw(docgen_tokenizer: *Tokenizer, out: anytype, source_token: Token, raw_src: []const u8) !void {
+fn tokenizeAndPrintRaw(
-    const src = mem.trim(u8, raw_src, " \n");
+    allocator: *Allocator,
+    docgen_tokenizer: *Tokenizer,
+    out: anytype,
+    source_token: Token,
+    raw_src: []const u8,
+) !void {
+    const src_non_terminated = mem.trim(u8, raw_src, " \n");
+    const src = try allocator.dupeZ(u8, src_non_terminated);
     try out.writeAll("<code class=\"zig\">");
     var tokenizer = std.zig.Tokenizer.init(src);
     var index: usize = 0;
 @@ -1016,12 +1024,24 @@ fn tokenizeAndPrintRaw(docgen_tokenizer: *Tokenizer, out: anytype, source_token:
     try out.writeAll("</code>");
 }
-fn tokenizeAndPrint(docgen_tokenizer: *Tokenizer, out: anytype, source_token: Token) !void {
+fn tokenizeAndPrint(
+    allocator: *Allocator,
+    docgen_tokenizer: *Tokenizer,
+    out: anytype,
+    source_token: Token,
+) !void {
     const raw_src = docgen_tokenizer.buffer[source_token.start..source_token.end];
-    return tokenizeAndPrintRaw(docgen_tokenizer, out, source_token, raw_src);
+    return tokenizeAndPrintRaw(allocator, docgen_tokenizer, out, source_token, raw_src);
 }
-fn genHtml(allocator: *mem.Allocator, tokenizer: *Tokenizer, toc: *Toc, out: anytype, zig_exe: []const u8, do_code_tests: bool) !void {
+fn genHtml(
+    allocator: *Allocator,
+    tokenizer: *Tokenizer,
+    toc: *Toc,
+    out: anytype,
+    zig_exe: []const u8,
+    do_code_tests: bool,
+) !void {
     var progress = Progress{};
     const root_node = try progress.start("Generating docgen examples", toc.nodes.len);
     defer root_node.end();
 @@ -1048,7 +1068,7 @@ fn genHtml(allocator: *mem.Allocator, tokenizer: *Tokenizer, toc: *Toc, out: any
             },
             .Builtin => |tok| {
                 try out.writeAll("<pre>");
-                try tokenizeAndPrintRaw(tokenizer, out, tok, builtin_code);
+                try tokenizeAndPrintRaw(allocator, tokenizer, out, tok, builtin_code);
                 try out.writeAll("</pre>");
             },
             .HeaderOpen => |info| {
 @@ -1069,7 +1089,7 @@ fn genHtml(allocator: *mem.Allocator, tokenizer: *Tokenizer, toc: *Toc, out: any
                 try out.writeAll("</ul>\n");
             },
             .Syntax => |content_tok| {
-                try tokenizeAndPrint(tokenizer, out, content_tok);
+                try tokenizeAndPrint(allocator, tokenizer, out, content_tok);
             },
             .Code => |code| {
                 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
                     try out.print("<p class=\"file\">{s}.zig</p>", .{code.name});
                 }
                 try out.writeAll("<pre>");
-                try tokenizeAndPrint(tokenizer, out, code.source_token);
+                try tokenizeAndPrint(allocator, tokenizer, out, code.source_token);
                 try out.writeAll("</pre>");
                 if (!do_code_tests) {
 @@ -1497,7 +1517,7 @@ fn genHtml(allocator: *mem.Allocator, tokenizer: *Tokenizer, toc: *Toc, out: any
     }
 }
-fn exec(allocator: *mem.Allocator, env_map: *std.BufMap, args: []const []const u8) !ChildProcess.ExecResult {
+fn exec(allocator: *Allocator, env_map: *std.BufMap, args: []const []const u8) !ChildProcess.ExecResult {
     const result = try ChildProcess.exec(.{
         .allocator = allocator,
         .argv = args,
 @@ -1521,7 +1541,7 @@ fn exec(allocator: *mem.Allocator, env_map: *std.BufMap, args: []const []const u
     return result;
 }
-fn getBuiltinCode(allocator: *mem.Allocator, env_map: *std.BufMap, zig_exe: []const u8) ![]const u8 {
+fn getBuiltinCode(allocator: *Allocator, env_map: *std.BufMap, zig_exe: []const u8) ![]const u8 {
     const result = try exec(allocator, env_map, &[_][]const u8{ zig_exe, "build-obj", "--show-builtin" });
     return result.stdout;
 }

doc/langref.html.in+18-6

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

lib/std/fmt.zig+2-2

...	@@ -362,8 +362,8 @@ pub fn format(	...	@@ -362,8 +362,8 @@ pub fn format(
362	const missing_count = arg_state.args_len - @popCount(ArgSetType, arg_state.used_args);	362	const missing_count = arg_state.args_len - @popCount(ArgSetType, arg_state.used_args);
363	switch (missing_count) {	363	switch (missing_count) {
364	0 => unreachable,	364	0 => unreachable,
365	1 => @compileError("Unused argument in \"" ++ fmt ++ "\""),	365	1 => @compileError("Unused argument in '" ++ fmt ++ "'"),
366	else => @compileError((comptime comptimePrint("{d}", .{missing_count})) ++ " unused arguments 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,14 +2297,14 @@ pub fn replaceOwned(comptime T: type, allocator: *Allocator, input: []const T, n
2297	}	2297	}
2298		2298
2299	test "replaceOwned" {	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;	2302	const base_replace = replaceOwned(u8, gpa, "All your base are belong to us", "base", "Zig") catch @panic("out of memory");
2303	defer allocator.free(base_replace);	2303	defer gpa.free(base_replace);
2304	try testing.expect(eql(u8, base_replace, "All your Zig are belong to us"));	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;	2306	const zen_replace = replaceOwned(u8, gpa, "Favor reading code over writing code.", " code", "") catch @panic("out of memory");
2307	defer allocator.free(zen_replace);	2307	defer gpa.free(zen_replace);
2308	try testing.expect(eql(u8, zen_replace, "Favor reading over writing."));	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,13 +57,13 @@ pub const SimpleNetworkProtocol = extern struct {
57	}	57	}
58		58
59	/// Modifies or resets the current station address, if supported.	59	/// Modifies or resets the current station address, if supported.
60	pub fn stationAddress(self: const SimpleNetworkProtocol, reset: bool, new: ?const MacAddress) Status {	60	pub fn stationAddress(self: const SimpleNetworkProtocol, reset_flag: bool, new: ?const MacAddress) Status {
61	return self._station_address(self, reset, new);	61	return self._station_address(self, reset_flag, new);
62	}	62	}
63		63
64	/// Resets or collects the statistics on a network interface.	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 {	65	pub fn statistics(self: const SimpleNetworkProtocol, reset_flag: bool, statistics_size: ?usize, statistics_table: ?*NetworkStatistics) Status {
66	return self._statistics(self, reset_, statistics_size, statistics_table);	66	return self._statistics(self, reset_flag, statistics_size, statistics_table);
67	}	67	}
68		68
69	/// Converts a multicast IP address to a multicast HW MAC address.	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,7 +247,6 @@ pub const Utf8View = struct {
247	} else \|err\| switch (err) {	247	} else \|err\| switch (err) {
248	error.InvalidUtf8 => {	248	error.InvalidUtf8 => {
249	@compileError("invalid utf8");	249	@compileError("invalid utf8");
250	unreachable;
251	},	250	},
252	}	251	}
253	}	252	}

lib/std/zig.zig+147-56

 @@ -6,6 +6,7 @@
 const std = @import("std.zig");
 const tokenizer = @import("zig/tokenizer.zig");
 const fmt = @import("zig/fmt.zig");
+const assert = std.debug.assert;
 pub const Token = tokenizer.Token;
 pub const Tokenizer = tokenizer.Tokenizer;
 @@ -183,29 +184,48 @@ pub fn binNameAlloc(allocator: *std.mem.Allocator, options: BinNameOptions) erro
     }
 }
+pub const ParsedCharLiteral = union(enum) {
+    success: u32,
+    /// The character after backslash is not recognized.
+    invalid_escape_character: usize,
+    /// Expected hex digit at this index.
+    expected_hex_digit: usize,
+    /// Unicode escape sequence had no digits with rbrace at this index.
+    empty_unicode_escape_sequence: usize,
+    /// Expected hex digit or '}' at this index.
+    expected_hex_digit_or_rbrace: usize,
+    /// The unicode point is outside the range of Unicode codepoints.
+    unicode_escape_overflow: usize,
+    /// Expected '{' at this index.
+    expected_lbrace: usize,
+    /// Expected the terminating single quote at this index.
+    expected_end: usize,
+    /// The character at this index cannot be represented without an escape sequence.
+    invalid_character: usize,
+};
 /// Only validates escape sequence characters.
 /// Slice must be valid utf8 starting and ending with "'" and exactly one codepoint in between.
-pub fn parseCharLiteral(
+pub fn parseCharLiteral(slice: []const u8) ParsedCharLiteral {
-    slice: []const u8,
+    assert(slice.len >= 3 and slice[0] == '\'' and slice[slice.len - 1] == '\'');
-    bad_index: *usize, // populated if error.InvalidCharacter is returned
-) error{InvalidCharacter}!u32 {
-    std.debug.assert(slice.len >= 3 and slice[0] == '\'' and slice[slice.len - 1] == '\'');
-    if (slice[1] == '\\') {
+    switch (slice[1]) {
-        switch (slice[2]) {
+        0 => return .{ .invalid_character = 1 },
-            'n' => return '\n',
+        '\\' => switch (slice[2]) {
-            'r' => return '\r',
+            'n' => return .{ .success = '\n' },
-            '\\' => return '\\',
+            'r' => return .{ .success = '\r' },
-            't' => return '\t',
+            '\\' => return .{ .success = '\\' },
-            '\'' => return '\'',
+            't' => return .{ .success = '\t' },
-            '"' => return '"',
+            '\'' => return .{ .success = '\'' },
+            '"' => return .{ .success = '"' },
             'x' => {
-                if (slice.len != 6) {
+                if (slice.len < 4) {
-                    bad_index.* = slice.len - 2;
+                    return .{ .expected_hex_digit = 3 };
-                    return error.InvalidCharacter;
                 }
                 var value: u32 = 0;
-                for (slice[3..5]) |c, i| {
+                var i: usize = 3;
+                while (i < 5) : (i += 1) {
+                    const c = slice[i];
                     switch (c) {
                         '0'...'9' => {
                             value *= 16;
 @@ -220,20 +240,28 @@ pub fn parseCharLiteral(
                             value += c - 'A' + 10;
                         },
                         else => {
-                            bad_index.* = 3 + i;
+                            return .{ .expected_hex_digit = i };
-                            return error.InvalidCharacter;
                         },
                     }
                 }
-                return value;
+                if (slice[i] != '\'') {
+                    return .{ .expected_end = i };
+                }
+                return .{ .success = value };
             },
             'u' => {
-                if (slice.len < "'\\u{0}'".len or slice[3] != '{' or slice[slice.len - 2] != '}') {
+                var i: usize = 3;
-                    bad_index.* = 2;
+                if (slice[i] != '{') {
-                    return error.InvalidCharacter;
+                    return .{ .expected_lbrace = i };
                 }
+                i += 1;
+                if (slice[i] == '}') {
+                    return .{ .empty_unicode_escape_sequence = i };
+                }
                 var value: u32 = 0;
-                for (slice[4 .. slice.len - 2]) |c, i| {
+                while (i < slice.len) : (i += 1) {
+                    const c = slice[i];
                     switch (c) {
                         '0'...'9' => {
                             value *= 16;
 @@ -247,49 +275,112 @@ pub fn parseCharLiteral(
                             value *= 16;
                             value += c - 'A' + 10;
                         },
-                        else => {
+                        '}' => {
-                            bad_index.* = 4 + i;
+                            i += 1;
-                            return error.InvalidCharacter;
+                            break;
                         },
+                        else => return .{ .expected_hex_digit_or_rbrace = i },
                     }
                     if (value > 0x10ffff) {
-                        bad_index.* = 4 + i;
+                        return .{ .unicode_escape_overflow = i };
-                        return error.InvalidCharacter;
                     }
                 }
-                return value;
+                if (slice[i] != '\'') {
-            },
+                    return .{ .expected_end = i };
-            else => {
+                }
-                bad_index.* = 2;
+                return .{ .success = value };
-                return error.InvalidCharacter;
             },
-        }
+            else => return .{ .invalid_escape_character = 2 },
+        },
+        else => {
+            const codepoint = std.unicode.utf8Decode(slice[1 .. slice.len - 1]) catch unreachable;
+            return .{ .success = codepoint };
+        },
     }
-    return std.unicode.utf8Decode(slice[1 .. slice.len - 1]) catch unreachable;
 }
 test "parseCharLiteral" {
-    var bad_index: usize = undefined;
+    try std.testing.expectEqual(
-    try std.testing.expectEqual(try parseCharLiteral("'a'", &bad_index), 'a');
+        ParsedCharLiteral{ .success = 'a' },
-    try std.testing.expectEqual(try parseCharLiteral("'ä'", &bad_index), 'ä');
+        parseCharLiteral("'a'"),
-    try std.testing.expectEqual(try parseCharLiteral("'\\x00'", &bad_index), 0);
+    );
-    try std.testing.expectEqual(try parseCharLiteral("'\\x4f'", &bad_index), 0x4f);
+    try std.testing.expectEqual(
-    try std.testing.expectEqual(try parseCharLiteral("'\\x4F'", &bad_index), 0x4f);
+        ParsedCharLiteral{ .success = 'ä' },
-    try std.testing.expectEqual(try parseCharLiteral("'ぁ'", &bad_index), 0x3041);
+        parseCharLiteral("'ä'"),
-    try std.testing.expectEqual(try parseCharLiteral("'\\u{0}'", &bad_index), 0);
+    );
-    try std.testing.expectEqual(try parseCharLiteral("'\\u{3041}'", &bad_index), 0x3041);
+    try std.testing.expectEqual(
-    try std.testing.expectEqual(try parseCharLiteral("'\\u{7f}'", &bad_index), 0x7f);
+        ParsedCharLiteral{ .success = 0 },
-    try std.testing.expectEqual(try parseCharLiteral("'\\u{7FFF}'", &bad_index), 0x7FFF);
+        parseCharLiteral("'\\x00'"),
+    );
+    try std.testing.expectEqual(
+        ParsedCharLiteral{ .success = 0x4f },
+        parseCharLiteral("'\\x4f'"),
+    );
+    try std.testing.expectEqual(
+        ParsedCharLiteral{ .success = 0x4f },
+        parseCharLiteral("'\\x4F'"),
+    );
+    try std.testing.expectEqual(
+        ParsedCharLiteral{ .success = 0x3041 },
+        parseCharLiteral("'ぁ'"),
+    );
+    try std.testing.expectEqual(
+        ParsedCharLiteral{ .success = 0 },
+        parseCharLiteral("'\\u{0}'"),
+    );
+    try std.testing.expectEqual(
+        ParsedCharLiteral{ .success = 0x3041 },
+        parseCharLiteral("'\\u{3041}'"),
+    );
+    try std.testing.expectEqual(
+        ParsedCharLiteral{ .success = 0x7f },
+        parseCharLiteral("'\\u{7f}'"),
+    );
+    try std.testing.expectEqual(
+        ParsedCharLiteral{ .success = 0x7fff },
+        parseCharLiteral("'\\u{7FFF}'"),
+    );
-    try std.testing.expectError(error.InvalidCharacter, parseCharLiteral("'\\x0'", &bad_index));
+    try std.testing.expectEqual(
-    try std.testing.expectError(error.InvalidCharacter, parseCharLiteral("'\\x000'", &bad_index));
+        ParsedCharLiteral{ .expected_hex_digit = 4 },
-    try std.testing.expectError(error.InvalidCharacter, parseCharLiteral("'\\y'", &bad_index));
+        parseCharLiteral("'\\x0'"),
-    try std.testing.expectError(error.InvalidCharacter, parseCharLiteral("'\\u'", &bad_index));
+    );
-    try std.testing.expectError(error.InvalidCharacter, parseCharLiteral("'\\uFFFF'", &bad_index));
+    try std.testing.expectEqual(
-    try std.testing.expectError(error.InvalidCharacter, parseCharLiteral("'\\u{}'", &bad_index));
+        ParsedCharLiteral{ .expected_end = 5 },
-    try std.testing.expectError(error.InvalidCharacter, parseCharLiteral("'\\u{FFFFFF}'", &bad_index));
+        parseCharLiteral("'\\x000'"),
-    try std.testing.expectError(error.InvalidCharacter, parseCharLiteral("'\\u{FFFF'", &bad_index));
+    );
-    try std.testing.expectError(error.InvalidCharacter, parseCharLiteral("'\\u{FFFF}x'", &bad_index));
+    try std.testing.expectEqual(
+        ParsedCharLiteral{ .invalid_escape_character = 2 },
+        parseCharLiteral("'\\y'"),
+    );
+    try std.testing.expectEqual(
+        ParsedCharLiteral{ .expected_lbrace = 3 },
+        parseCharLiteral("'\\u'"),
+    );
+    try std.testing.expectEqual(
+        ParsedCharLiteral{ .expected_lbrace = 3 },
+        parseCharLiteral("'\\uFFFF'"),
+    );
+    try std.testing.expectEqual(
+        ParsedCharLiteral{ .empty_unicode_escape_sequence = 4 },
+        parseCharLiteral("'\\u{}'"),
+    );
+    try std.testing.expectEqual(
+        ParsedCharLiteral{ .unicode_escape_overflow = 9 },
+        parseCharLiteral("'\\u{FFFFFF}'"),
+    );
+    try std.testing.expectEqual(
+        ParsedCharLiteral{ .expected_hex_digit_or_rbrace = 8 },
+        parseCharLiteral("'\\u{FFFF'"),
+    );
+    try std.testing.expectEqual(
+        ParsedCharLiteral{ .expected_end = 9 },
+        parseCharLiteral("'\\u{FFFF}x'"),
+    );
+    try std.testing.expectEqual(
+        ParsedCharLiteral{ .invalid_character = 1 },
+        parseCharLiteral("'\x00'"),
+    );
 }
 test {

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

...	@@ -20,7 +20,7 @@ pub const NodeList = std.MultiArrayList(Node);	...	@@ -20,7 +20,7 @@ pub const NodeList = std.MultiArrayList(Node);
20		20
21	pub const Tree = struct {	21	pub const Tree = struct {
22	/// Reference to externally-owned data.	22	/// Reference to externally-owned data.
23	source: []const u8,	23	source: [:0]const u8,
24		24
25	tokens: TokenList.Slice,	25	tokens: TokenList.Slice,
26	/// The root AST node is assumed to be index 0. Since there can be no	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,6 +135,8 @@ pub const Tree = struct {
135	const token_tags = tree.tokens.items(.tag);	135	const token_tags = tree.tokens.items(.tag);
136	switch (parse_error.tag) {	136	switch (parse_error.tag) {
137	.asterisk_after_ptr_deref => {	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	return stream.writeAll("'.' cannot be followed by ''. Are you missing a space?");	140	return stream.writeAll("'.' cannot be followed by ''. Are you missing a space?");
139	},	141	},
140	.decl_between_fields => {	142	.decl_between_fields => {
...	@@ -284,7 +286,7 @@ pub const Tree = struct {	...	@@ -284,7 +286,7 @@ pub const Tree = struct {
284	return stream.writeAll("bit range not allowed on slices and arrays");	286	return stream.writeAll("bit range not allowed on slices and arrays");
285	},	287	},
286	.invalid_token => {	288	.invalid_token => {
287	return stream.print("invalid token '{s}'", .{	289	return stream.print("invalid token: '{s}'", .{
288	token_tags[parse_error.token].symbol(),	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,7 +17,7 @@ pub const Error = error{ParseError} \|\| Allocator.Error;
17		17
18	/// Result should be freed with tree.deinit() when there are	18	/// Result should be freed with tree.deinit() when there are
19	/// no more references to any of the tokens or nodes.	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	var tokens = ast.TokenList{};	21	var tokens = ast.TokenList{};
22	defer tokens.deinit(gpa);	22	defer tokens.deinit(gpa);
23		23

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

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

 @@ -326,7 +326,7 @@ pub const Token = struct {
 };
 pub const Tokenizer = struct {
-    buffer: []const u8,
+    buffer: [:0]const u8,
     index: usize,
     pending_invalid_token: ?Token,
 @@ -335,7 +335,7 @@ pub const Tokenizer = struct {
         std.debug.warn("{s} \"{s}\"\n", .{ @tagName(token.tag), self.buffer[token.start..token.end] });
     }
-    pub fn init(buffer: []const u8) Tokenizer {
+    pub fn init(buffer: [:0]const u8) Tokenizer {
         // Skip the UTF-8 BOM if present
         const src_start = if (mem.startsWith(u8, buffer, "\xEF\xBB\xBF")) 3 else @as(usize, 0);
         return Tokenizer{
 @@ -373,7 +373,6 @@ pub const Tokenizer = struct {
         line_comment,
         doc_comment_start,
         doc_comment,
-        container_doc_comment,
         zero,
         int_literal_dec,
         int_literal_dec_no_underscore,
 @@ -407,10 +406,6 @@ pub const Tokenizer = struct {
         saw_at_sign,
     };
-    fn isIdentifierChar(char: u8) bool {
-        return std.ascii.isAlNum(char) or char == '_';
-    }
     pub fn next(self: *Tokenizer) Token {
         if (self.pending_invalid_token) |token| {
             self.pending_invalid_token = null;
 @@ -426,10 +421,11 @@ pub const Tokenizer = struct {
         };
         var seen_escape_digits: usize = undefined;
         var remaining_code_units: usize = undefined;
-        while (self.index < self.buffer.len) : (self.index += 1) {
+        while (true) : (self.index += 1) {
             const c = self.buffer[self.index];
             switch (state) {
                 .start => switch (c) {
+                    0 => break,
                     ' ', '\n', '\t', '\r' => {
                         result.loc.start = self.index + 1;
                     },
 @@ -555,8 +551,9 @@ pub const Tokenizer = struct {
                     },
                     else => {
                         result.tag = .invalid;
+                        result.loc.end = self.index;
                         self.index += 1;
-                        break;
+                        return result;
                     },
                 },
 @@ -705,18 +702,35 @@ pub const Tokenizer = struct {
                         self.index += 1;
                         break;
                     },
-                    '\n', '\r' => break, // Look for this error later.
+                    0 => {
+                        if (self.index == self.buffer.len) {
+                            break;
+                        } else {
+                            self.checkLiteralCharacter();
+                        }
+                    },
+                    '\n' => {
+                        result.tag = .invalid;
+                        break;
+                    },
                     else => self.checkLiteralCharacter(),
                 },
                 .string_literal_backslash => switch (c) {
-                    '\n', '\r' => break, // Look for this error later.
+                    '\n' => {
+                        result.tag = .invalid;
+                        break;
+                    },
                     else => {
                         state = .string_literal;
                     },
                 },
                 .char_literal => switch (c) {
+                    0 => {
+                        result.tag = .invalid;
+                        break;
+                    },
                     '\\' => {
                         state = .char_literal_backslash;
                     },
 @@ -742,7 +756,7 @@ pub const Tokenizer = struct {
                 },
                 .char_literal_backslash => switch (c) {
-                    '\n' => {
+                    0, '\n' => {
                         result.tag = .invalid;
                         break;
                     },
 @@ -774,7 +788,6 @@ pub const Tokenizer = struct {
                 .char_literal_unicode_escape_saw_u => switch (c) {
                     '{' => {
                         state = .char_literal_unicode_escape;
-                        seen_escape_digits = 0;
                     },
                     else => {
                         result.tag = .invalid;
 @@ -783,16 +796,9 @@ pub const Tokenizer = struct {
                 },
                 .char_literal_unicode_escape => switch (c) {
-                    '0'...'9', 'a'...'f', 'A'...'F' => {
+                    '0'...'9', 'a'...'f', 'A'...'F' => {},
-                        seen_escape_digits += 1;
-                    },
                     '}' => {
-                        if (seen_escape_digits == 0) {
+                        state = .char_literal_end; // too many/few digits handled later
-                            result.tag = .invalid;
-                            state = .char_literal_unicode_invalid;
-                        } else {
-                            state = .char_literal_end;
-                        }
                     },
                     else => {
                         result.tag = .invalid;
 @@ -834,6 +840,7 @@ pub const Tokenizer = struct {
                 },
                 .multiline_string_literal_line => switch (c) {
+                    0 => break,
                     '\n' => {
                         self.index += 1;
                         break;
 @@ -1025,12 +1032,19 @@ pub const Tokenizer = struct {
                     },
                 },
                 .line_comment_start => switch (c) {
+                    0 => {
+                        if (self.index != self.buffer.len) {
+                            result.tag = .invalid;
+                            self.index += 1;
+                        }
+                        break;
+                    },
                     '/' => {
                         state = .doc_comment_start;
                     },
                     '!' => {
                         result.tag = .container_doc_comment;
-                        state = .container_doc_comment;
+                        state = .doc_comment;
                     },
                     '\n' => {
                         state = .start;
 @@ -1046,7 +1060,7 @@ pub const Tokenizer = struct {
                     '/' => {
                         state = .line_comment;
                     },
-                    '\n' => {
+                    0, '\n' => {
                         result.tag = .doc_comment;
                         break;
                     },
 @@ -1061,6 +1075,7 @@ pub const Tokenizer = struct {
                     },
                 },
                 .line_comment => switch (c) {
+                    0 => break,
                     '\n' => {
                         state = .start;
                         result.loc.start = self.index + 1;
 @@ -1068,8 +1083,8 @@ pub const Tokenizer = struct {
                     '\t', '\r' => {},
                     else => self.checkLiteralCharacter(),
                 },
-                .doc_comment, .container_doc_comment => switch (c) {
+                .doc_comment => switch (c) {
-                    '\n' => break,
+                    0, '\n' => break,
                     '\t', '\r' => {},
                     else => self.checkLiteralCharacter(),
                 },
 @@ -1088,12 +1103,11 @@ pub const Tokenizer = struct {
                         self.index -= 1;
                         state = .int_literal_dec;
                     },
-                    else => {
+                    'a', 'c', 'd', 'f'...'n', 'p'...'w', 'y', 'z', 'A'...'D', 'F'...'Z' => {
-                        if (isIdentifierChar(c)) {
+                        result.tag = .invalid;
-                            result.tag = .invalid;
-                        }
                         break;
                     },
+                    else => break,
                 },
                 .int_literal_bin_no_underscore => switch (c) {
                     '0'...'1' => {
 @@ -1109,12 +1123,11 @@ pub const Tokenizer = struct {
                         state = .int_literal_bin_no_underscore;
                     },
                     '0'...'1' => {},
-                    else => {
+                    '2'...'9', 'a'...'z', 'A'...'Z' => {
-                        if (isIdentifierChar(c)) {
+                        result.tag = .invalid;
-                            result.tag = .invalid;
-                        }
                         break;
                     },
+                    else => break,
                 },
                 .int_literal_oct_no_underscore => switch (c) {
                     '0'...'7' => {
 @@ -1130,12 +1143,11 @@ pub const Tokenizer = struct {
                         state = .int_literal_oct_no_underscore;
                     },
                     '0'...'7' => {},
-                    else => {
+                    '8', '9', 'a'...'z', 'A'...'Z' => {
-                        if (isIdentifierChar(c)) {
+                        result.tag = .invalid;
-                            result.tag = .invalid;
-                        }
                         break;
                     },
+                    else => break,
                 },
                 .int_literal_dec_no_underscore => switch (c) {
                     '0'...'9' => {
 @@ -1159,12 +1171,11 @@ pub const Tokenizer = struct {
                         result.tag = .float_literal;
                     },
                     '0'...'9' => {},
-                    else => {
+                    'a'...'d', 'f'...'z', 'A'...'D', 'F'...'Z' => {
-                        if (isIdentifierChar(c)) {
+                        result.tag = .invalid;
-                            result.tag = .invalid;
-                        }
                         break;
                     },
+                    else => break,
                 },
                 .int_literal_hex_no_underscore => switch (c) {
                     '0'...'9', 'a'...'f', 'A'...'F' => {
 @@ -1188,12 +1199,11 @@ pub const Tokenizer = struct {
                         result.tag = .float_literal;
                     },
                     '0'...'9', 'a'...'f', 'A'...'F' => {},
-                    else => {
+                    'g'...'o', 'q'...'z', 'G'...'O', 'Q'...'Z' => {
-                        if (isIdentifierChar(c)) {
+                        result.tag = .invalid;
-                            result.tag = .invalid;
-                        }
                         break;
                     },
+                    else => break,
                 },
                 .num_dot_dec => switch (c) {
                     '.' => {
 @@ -1206,12 +1216,11 @@ pub const Tokenizer = struct {
                         result.tag = .float_literal;
                         state = .float_fraction_dec;
                     },
-                    else => {
+                    '_', 'a'...'z', 'A'...'Z' => {
-                        if (isIdentifierChar(c)) {
+                        result.tag = .invalid;
-                            result.tag = .invalid;
-                        }
                         break;
                     },
+                    else => break,
                 },
                 .num_dot_hex => switch (c) {
                     '.' => {
 @@ -1224,12 +1233,11 @@ pub const Tokenizer = struct {
                         result.tag = .float_literal;
                         state = .float_fraction_hex;
                     },
-                    else => {
+                    '_', 'g'...'z', 'G'...'Z' => {
-                        if (isIdentifierChar(c)) {
+                        result.tag = .invalid;
-                            result.tag = .invalid;
-                        }
                         break;
                     },
+                    else => break,
                 },
                 .float_fraction_dec_no_underscore => switch (c) {
                     '0'...'9' => {
 @@ -1248,12 +1256,11 @@ pub const Tokenizer = struct {
                         state = .float_exponent_unsigned;
                     },
                     '0'...'9' => {},
-                    else => {
+                    'a'...'d', 'f'...'z', 'A'...'D', 'F'...'Z' => {
-                        if (isIdentifierChar(c)) {
+                        result.tag = .invalid;
-                            result.tag = .invalid;
-                        }
                         break;
                     },
+                    else => break,
                 },
                 .float_fraction_hex_no_underscore => switch (c) {
                     '0'...'9', 'a'...'f', 'A'...'F' => {
 @@ -1272,12 +1279,11 @@ pub const Tokenizer = struct {
                         state = .float_exponent_unsigned;
                     },
                     '0'...'9', 'a'...'f', 'A'...'F' => {},
-                    else => {
+                    'g'...'o', 'q'...'z', 'G'...'O', 'Q'...'Z' => {
-                        if (isIdentifierChar(c)) {
+                        result.tag = .invalid;
-                            result.tag = .invalid;
-                        }
                         break;
                     },
+                    else => break,
                 },
                 .float_exponent_unsigned => switch (c) {
                     '+', '-' => {
 @@ -1303,130 +1309,11 @@ pub const Tokenizer = struct {
                         state = .float_exponent_num_no_underscore;
                     },
                     '0'...'9' => {},
-                    else => {
+                    'a'...'z', 'A'...'Z' => {
-                        if (isIdentifierChar(c)) {
+                        result.tag = .invalid;
-                            result.tag = .invalid;
-                        }
                         break;
                     },
-                },
+                    else => break,
-            }
-        } else if (self.index == self.buffer.len) {
-            switch (state) {
-                .start,
-                .int_literal_dec,
-                .int_literal_bin,
-                .int_literal_oct,
-                .int_literal_hex,
-                .num_dot_dec,
-                .num_dot_hex,
-                .float_fraction_dec,
-                .float_fraction_hex,
-                .float_exponent_num,
-                .string_literal, // find this error later
-                .multiline_string_literal_line,
-                .builtin,
-                .line_comment,
-                .line_comment_start,
-                => {},
-                .identifier => {
-                    if (Token.getKeyword(self.buffer[result.loc.start..self.index])) |tag| {
-                        result.tag = tag;
-                    }
-                },
-                .doc_comment, .doc_comment_start => {
-                    result.tag = .doc_comment;
-                },
-                .container_doc_comment => {
-                    result.tag = .container_doc_comment;
-                },
-                .int_literal_dec_no_underscore,
-                .int_literal_bin_no_underscore,
-                .int_literal_oct_no_underscore,
-                .int_literal_hex_no_underscore,
-                .float_fraction_dec_no_underscore,
-                .float_fraction_hex_no_underscore,
-                .float_exponent_num_no_underscore,
-                .float_exponent_unsigned,
-                .saw_at_sign,
-                .backslash,
-                .char_literal,
-                .char_literal_backslash,
-                .char_literal_hex_escape,
-                .char_literal_unicode_escape_saw_u,
-                .char_literal_unicode_escape,
-                .char_literal_unicode_invalid,
-                .char_literal_end,
-                .char_literal_unicode,
-                .string_literal_backslash,
-                => {
-                    result.tag = .invalid;
-                },
-                .equal => {
-                    result.tag = .equal;
-                },
-                .bang => {
-                    result.tag = .bang;
-                },
-                .minus => {
-                    result.tag = .minus;
-                },
-                .slash => {
-                    result.tag = .slash;
-                },
-                .zero => {
-                    result.tag = .integer_literal;
-                },
-                .ampersand => {
-                    result.tag = .ampersand;
-                },
-                .period => {
-                    result.tag = .period;
-                },
-                .period_2 => {
-                    result.tag = .ellipsis2;
-                },
-                .period_asterisk => {
-                    result.tag = .period_asterisk;
-                },
-                .pipe => {
-                    result.tag = .pipe;
-                },
-                .angle_bracket_angle_bracket_right => {
-                    result.tag = .angle_bracket_angle_bracket_right;
-                },
-                .angle_bracket_right => {
-                    result.tag = .angle_bracket_right;
-                },
-                .angle_bracket_angle_bracket_left => {
-                    result.tag = .angle_bracket_angle_bracket_left;
-                },
-                .angle_bracket_left => {
-                    result.tag = .angle_bracket_left;
-                },
-                .plus_percent => {
-                    result.tag = .plus_percent;
-                },
-                .plus => {
-                    result.tag = .plus;
-                },
-                .percent => {
-                    result.tag = .percent;
-                },
-                .caret => {
-                    result.tag = .caret;
-                },
-                .asterisk_percent => {
-                    result.tag = .asterisk_percent;
-                },
-                .asterisk => {
-                    result.tag = .asterisk;
-                },
-                .minus_percent => {
-                    result.tag = .minus_percent;
                 },
             }
         }
 @@ -1566,7 +1453,7 @@ test "tokenizer - code point literal with unicode escapes" {
     , &.{ .invalid, .invalid });
     try testTokenize(
         \\'\u{}'
-    , &.{ .invalid, .invalid });
+    , &.{.char_literal});
     try testTokenize(
         \\'\u{s}'
     , &.{ .invalid, .invalid });
 @@ -2049,15 +1936,17 @@ test "tokenizer - invalid builtin identifiers" {
     try testTokenize("@0()", &.{ .invalid, .integer_literal, .l_paren, .r_paren });
 }
-fn testTokenize(source: []const u8, expected_tokens: []const Token.Tag) !void {
+fn testTokenize(source: [:0]const u8, expected_tokens: []const Token.Tag) !void {
     var tokenizer = Tokenizer.init(source);
     for (expected_tokens) |expected_token_id| {
         const token = tokenizer.next();
         if (token.tag != expected_token_id) {
-            std.debug.panic("expected {s}, found {s}\n", .{ @tagName(expected_token_id), @tagName(token.tag) });
+            std.debug.panic("expected {s}, found {s}\n", .{
+                @tagName(expected_token_id), @tagName(token.tag),
+            });
         }
     }
     const last_token = tokenizer.next();
-    try std.testing.expect(last_token.tag == .eof);
+    try std.testing.expectEqual(Token.Tag.eof, last_token.tag);
-    try std.testing.expect(last_token.loc.start == source.len);
+    try std.testing.expectEqual(source.len, last_token.loc.start);
 }

src/AstGen.zig+321-180

 @@ -34,8 +34,9 @@ string_table: std.StringHashMapUnmanaged(u32) = .{},
 compile_errors: ArrayListUnmanaged(Zir.Inst.CompileErrors.Item) = .{},
 /// The topmost block of the current function.
 fn_block: ?*GenZir = null,
-/// String table indexes, keeps track of all `@import` operands.
+/// Maps string table indexes to the first `@import` ZIR instruction
-imports: std.AutoArrayHashMapUnmanaged(u32, void) = .{},
+/// that uses this string as the operand.
+imports: std.AutoArrayHashMapUnmanaged(u32, Zir.Inst.Index) = .{},
 const InnerError = error{ OutOfMemory, AnalysisFail };
 @@ -154,7 +155,7 @@ pub fn generate(gpa: *Allocator, tree: ast.Tree) Allocator.Error!Zir {
         astgen.extra.items[imports_index] = astgen.addExtraAssumeCapacity(Zir.Inst.Imports{
             .imports_len = @intCast(u32, astgen.imports.count()),
         });
-        astgen.extra.appendSliceAssumeCapacity(astgen.imports.keys());
+        astgen.extra.appendSliceAssumeCapacity(astgen.imports.values());
     }
     return Zir{
 @@ -261,6 +262,23 @@ fn typeExpr(gz: *GenZir, scope: *Scope, type_node: ast.Node.Index) InnerError!Zi
     return expr(gz, scope, .{ .ty = .type_type }, type_node);
 }
+/// Same as `expr` but fails with a compile error if the result type is `noreturn`.
+fn reachableExpr(
+    gz: *GenZir,
+    scope: *Scope,
+    rl: ResultLoc,
+    node: ast.Node.Index,
+    src_node: ast.Node.Index,
+) InnerError!Zir.Inst.Ref {
+    const result_inst = try expr(gz, scope, rl, node);
+    if (gz.refIsNoReturn(result_inst)) {
+        return gz.astgen.failNodeNotes(src_node, "unreachable code", .{}, &[_]u32{
+            try gz.astgen.errNoteNode(node, "control flow is diverted here", .{}),
+        });
+    }
+    return result_inst;
+}
 fn lvalExpr(gz: *GenZir, scope: *Scope, node: ast.Node.Index) InnerError!Zir.Inst.Ref {
     const astgen = gz.astgen;
     const tree = astgen.tree;
 @@ -1296,22 +1314,23 @@ fn structInitExpr(
     const astgen = gz.astgen;
     const tree = astgen.tree;
-    if (struct_init.ast.fields.len == 0) {
+    if (struct_init.ast.type_expr == 0) {
-        if (struct_init.ast.type_expr == 0) {
+        if (struct_init.ast.fields.len == 0) {
             return rvalue(gz, rl, .empty_struct, node);
         }
-        array: {
+    } else array: {
-            const node_tags = tree.nodes.items(.tag);
+        const node_tags = tree.nodes.items(.tag);
-            const main_tokens = tree.nodes.items(.main_token);
+        const main_tokens = tree.nodes.items(.main_token);
-            const array_type: ast.full.ArrayType = switch (node_tags[struct_init.ast.type_expr]) {
+        const array_type: ast.full.ArrayType = switch (node_tags[struct_init.ast.type_expr]) {
-                .array_type => tree.arrayType(struct_init.ast.type_expr),
+            .array_type => tree.arrayType(struct_init.ast.type_expr),
-                .array_type_sentinel => tree.arrayTypeSentinel(struct_init.ast.type_expr),
+            .array_type_sentinel => tree.arrayTypeSentinel(struct_init.ast.type_expr),
-                else => break :array,
+            else => break :array,
-            };
+        };
+        const is_inferred_array_len = node_tags[array_type.ast.elem_count] == .identifier and
             // This intentionally does not support `@"_"` syntax.
-            if (node_tags[array_type.ast.elem_count] == .identifier and
+            mem.eql(u8, tree.tokenSlice(main_tokens[array_type.ast.elem_count]), "_");
-                mem.eql(u8, tree.tokenSlice(main_tokens[array_type.ast.elem_count]), "_"))
+        if (struct_init.ast.fields.len == 0) {
-            {
+            if (is_inferred_array_len) {
                 const elem_type = try typeExpr(gz, scope, array_type.ast.elem_type);
                 const array_type_inst = if (array_type.ast.sentinel == 0) blk: {
                     break :blk try gz.addBin(.array_type, .zero_usize, elem_type);
 @@ -1322,11 +1341,18 @@ fn structInitExpr(
                 const result = try gz.addUnNode(.struct_init_empty, array_type_inst, node);
                 return rvalue(gz, rl, result, node);
             }
+            const ty_inst = try typeExpr(gz, scope, struct_init.ast.type_expr);
+            const result = try gz.addUnNode(.struct_init_empty, ty_inst, node);
+            return rvalue(gz, rl, result, node);
+        } else {
+            return astgen.failNode(
+                struct_init.ast.type_expr,
+                "initializing array with struct syntax",
+                .{},
+            );
         }
-        const ty_inst = try typeExpr(gz, scope, struct_init.ast.type_expr);
-        const result = try gz.addUnNode(.struct_init_empty, ty_inst, node);
-        return rvalue(gz, rl, result, node);
     }
     switch (rl) {
         .discard => {
             if (struct_init.ast.type_expr != 0)
 @@ -1570,7 +1596,7 @@ fn breakExpr(parent_gz: *GenZir, parent_scope: *Scope, node: ast.Node.Index) Inn
                 const defer_scope = scope.cast(Scope.Defer).?;
                 scope = defer_scope.parent;
                 const expr_node = node_datas[defer_scope.defer_node].rhs;
-                try unusedResultExpr(parent_gz, defer_scope.parent, expr_node);
+                _ = try unusedResultExpr(parent_gz, defer_scope.parent, expr_node);
             },
             .defer_error => scope = scope.cast(Scope.Defer).?.parent,
             .top => unreachable,
 @@ -1623,7 +1649,7 @@ fn continueExpr(parent_gz: *GenZir, parent_scope: *Scope, node: ast.Node.Index)
                 const defer_scope = scope.cast(Scope.Defer).?;
                 scope = defer_scope.parent;
                 const expr_node = node_datas[defer_scope.defer_node].rhs;
-                try unusedResultExpr(parent_gz, defer_scope.parent, expr_node);
+                _ = try unusedResultExpr(parent_gz, defer_scope.parent, expr_node);
             },
             .defer_error => scope = scope.cast(Scope.Defer).?.parent,
             .namespace => break,
 @@ -1679,7 +1705,7 @@ fn checkLabelRedefinition(astgen: *AstGen, parent_scope: *Scope, label: ast.Toke
                         }, &[_]u32{
                             try astgen.errNoteTok(
                                 prev_label.token,
-                                "previous definition is here",
+                                "previous definition here",
                                 .{},
                             ),
                         });
 @@ -1785,8 +1811,23 @@ fn blockExprStmts(gz: *GenZir, parent_scope: *Scope, statements: []const ast.Nod
     var block_arena = std.heap.ArenaAllocator.init(gz.astgen.gpa);
     defer block_arena.deinit();
+    var noreturn_src_node: ast.Node.Index = 0;
     var scope = parent_scope;
     for (statements) |statement| {
+        if (noreturn_src_node != 0) {
+            return astgen.failNodeNotes(
+                statement,
+                "unreachable code",
+                .{},
+                &[_]u32{
+                    try astgen.errNoteNode(
+                        noreturn_src_node,
+                        "control flow is diverted here",
+                        .{},
+                    ),
+                },
+            );
+        }
         switch (node_tags[statement]) {
             // zig fmt: off
             .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
             .assign_mul      => try assignOp(gz, scope, statement, .mul),
             .assign_mul_wrap => try assignOp(gz, scope, statement, .mulwrap),
-            else => try unusedResultExpr(gz, scope, statement),
+            else => noreturn_src_node = try unusedResultExpr(gz, scope, statement),
             // zig fmt: on
         }
     }
 @@ -1823,11 +1864,14 @@ fn blockExprStmts(gz: *GenZir, parent_scope: *Scope, statements: []const ast.Nod
     try checkUsed(gz, parent_scope, scope);
 }
-fn unusedResultExpr(gz: *GenZir, scope: *Scope, statement: ast.Node.Index) InnerError!void {
+/// Returns AST source node of the thing that is noreturn if the statement is definitely `noreturn`.
+/// Otherwise returns 0.
+fn unusedResultExpr(gz: *GenZir, scope: *Scope, statement: ast.Node.Index) InnerError!ast.Node.Index {
     try emitDbgNode(gz, statement);
     // We need to emit an error if the result is not `noreturn` or `void`, but
     // we want to avoid adding the ZIR instruction if possible for performance.
     const maybe_unused_result = try expr(gz, scope, .none, statement);
+    var noreturn_src_node: ast.Node.Index = 0;
     const elide_check = if (gz.refToIndex(maybe_unused_result)) |inst| b: {
         // Note that this array becomes invalid after appending more items to it
         // in the above while loop.
 @@ -2061,15 +2105,7 @@ fn unusedResultExpr(gz: *GenZir, scope: *Scope, statement: ast.Node.Index) Inner
             .extended,
             => break :b false,
-            // ZIR instructions that are always either `noreturn` or `void`.
+            // ZIR instructions that are always `noreturn`.
-            .breakpoint,
-            .fence,
-            .dbg_stmt,
-            .ensure_result_used,
-            .ensure_result_non_error,
-            .@"export",
-            .set_eval_branch_quota,
-            .ensure_err_payload_void,
             .@"break",
             .break_inline,
             .condbr,
 @@ -2078,16 +2114,30 @@ fn unusedResultExpr(gz: *GenZir, scope: *Scope, statement: ast.Node.Index) Inner
             .ret_node,
             .ret_coerce,
             .@"unreachable",
+            .repeat,
+            .repeat_inline,
+            .panic,
+            => {
+                noreturn_src_node = statement;
+                break :b true;
+            },
+            // ZIR instructions that are always `void`.
+            .breakpoint,
+            .fence,
+            .dbg_stmt,
+            .ensure_result_used,
+            .ensure_result_non_error,
+            .@"export",
+            .set_eval_branch_quota,
+            .ensure_err_payload_void,
             .store,
             .store_node,
             .store_to_block_ptr,
             .store_to_inferred_ptr,
             .resolve_inferred_alloc,
-            .repeat,
-            .repeat_inline,
             .validate_struct_init_ptr,
             .validate_array_init_ptr,
-            .panic,
             .set_align_stack,
             .set_cold,
             .set_float_mode,
 @@ -2097,15 +2147,19 @@ fn unusedResultExpr(gz: *GenZir, scope: *Scope, statement: ast.Node.Index) Inner
     } else switch (maybe_unused_result) {
         .none => unreachable,
-        .void_value,
+        .unreachable_value => b: {
-        .unreachable_value,
+            noreturn_src_node = statement;
-        => true,
+            break :b true;
+        },
+        .void_value => true,
         else => false,
     };
     if (!elide_check) {
         _ = try gz.addUnNode(.ensure_result_used, maybe_unused_result, statement);
     }
+    return noreturn_src_node;
 }
 fn genDefers(
 @@ -2132,7 +2186,7 @@ fn genDefers(
                 const prev_in_defer = gz.in_defer;
                 gz.in_defer = true;
                 defer gz.in_defer = prev_in_defer;
-                try unusedResultExpr(gz, defer_scope.parent, expr_node);
+                _ = try unusedResultExpr(gz, defer_scope.parent, expr_node);
             },
             .defer_error => {
                 const defer_scope = scope.cast(Scope.Defer).?;
 @@ -2142,7 +2196,7 @@ fn genDefers(
                 const prev_in_defer = gz.in_defer;
                 gz.in_defer = true;
                 defer gz.in_defer = prev_in_defer;
-                try unusedResultExpr(gz, defer_scope.parent, expr_node);
+                _ = try unusedResultExpr(gz, defer_scope.parent, expr_node);
             },
             .namespace => unreachable,
             .top => unreachable,
 @@ -2163,25 +2217,15 @@ fn checkUsed(
             .gen_zir => scope = scope.cast(GenZir).?.parent,
             .local_val => {
                 const s = scope.cast(Scope.LocalVal).?;
-                switch (s.used) {
+                if (!s.used) {
-                    .used => {},
+                    return astgen.failTok(s.token_src, "unused {s}", .{@tagName(s.id_cat)});
-                    .fn_param => return astgen.failTok(s.token_src, "unused function parameter", .{}),
-                    .constant => return astgen.failTok(s.token_src, "unused local constant", .{}),
-                    .variable => unreachable,
-                    .loop_index => unreachable,
-                    .capture => return astgen.failTok(s.token_src, "unused capture", .{}),
                 }
                 scope = s.parent;
             },
             .local_ptr => {
                 const s = scope.cast(Scope.LocalPtr).?;
-                switch (s.used) {
+                if (!s.used) {
-                    .used => {},
+                    return astgen.failTok(s.token_src, "unused {s}", .{@tagName(s.id_cat)});
-                    .fn_param => unreachable,
-                    .constant => return astgen.failTok(s.token_src, "unused local constant", .{}),
-                    .variable => return astgen.failTok(s.token_src, "unused local variable", .{}),
-                    .loop_index => return astgen.failTok(s.token_src, "unused loop index capture", .{}),
-                    .capture => unreachable,
                 }
                 scope = s.parent;
             },
 @@ -2221,65 +2265,13 @@ fn varDecl(
     const token_tags = tree.tokens.items(.tag);
     const name_token = var_decl.ast.mut_token + 1;
+    const ident_name_raw = tree.tokenSlice(name_token);
+    if (mem.eql(u8, ident_name_raw, "_")) {
+        return astgen.failTok(name_token, "'_' used as an identifier without @\"_\" syntax", .{});
+    }
     const ident_name = try astgen.identAsString(name_token);
-    // Local variables shadowing detection, including function parameters.
+    try astgen.detectLocalShadowing(scope, ident_name, name_token);
-    {
-        var s = scope;
-        while (true) switch (s.tag) {
-            .local_val => {
-                const local_val = s.cast(Scope.LocalVal).?;
-                if (local_val.name == ident_name) {
-                    const name = try gpa.dupe(u8, mem.spanZ(astgen.nullTerminatedString(ident_name)));
-                    defer gpa.free(name);
-                    return astgen.failTokNotes(name_token, "redeclaration of '{s}'", .{
-                        name,
-                    }, &[_]u32{
-                        try astgen.errNoteTok(
-                            local_val.token_src,
-                            "previously declared here",
-                            .{},
-                        ),
-                    });
-                }
-                s = local_val.parent;
-            },
-            .local_ptr => {
-                const local_ptr = s.cast(Scope.LocalPtr).?;
-                if (local_ptr.name == ident_name) {
-                    const name = try gpa.dupe(u8, mem.spanZ(astgen.nullTerminatedString(ident_name)));
-                    defer gpa.free(name);
-                    return astgen.failTokNotes(name_token, "redeclaration of '{s}'", .{
-                        name,
-                    }, &[_]u32{
-                        try astgen.errNoteTok(
-                            local_ptr.token_src,
-                            "previously declared here",
-                            .{},
-                        ),
-                    });
-                }
-                s = local_ptr.parent;
-            },
-            .namespace => {
-                const ns = s.cast(Scope.Namespace).?;
-                const decl_node = ns.decls.get(ident_name) orelse {
-                    s = ns.parent;
-                    continue;
-                };
-                const name = try gpa.dupe(u8, mem.spanZ(astgen.nullTerminatedString(ident_name)));
-                defer gpa.free(name);
-                return astgen.failTokNotes(name_token, "local shadows declaration of '{s}'", .{
-                    name,
-                }, &[_]u32{
-                    try astgen.errNoteNode(decl_node, "declared here", .{}),
-                });
-            },
-            .gen_zir => s = s.cast(GenZir).?.parent,
-            .defer_normal, .defer_error => s = s.cast(Scope.Defer).?.parent,
-            .top => break,
-        };
-    }
     if (var_decl.ast.init_node == 0) {
         return astgen.failNode(node, "variables must be initialized", .{});
 @@ -2303,7 +2295,8 @@ fn varDecl(
                 const result_loc: ResultLoc = if (var_decl.ast.type_node != 0) .{
                     .ty = try typeExpr(gz, scope, var_decl.ast.type_node),
                 } else .none;
-                const init_inst = try expr(gz, scope, result_loc, var_decl.ast.init_node);
+                const init_inst = try reachableExpr(gz, scope, result_loc, var_decl.ast.init_node, node);
                 const sub_scope = try block_arena.create(Scope.LocalVal);
                 sub_scope.* = .{
                     .parent = scope,
 @@ -2311,7 +2304,7 @@ fn varDecl(
                     .name = ident_name,
                     .inst = init_inst,
                     .token_src = name_token,
-                    .used = .constant,
+                    .id_cat = .@"local constant",
                 };
                 return &sub_scope.base;
             }
 @@ -2353,7 +2346,8 @@ fn varDecl(
                 init_scope.rl_ptr = alloc;
             }
             const init_result_loc: ResultLoc = .{ .block_ptr = &init_scope };
-            const init_inst = try expr(&init_scope, &init_scope.base, init_result_loc, var_decl.ast.init_node);
+            const init_inst = try reachableExpr(&init_scope, &init_scope.base, init_result_loc, var_decl.ast.init_node, node);
             const zir_tags = astgen.instructions.items(.tag);
             const zir_datas = astgen.instructions.items(.data);
 @@ -2379,7 +2373,7 @@ fn varDecl(
                     .name = ident_name,
                     .inst = init_inst,
                     .token_src = name_token,
-                    .used = .constant,
+                    .id_cat = .@"local constant",
                 };
                 return &sub_scope.base;
             }
 @@ -2409,7 +2403,7 @@ fn varDecl(
                 .ptr = init_scope.rl_ptr,
                 .token_src = name_token,
                 .maybe_comptime = true,
-                .used = .constant,
+                .id_cat = .@"local constant",
             };
             return &sub_scope.base;
         },
 @@ -2454,7 +2448,7 @@ fn varDecl(
                 resolve_inferred_alloc = alloc;
                 break :a .{ .alloc = alloc, .result_loc = .{ .inferred_ptr = alloc } };
             };
-            _ = try expr(gz, scope, var_data.result_loc, var_decl.ast.init_node);
+            _ = try reachableExpr(gz, scope, var_data.result_loc, var_decl.ast.init_node, node);
             if (resolve_inferred_alloc != .none) {
                 _ = try gz.addUnNode(.resolve_inferred_alloc, resolve_inferred_alloc, node);
             }
 @@ -2466,7 +2460,7 @@ fn varDecl(
                 .ptr = var_data.alloc,
                 .token_src = name_token,
                 .maybe_comptime = is_comptime,
-                .used = .variable,
+                .id_cat = .@"local variable",
             };
             return &sub_scope.base;
         },
 @@ -2956,7 +2950,11 @@ fn fnDecl(
             var it = fn_proto.iterate(tree.*);
             while (it.next()) |param| : (i += 1) {
                 const name_token = param.name_token orelse {
-                    return astgen.failNode(param.type_expr, "missing parameter name", .{});
+                    if (param.anytype_ellipsis3) |tok| {
+                        return astgen.failTok(tok, "missing parameter name", .{});
+                    } else {
+                        return astgen.failNode(param.type_expr, "missing parameter name", .{});
+                    }
                 };
                 if (param.type_expr != 0)
                     _ = try typeExpr(&fn_gz, params_scope, param.type_expr);
 @@ -2965,7 +2963,7 @@ fn fnDecl(
                 const param_name = try astgen.identAsString(name_token);
                 // Create an arg instruction. This is needed to emit a semantic analysis
                 // error for shadowing decls.
-                // TODO emit a compile error here for shadowing locals.
+                try astgen.detectLocalShadowing(params_scope, param_name, name_token);
                 const arg_inst = try fn_gz.addStrTok(.arg, param_name, name_token);
                 const sub_scope = try astgen.arena.create(Scope.LocalVal);
                 sub_scope.* = .{
 @@ -2974,7 +2972,7 @@ fn fnDecl(
                     .name = param_name,
                     .inst = arg_inst,
                     .token_src = name_token,
-                    .used = .fn_param,
+                    .id_cat = .@"function parameter",
                 };
                 params_scope = &sub_scope.base;
 @@ -4005,7 +4003,18 @@ fn containerDecl(
                         return astgen.failTok(comptime_token, "enum fields cannot be marked comptime", .{});
                     }
                     if (member.ast.type_expr != 0) {
-                        return astgen.failNode(member.ast.type_expr, "enum fields do not have types", .{});
+                        return astgen.failNodeNotes(
+                            member.ast.type_expr,
+                            "enum fields do not have types",
+                            .{},
+                            &[_]u32{
+                                try astgen.errNoteNode(
+                                    node,
+                                    "consider 'union(enum)' here to make it a tagged union",
+                                    .{},
+                                ),
+                            },
+                        );
                     }
                     // Alignment expressions in enums are caught by the parser.
                     assert(member.ast.align_expr == 0);
 @@ -4523,7 +4532,7 @@ fn tryExpr(
         return astgen.failNode(node, "invalid 'try' outside function scope", .{});
     };
-    if (parent_gz.in_defer) return astgen.failNode(node, "try is not allowed inside defer expression", .{});
+    if (parent_gz.in_defer) return astgen.failNode(node, "'try' not allowed inside defer expression", .{});
     var block_scope = parent_gz.makeSubBlock(scope);
     block_scope.setBreakResultLoc(rl);
 @@ -4638,7 +4647,7 @@ fn orelseCatchExpr(
             .name = err_name,
             .inst = try then_scope.addUnNode(unwrap_code_op, operand, node),
             .token_src = payload,
-            .used = .capture,
+            .id_cat = .@"capture",
         };
         break :blk &err_val_scope.base;
     };
 @@ -4930,7 +4939,7 @@ fn ifExpr(
                     .name = ident_name,
                     .inst = payload_inst,
                     .token_src = payload_token,
-                    .used = .capture,
+                    .id_cat = .@"capture",
                 };
                 break :s &payload_val_scope.base;
             } else {
 @@ -4952,7 +4961,7 @@ fn ifExpr(
                 .name = ident_name,
                 .inst = payload_inst,
                 .token_src = ident_token,
-                .used = .capture,
+                .id_cat = .@"capture",
             };
             break :s &payload_val_scope.base;
         } else {
 @@ -4993,7 +5002,7 @@ fn ifExpr(
                     .name = ident_name,
                     .inst = payload_inst,
                     .token_src = error_token,
-                    .used = .capture,
+                    .id_cat = .@"capture",
                 };
                 break :s &payload_val_scope.base;
             } else {
 @@ -5187,7 +5196,7 @@ fn whileExpr(
                     .name = ident_name,
                     .inst = payload_inst,
                     .token_src = payload_token,
-                    .used = .capture,
+                    .id_cat = .@"capture",
                 };
                 break :s &payload_val_scope.base;
             } else {
 @@ -5209,7 +5218,7 @@ fn whileExpr(
                 .name = ident_name,
                 .inst = payload_inst,
                 .token_src = ident_token,
-                .used = .capture,
+                .id_cat = .@"capture",
             };
             break :s &payload_val_scope.base;
         } else {
 @@ -5266,7 +5275,7 @@ fn whileExpr(
                     .name = ident_name,
                     .inst = payload_inst,
                     .token_src = error_token,
-                    .used = .capture,
+                    .id_cat = .@"capture",
                 };
                 break :s &payload_val_scope.base;
             } else {
 @@ -5405,7 +5414,7 @@ fn forExpr(
                 .name = name_str_index,
                 .inst = payload_inst,
                 .token_src = ident,
-                .used = .capture,
+                .id_cat = .@"capture",
             };
             payload_sub_scope = &payload_val_scope.base;
         } else if (is_ptr) {
 @@ -5429,7 +5438,7 @@ fn forExpr(
             .ptr = index_ptr,
             .token_src = index_token,
             .maybe_comptime = is_inline,
-            .used = .loop_index,
+            .id_cat = .@"loop index capture",
         };
         break :blk &index_scope.base;
     };
 @@ -5529,7 +5538,7 @@ fn switchExpr(
                     &[_]u32{
                         try astgen.errNoteTok(
                             src,
-                            "previous else prong is here",
+                            "previous else prong here",
                             .{},
                         ),
                     },
 @@ -5542,12 +5551,12 @@ fn switchExpr(
                     &[_]u32{
                         try astgen.errNoteTok(
                             case_src,
-                            "else prong is here",
+                            "else prong here",
                             .{},
                         ),
                         try astgen.errNoteTok(
                             some_underscore,
-                            "'_' prong is here",
+                            "'_' prong here",
                             .{},
                         ),
                     },
 @@ -5570,7 +5579,7 @@ fn switchExpr(
                     &[_]u32{
                         try astgen.errNoteTok(
                             src,
-                            "previous '_' prong is here",
+                            "previous '_' prong here",
                             .{},
                         ),
                     },
 @@ -5583,12 +5592,12 @@ fn switchExpr(
                     &[_]u32{
                         try astgen.errNoteTok(
                             some_else,
-                            "else prong is here",
+                            "else prong here",
                             .{},
                         ),
                         try astgen.errNoteTok(
                             case_src,
-                            "'_' prong is here",
+                            "'_' prong here",
                             .{},
                         ),
                     },
 @@ -5674,7 +5683,7 @@ fn switchExpr(
                 .name = capture_name,
                 .inst = capture,
                 .token_src = payload_token,
-                .used = .capture,
+                .id_cat = .@"capture",
             };
             break :blk &capture_val_scope.base;
         };
 @@ -5768,7 +5777,7 @@ fn switchExpr(
                 .name = capture_name,
                 .inst = capture,
                 .token_src = payload_token,
-                .used = .capture,
+                .id_cat = .@"capture",
             };
             break :blk &capture_val_scope.base;
         };
 @@ -6150,10 +6159,11 @@ fn identifier(
     const main_tokens = tree.nodes.items(.main_token);
     const ident_token = main_tokens[ident];
-    const ident_name = try astgen.identifierTokenString(ident_token);
+    const ident_name_raw = tree.tokenSlice(ident_token);
-    if (mem.eql(u8, ident_name, "_")) {
+    if (mem.eql(u8, ident_name_raw, "_")) {
-        return astgen.failNode(ident, "'_' may not be used as an identifier", .{});
+        return astgen.failNode(ident, "'_' used as an identifier without @\"_\" syntax", .{});
     }
+    const ident_name = try astgen.identifierTokenString(ident_token);
     if (simple_types.get(ident_name)) |zir_const_ref| {
         return rvalue(gz, rl, zir_const_ref, ident);
 @@ -6197,7 +6207,7 @@ fn identifier(
                 const local_val = s.cast(Scope.LocalVal).?;
                 if (local_val.name == name_str_index) {
-                    local_val.used = .used;
+                    local_val.used = true;
                     // Captures of non-locals need to be emitted as decl_val or decl_ref.
                     // This *might* be capturable depending on if it is comptime known.
                     if (!hit_namespace) {
 @@ -6209,7 +6219,7 @@ fn identifier(
             .local_ptr => {
                 const local_ptr = s.cast(Scope.LocalPtr).?;
                 if (local_ptr.name == name_str_index) {
-                    local_ptr.used = .used;
+                    local_ptr.used = true;
                     if (hit_namespace) {
                         if (local_ptr.maybe_comptime)
                             break
 @@ -6333,20 +6343,76 @@ fn charLiteral(gz: *GenZir, rl: ResultLoc, node: ast.Node.Index) !Zir.Inst.Ref {
     const main_token = main_tokens[node];
     const slice = tree.tokenSlice(main_token);
-    var bad_index: usize = undefined;
+    switch (std.zig.parseCharLiteral(slice)) {
-    const value = std.zig.parseCharLiteral(slice, &bad_index) catch |err| switch (err) {
+        .success => |codepoint| {
-        error.InvalidCharacter => {
+            const result = try gz.addInt(codepoint);
-            const bad_byte = slice[bad_index];
+            return rvalue(gz, rl, result, node);
+        },
+        .invalid_escape_character => |bad_index| {
             return astgen.failOff(
                 main_token,
                 @intCast(u32, bad_index),
-                "invalid character: '{c}'\n",
+                "invalid escape character: '{c}'",
-                .{bad_byte},
+                .{slice[bad_index]},
             );
         },
-    };
+        .expected_hex_digit => |bad_index| {
-    const result = try gz.addInt(value);
+            return astgen.failOff(
-    return rvalue(gz, rl, result, node);
+                main_token,
+                @intCast(u32, bad_index),
+                "expected hex digit, found '{c}'",
+                .{slice[bad_index]},
+            );
+        },
+        .empty_unicode_escape_sequence => |bad_index| {
+            return astgen.failOff(
+                main_token,
+                @intCast(u32, bad_index),
+                "empty unicode escape sequence",
+                .{},
+            );
+        },
+        .expected_hex_digit_or_rbrace => |bad_index| {
+            return astgen.failOff(
+                main_token,
+                @intCast(u32, bad_index),
+                "expected hex digit or '}}', found '{c}'",
+                .{slice[bad_index]},
+            );
+        },
+        .unicode_escape_overflow => |bad_index| {
+            return astgen.failOff(
+                main_token,
+                @intCast(u32, bad_index),
+                "unicode escape too large to be a valid codepoint",
+                .{},
+            );
+        },
+        .expected_lbrace => |bad_index| {
+            return astgen.failOff(
+                main_token,
+                @intCast(u32, bad_index),
+                "expected '{{', found '{c}",
+                .{slice[bad_index]},
+            );
+        },
+        .expected_end => |bad_index| {
+            return astgen.failOff(
+                main_token,
+                @intCast(u32, bad_index),
+                "expected ending single quote ('), found '{c}",
+                .{slice[bad_index]},
+            );
+        },
+        .invalid_character => |bad_index| {
+            return astgen.failOff(
+                main_token,
+                @intCast(u32, bad_index),
+                "invalid byte in character literal: '{c}'",
+                .{slice[bad_index]},
+            );
+        },
+    }
 }
 fn integerLiteral(gz: *GenZir, rl: ResultLoc, node: ast.Node.Index) InnerError!Zir.Inst.Ref {
 @@ -6489,7 +6555,7 @@ fn asmExpr(
                     .local_val => {
                         const local_val = s.cast(Scope.LocalVal).?;
                         if (local_val.name == str_index) {
-                            local_val.used = .used;
+                            local_val.used = true;
                             break;
                         }
                         s = local_val.parent;
 @@ -6497,7 +6563,7 @@ fn asmExpr(
                     .local_ptr => {
                         const local_ptr = s.cast(Scope.LocalPtr).?;
                         if (local_ptr.name == str_index) {
-                            local_ptr.used = .used;
+                            local_ptr.used = true;
                             break;
                         }
                         s = local_ptr.parent;
 @@ -6585,14 +6651,14 @@ fn as(
     const dest_type = try typeExpr(gz, scope, lhs);
     switch (rl) {
         .none, .none_or_ref, .discard, .ref, .ty => {
-            const result = try expr(gz, scope, .{ .ty = dest_type }, rhs);
+            const result = try reachableExpr(gz, scope, .{ .ty = dest_type }, rhs, node);
             return rvalue(gz, rl, result, node);
         },
         .ptr, .inferred_ptr => |result_ptr| {
-            return asRlPtr(gz, scope, rl, result_ptr, rhs, dest_type);
+            return asRlPtr(gz, scope, rl, node, result_ptr, rhs, dest_type);
         },
         .block_ptr => |block_scope| {
-            return asRlPtr(gz, scope, rl, block_scope.rl_ptr, rhs, dest_type);
+            return asRlPtr(gz, scope, rl, node, block_scope.rl_ptr, rhs, dest_type);
         },
     }
 }
 @@ -6646,6 +6712,7 @@ fn asRlPtr(
     parent_gz: *GenZir,
     scope: *Scope,
     rl: ResultLoc,
+    src_node: ast.Node.Index,
     result_ptr: Zir.Inst.Ref,
     operand_node: ast.Node.Index,
     dest_type: Zir.Inst.Ref,
 @@ -6659,7 +6726,7 @@ fn asRlPtr(
     defer as_scope.instructions.deinit(astgen.gpa);
     as_scope.rl_ptr = try as_scope.addBin(.coerce_result_ptr, dest_type, result_ptr);
-    const result = try expr(&as_scope, &as_scope.base, .{ .block_ptr = &as_scope }, operand_node);
+    const result = try reachableExpr(&as_scope, &as_scope.base, .{ .block_ptr = &as_scope }, operand_node, src_node);
     const parent_zir = &parent_gz.instructions;
     if (as_scope.rvalue_rl_count == 1) {
         // Busted! This expression didn't actually need a pointer.
 @@ -6738,13 +6805,14 @@ fn typeOf(
         return gz.astgen.failNode(node, "expected at least 1 argument, found 0", .{});
     }
     if (params.len == 1) {
-        const result = try gz.addUnNode(.typeof, try expr(gz, scope, .none, params[0]), node);
+        const expr_result = try reachableExpr(gz, scope, .none, params[0], node);
+        const result = try gz.addUnNode(.typeof, expr_result, node);
         return rvalue(gz, rl, result, node);
     }
     const arena = gz.astgen.arena;
     var items = try arena.alloc(Zir.Inst.Ref, params.len);
     for (params) |param, param_i| {
-        items[param_i] = try expr(gz, scope, .none, param);
+        items[param_i] = try reachableExpr(gz, scope, .none, param, node);
     }
     const result = try gz.addExtendedMultiOp(.typeof_peer, node, items);
 @@ -6778,7 +6846,7 @@ fn builtinCall(
     if (info.param_count) |expected| {
         if (expected != params.len) {
             const s = if (expected == 1) "" else "s";
-            return astgen.failNode(node, "expected {d} parameter{s}, found {d}", .{
+            return astgen.failNode(node, "expected {d} argument{s}, found {d}", .{
                 expected, s, params.len,
             });
         }
 @@ -6796,8 +6864,13 @@ fn builtinCall(
             }
             const str_lit_token = main_tokens[operand_node];
             const str = try astgen.strLitAsString(str_lit_token);
-            try astgen.imports.put(astgen.gpa, str.index, {});
             const result = try gz.addStrTok(.import, str.index, str_lit_token);
+            if (gz.refToIndex(result)) |import_inst_index| {
+                const gop = try astgen.imports.getOrPut(astgen.gpa, str.index);
+                if (!gop.found_existing) {
+                    gop.value_ptr.* = import_inst_index;
+                }
+            }
             return rvalue(gz, rl, result, node);
         },
         .compile_log => {
 @@ -6846,7 +6919,7 @@ fn builtinCall(
                             .local_val => {
                                 const local_val = s.cast(Scope.LocalVal).?;
                                 if (local_val.name == decl_name) {
-                                    local_val.used = .used;
+                                    local_val.used = true;
                                     break;
                                 }
                                 s = local_val.parent;
 @@ -6856,7 +6929,7 @@ fn builtinCall(
                                 if (local_ptr.name == decl_name) {
                                     if (!local_ptr.maybe_comptime)
                                         return astgen.failNode(params[0], "unable to export runtime-known value", .{});
-                                    local_ptr.used = .used;
+                                    local_ptr.used = true;
                                     break;
                                 }
                                 s = local_ptr.parent;
 @@ -8423,15 +8496,15 @@ const Scope = struct {
         top,
     };
-    // either .used or the type of the var/constant
+    /// The category of identifier. These tag names are user-visible in compile errors.
-    const Used = enum {
+    const IdCat = enum {
-        fn_param,
+        @"function parameter",
-        constant,
+        @"local constant",
-        variable,
+        @"local variable",
-        loop_index,
+        @"loop index capture",
-        capture,
+        @"capture",
-        used,
     };
     /// This is always a `const` local and importantly the `inst` is a value type, not a pointer.
     /// This structure lives as long as the AST generation of the Block
     /// node that contains the variable.
 @@ -8446,8 +8519,9 @@ const Scope = struct {
         token_src: ast.TokenIndex,
         /// String table index.
         name: u32,
-        /// has this variable been referenced?
+        id_cat: IdCat,
-        used: Used,
+        /// Track whether the name has been referenced.
+        used: bool = false,
     };
     /// This could be a `const` or `var` local. It has a pointer instead of a value.
 @@ -8464,10 +8538,12 @@ const Scope = struct {
         token_src: ast.TokenIndex,
         /// String table index.
         name: u32,
-        /// 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.
+        id_cat: IdCat,
+        /// 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.
         maybe_comptime: bool,
-        /// has this variable been referenced?
+        /// Track whether the name has been referenced.
-        used: Used,
+        used: bool = false,
     };
     const Defer = struct {
 @@ -9558,6 +9634,71 @@ fn declareNewName(
     }
 }
+/// Local variables shadowing detection, including function parameters.
+fn detectLocalShadowing(
+    astgen: *AstGen,
+    scope: *Scope,
+    ident_name: u32,
+    name_token: ast.TokenIndex,
+) !void {
+    const gpa = astgen.gpa;
+    var s = scope;
+    while (true) switch (s.tag) {
+        .local_val => {
+            const local_val = s.cast(Scope.LocalVal).?;
+            if (local_val.name == ident_name) {
+                const name = try gpa.dupe(u8, mem.spanZ(astgen.nullTerminatedString(ident_name)));
+                defer gpa.free(name);
+                return astgen.failTokNotes(name_token, "redeclaration of {s} '{s}'", .{
+                    @tagName(local_val.id_cat), name,
+                }, &[_]u32{
+                    try astgen.errNoteTok(
+                        local_val.token_src,
+                        "previous declaration here",
+                        .{},
+                    ),
+                });
+            }
+            s = local_val.parent;
+        },
+        .local_ptr => {
+            const local_ptr = s.cast(Scope.LocalPtr).?;
+            if (local_ptr.name == ident_name) {
+                const name = try gpa.dupe(u8, mem.spanZ(astgen.nullTerminatedString(ident_name)));
+                defer gpa.free(name);
+                return astgen.failTokNotes(name_token, "redeclaration of {s} '{s}'", .{
+                    @tagName(local_ptr.id_cat), name,
+                }, &[_]u32{
+                    try astgen.errNoteTok(
+                        local_ptr.token_src,
+                        "previous declaration here",
+                        .{},
+                    ),
+                });
+            }
+            s = local_ptr.parent;
+        },
+        .namespace => {
+            const ns = s.cast(Scope.Namespace).?;
+            const decl_node = ns.decls.get(ident_name) orelse {
+                s = ns.parent;
+                continue;
+            };
+            const name = try gpa.dupe(u8, mem.spanZ(astgen.nullTerminatedString(ident_name)));
+            defer gpa.free(name);
+            return astgen.failTokNotes(name_token, "local shadows declaration of '{s}'", .{
+                name,
+            }, &[_]u32{
+                try astgen.errNoteNode(decl_node, "declared here", .{}),
+            });
+        },
+        .gen_zir => s = s.cast(GenZir).?.parent,
+        .defer_normal, .defer_error => s = s.cast(Scope.Defer).?.parent,
+        .top => break,
+    };
+}
 fn advanceSourceCursor(astgen: *AstGen, source: []const u8, end: usize) void {
     var i = astgen.source_offset;
     var line = astgen.source_line;

src/Compilation.zig+87-31

 @@ -670,6 +670,7 @@ pub const InitOptions = struct {
     use_llvm: ?bool = null,
     use_lld: ?bool = null,
     use_clang: ?bool = null,
+    use_stage1: ?bool = null,
     rdynamic: bool = false,
     strip: bool = false,
     single_threaded: bool = false,
 @@ -807,8 +808,22 @@ pub fn create(gpa: *Allocator, options: InitOptions) !*Compilation {
         const ofmt = options.object_format orelse options.target.getObjectFormat();
+        const use_stage1 = options.use_stage1 orelse blk: {
+            if (build_options.omit_stage2)
+                break :blk true;
+            if (options.use_llvm) |use_llvm| {
+                if (!use_llvm) {
+                    break :blk false;
+                }
+            }
+            break :blk build_options.is_stage1;
+        };
         // Make a decision on whether to use LLVM or our own backend.
-        const use_llvm = if (options.use_llvm) |explicit| explicit else blk: {
+        const use_llvm = build_options.have_llvm and blk: {
+            if (options.use_llvm) |explicit|
+                break :blk explicit;
             // If we have no zig code to compile, no need for LLVM.
             if (options.root_pkg == null)
                 break :blk false;
 @@ -817,18 +832,24 @@ pub fn create(gpa: *Allocator, options: InitOptions) !*Compilation {
             if (ofmt == .c)
                 break :blk false;
-            // If we are the stage1 compiler, we depend on the stage1 c++ llvm backend
+            // The stage1 compiler depends on the stage1 C++ LLVM backend
             // to compile zig code.
-            if (build_options.is_stage1)
+            if (use_stage1)
+                break :blk true;
+            // Prefer LLVM for release builds as long as it supports the target architecture.
+            if (options.optimize_mode != .Debug and target_util.hasLlvmSupport(options.target))
                 break :blk true;
-            // We would want to prefer LLVM for release builds when it is available, however
-            // we don't have an LLVM backend yet :)
-            // We would also want to prefer LLVM for architectures that we don't have self-hosted support for too.
             break :blk false;
         };
-        if (!use_llvm and options.machine_code_model != .default) {
+        if (!use_llvm) {
-            return error.MachineCodeModelNotSupported;
+            if (options.use_llvm == true) {
+                return error.ZigCompilerNotBuiltWithLLVMExtensions;
+            }
+            if (options.machine_code_model != .default) {
+                return error.MachineCodeModelNotSupportedWithoutLlvm;
+            }
         }
         const tsan = options.want_tsan orelse false;
 @@ -1344,6 +1365,7 @@ pub fn create(gpa: *Allocator, options: InitOptions) !*Compilation {
             .subsystem = options.subsystem,
             .is_test = options.is_test,
             .wasi_exec_model = wasi_exec_model,
+            .use_stage1 = use_stage1,
         });
         errdefer bin_file.destroy();
         comp.* = .{
 @@ -1486,9 +1508,9 @@ pub fn create(gpa: *Allocator, options: InitOptions) !*Compilation {
             try comp.work_queue.writeItem(.libtsan);
         }
-        // The `is_stage1` condition is here only because stage2 cannot yet build compiler-rt.
+        // The `use_stage1` condition is here only because stage2 cannot yet build compiler-rt.
         // Once it is capable this condition should be removed.
-        if (build_options.is_stage1) {
+        if (comp.bin_file.options.use_stage1) {
             if (comp.bin_file.options.include_compiler_rt) {
                 if (is_exe_or_dyn_lib) {
                     try comp.work_queue.writeItem(.{ .compiler_rt_lib = {} });
 @@ -1519,7 +1541,7 @@ pub fn create(gpa: *Allocator, options: InitOptions) !*Compilation {
         }
     }
-    if (build_options.is_stage1 and comp.bin_file.options.use_llvm) {
+    if (comp.bin_file.options.use_stage1 and comp.bin_file.options.module != null) {
         try comp.work_queue.writeItem(.{ .stage1_module = {} });
     }
 @@ -1625,8 +1647,7 @@ pub fn update(self: *Compilation) !void {
         self.c_object_work_queue.writeItemAssumeCapacity(key);
     }
-    const use_stage1 = build_options.omit_stage2 or
+    const use_stage1 = build_options.is_stage1 and self.bin_file.options.use_stage1;
-        (build_options.is_stage1 and self.bin_file.options.use_llvm);
     if (self.bin_file.options.module) |module| {
         module.compile_log_text.shrinkAndFree(module.gpa, 0);
         module.generation += 1;
 @@ -1921,7 +1942,7 @@ pub fn performAllTheWork(self: *Compilation) error{ TimerUnsupported, OutOfMemor
     // (at least for now) single-threaded main work queue. However, C object compilation
     // only needs to be finished by the end of this function.
-    var zir_prog_node = main_progress_node.start("AST Lowering", self.astgen_work_queue.count);
+    var zir_prog_node = main_progress_node.start("AST Lowering", 0);
     defer zir_prog_node.end();
     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
         while (self.astgen_work_queue.readItem()) |file| {
             self.astgen_wait_group.start();
             try self.thread_pool.spawn(workerAstGenFile, .{
-                self, file, &zir_prog_node, &self.astgen_wait_group,
+                self, file, &zir_prog_node, &self.astgen_wait_group, .root,
             });
         }
 @@ -1949,13 +1970,18 @@ pub fn performAllTheWork(self: *Compilation) error{ TimerUnsupported, OutOfMemor
         }
     }
-    const use_stage1 = build_options.omit_stage2 or
+    const use_stage1 = build_options.is_stage1 and self.bin_file.options.use_stage1;
-        (build_options.is_stage1 and self.bin_file.options.use_llvm);
     if (!use_stage1) {
         // Iterate over all the files and look for outdated and deleted declarations.
         if (self.bin_file.options.module) |mod| {
             try mod.processOutdatedAndDeletedDecls();
         }
+    } else if (self.bin_file.options.module) |mod| {
+        // If there are any AstGen compile errors, report them now to avoid
+        // hitting stage1 bugs.
+        if (mod.failed_files.count() != 0) {
+            return;
+        }
     }
     while (self.work_queue.readItem()) |work_item| switch (work_item) {
 @@ -2284,11 +2310,20 @@ pub fn performAllTheWork(self: *Compilation) error{ TimerUnsupported, OutOfMemor
     };
 }
+const AstGenSrc = union(enum) {
+    root,
+    import: struct {
+        importing_file: *Module.Scope.File,
+        import_inst: Zir.Inst.Index,
+    },
+};
 fn workerAstGenFile(
     comp: *Compilation,
     file: *Module.Scope.File,
     prog_node: *std.Progress.Node,
     wg: *WaitGroup,
+    src: AstGenSrc,
 ) void {
     defer wg.finish();
 @@ -2301,7 +2336,7 @@ fn workerAstGenFile(
         error.AnalysisFail => return,
         else => {
             file.status = .retryable_failure;
-            comp.reportRetryableAstGenError(file, err) catch |oom| switch (oom) {
+            comp.reportRetryableAstGenError(src, file, err) catch |oom| switch (oom) {
                 // Swallowing this error is OK because it's implied to be OOM when
                 // there is a missing `failed_files` error message.
                 error.OutOfMemory => {},
 @@ -2318,8 +2353,9 @@ fn workerAstGenFile(
     if (imports_index != 0) {
         const imports_len = file.zir.extra[imports_index];
-        for (file.zir.extra[imports_index + 1 ..][0..imports_len]) |str_index| {
+        for (file.zir.extra[imports_index + 1 ..][0..imports_len]) |import_inst| {
-            const import_path = file.zir.nullTerminatedString(str_index);
+            const inst_data = file.zir.instructions.items(.data)[import_inst].str_tok;
+            const import_path = inst_data.get(file.zir);
             const import_result = blk: {
                 const lock = comp.mutex.acquire();
 @@ -2331,9 +2367,13 @@ fn workerAstGenFile(
                 log.debug("AstGen of {s} has import '{s}'; queuing AstGen of {s}", .{
                     file.sub_file_path, import_path, import_result.file.sub_file_path,
                 });
+                const sub_src: AstGenSrc = .{ .import = .{
+                    .importing_file = file,
+                    .import_inst = import_inst,
+                } };
                 wg.start();
                 comp.thread_pool.spawn(workerAstGenFile, .{
-                    comp, import_result.file, prog_node, wg,
+                    comp, import_result.file, prog_node, wg, sub_src,
                 }) catch {
                     wg.finish();
                     continue;
 @@ -2544,6 +2584,7 @@ fn reportRetryableCObjectError(
 fn reportRetryableAstGenError(
     comp: *Compilation,
+    src: AstGenSrc,
     file: *Module.Scope.File,
     err: anyerror,
 ) error{OutOfMemory}!void {
 @@ -2552,22 +2593,38 @@ fn reportRetryableAstGenError(
     file.status = .retryable_failure;
-    const src_loc: Module.SrcLoc = .{
+    const src_loc: Module.SrcLoc = switch (src) {
-        .file_scope = file,
+        .root => .{
-        .parent_decl_node = 0,
+            .file_scope = file,
-        .lazy = .entire_file,
+            .parent_decl_node = 0,
+            .lazy = .entire_file,
+        },
+        .import => |info| blk: {
+            const importing_file = info.importing_file;
+            const import_inst = info.import_inst;
+            const inst_data = importing_file.zir.instructions.items(.data)[import_inst].str_tok;
+            break :blk .{
+                .file_scope = importing_file,
+                .parent_decl_node = 0,
+                .lazy = .{ .token_offset = inst_data.src_tok },
+            };
+        },
     };
     const err_msg = if (file.pkg.root_src_directory.path) |dir_path|
         try Module.ErrorMsg.create(
             gpa,
             src_loc,
-            "unable to load {s}" ++ std.fs.path.sep_str ++ "{s}: {s}",
+            "unable to load '{'}" ++ std.fs.path.sep_str ++ "{'}': {s}",
-            .{ dir_path, file.sub_file_path, @errorName(err) },
+            .{
+                std.zig.fmtEscapes(dir_path),
+                std.zig.fmtEscapes(file.sub_file_path),
+                @errorName(err),
+            },
         )
     else
-        try Module.ErrorMsg.create(gpa, src_loc, "unable to load {s}: {s}", .{
+        try Module.ErrorMsg.create(gpa, src_loc, "unable to load '{'}': {s}", .{
-            file.sub_file_path, @errorName(err),
+            std.zig.fmtEscapes(file.sub_file_path), @errorName(err),
         });
     errdefer err_msg.destroy(gpa);
 @@ -3486,8 +3543,7 @@ pub fn generateBuiltinZigSource(comp: *Compilation, allocator: *Allocator) Alloc
     const target = comp.getTarget();
     const generic_arch_name = target.cpu.arch.genericName();
-    const use_stage1 = build_options.omit_stage2 or
+    const use_stage1 = build_options.is_stage1 and comp.bin_file.options.use_stage1;
-        (build_options.is_stage1 and comp.bin_file.options.use_llvm);
     @setEvalBranchQuota(4000);
     try buffer.writer().print(

src/Module.zig+10

 @@ -2466,6 +2466,7 @@ pub fn astGenFile(mod: *Module, file: *Scope.File) !void {
         defer msg.deinit();
         const token_starts = file.tree.tokens.items(.start);
+        const token_tags = file.tree.tokens.items(.tag);
         try file.tree.renderError(parse_err, msg.writer());
         const err_msg = try gpa.create(ErrorMsg);
 @@ -2477,6 +2478,15 @@ pub fn astGenFile(mod: *Module, file: *Scope.File) !void {
             },
             .msg = msg.toOwnedSlice(),
         };
+        if (token_tags[parse_err.token] == .invalid) {
+            const bad_off = @intCast(u32, file.tree.tokenSlice(parse_err.token).len);
+            const byte_abs = token_starts[parse_err.token] + bad_off;
+            try mod.errNoteNonLazy(.{
+                .file_scope = file,
+                .parent_decl_node = 0,
+                .lazy = .{ .byte_abs = byte_abs },
+            }, err_msg, "invalid byte: '{'}'", .{std.zig.fmtEscapes(source[byte_abs..][0..1])});
+        }
         {
             const lock = comp.mutex.acquire();

src/Zir.zig+12-5

 @@ -139,9 +139,15 @@ pub fn renderAsTextToFile(
     if (imports_index != 0) {
         try fs_file.writeAll("Imports:\n");
         const imports_len = scope_file.zir.extra[imports_index];
-        for (scope_file.zir.extra[imports_index + 1 ..][0..imports_len]) |str_index| {
+        for (scope_file.zir.extra[imports_index + 1 ..][0..imports_len]) |import_inst| {
-            const import_path = scope_file.zir.nullTerminatedString(str_index);
+            const inst_data = writer.code.instructions.items(.data)[import_inst].str_tok;
-            try fs_file.writer().print("  {s}\n", .{import_path});
+            const src = inst_data.src();
+            const import_path = inst_data.get(writer.code);
+            try fs_file.writer().print("  @import(\"{}\") ", .{
+                std.zig.fmtEscapes(import_path),
+            });
+            try writer.writeSrc(fs_file.writer(), src);
+            try fs_file.writer().writeAll("\n");
         }
     }
 }
 @@ -2767,9 +2773,10 @@ pub const Inst = struct {
         };
     };
-    /// Trailing: for each `imports_len` there is a string table index.
+    /// Trailing: for each `imports_len` there is an instruction index
+    /// to an import instruction.
     pub const Imports = struct {
-        imports_len: u32,
+        imports_len: Zir.Inst.Index,
     };
 };

src/link.zig+3-2

src/link/MachO.zig+1-1

...	@@ -606,7 +606,7 @@ fn linkWithZld(self: MachO, comp: Compilation) !void {	...	@@ -606,7 +606,7 @@ fn linkWithZld(self: MachO, comp: Compilation) !void {
606	// If there is no Zig code to compile, then we should skip flushing the output file because it	606	// If there is no Zig code to compile, then we should skip flushing the output file because it
607	// will not be part of the linker line anyway.	607	// will not be part of the linker line anyway.
608	const module_obj_path: ?[]const u8 = if (self.base.options.module) \|module\| blk: {	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	if (use_stage1) {	610	if (use_stage1) {
611	const obj_basename = try std.zig.binNameAlloc(arena, .{	611	const obj_basename = try std.zig.binNameAlloc(arena, .{
612	.root_name = self.base.options.root_name,	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,7 +556,7 @@ fn linkWithLLD(self: Wasm, comp: Compilation) !void {
556	// If there is no Zig code to compile, then we should skip flushing the output file because it	556	// If there is no Zig code to compile, then we should skip flushing the output file because it
557	// will not be part of the linker line anyway.	557	// will not be part of the linker line anyway.
558	const module_obj_path: ?[]const u8 = if (self.base.options.module) \|module\| blk: {	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	if (use_stage1) {	560	if (use_stage1) {
561	const obj_basename = try std.zig.binNameAlloc(arena, .{	561	const obj_basename = try std.zig.binNameAlloc(arena, .{
562	.root_name = self.base.options.root_name,	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
     } else if (mem.eql(u8, cmd, "build")) {
         return cmdBuild(gpa, arena, cmd_args);
     } else if (mem.eql(u8, cmd, "fmt")) {
-        return cmdFmt(gpa, cmd_args);
+        return cmdFmt(gpa, arena, cmd_args);
     } else if (mem.eql(u8, cmd, "libc")) {
         return cmdLibC(gpa, cmd_args);
     } else if (mem.eql(u8, cmd, "init-exe")) {
 @@ -350,9 +350,11 @@ const usage_build_generic =
     \\  -funwind-tables           Always produce unwind table entries for all functions
     \\  -fno-unwind-tables        Never produce unwind table entries
     \\  -fLLVM                    Force using LLVM as the codegen backend
-    \\  -fno-LLVM                 Prevent using LLVM as a codegen backend
+    \\  -fno-LLVM                 Prevent using LLVM as the codegen backend
     \\  -fClang                   Force using Clang as the C/C++ compilation backend
     \\  -fno-Clang                Prevent using Clang as the C/C++ compilation backend
+    \\  -fstage1                  Force using bootstrap compiler as the codegen backend
+    \\  -fno-stage1               Prevent using bootstrap compiler as the codegen backend
     \\  --strip                   Omit debug symbols
     \\  --single-threaded         Code assumes it is only used single-threaded
     \\  -ofmt=[mode]              Override target object format
 @@ -602,6 +604,7 @@ fn buildOutputType(
     var use_llvm: ?bool = null;
     var use_lld: ?bool = null;
     var use_clang: ?bool = null;
+    var use_stage1: ?bool = null;
     var link_eh_frame_hdr = false;
     var link_emit_relocs = false;
     var each_lib_rpath: ?bool = null;
 @@ -975,6 +978,10 @@ fn buildOutputType(
                         use_clang = true;
                     } else if (mem.eql(u8, arg, "-fno-Clang")) {
                         use_clang = false;
+                    } else if (mem.eql(u8, arg, "-fstage1")) {
+                        use_stage1 = true;
+                    } else if (mem.eql(u8, arg, "-fno-stage1")) {
+                        use_stage1 = false;
                     } else if (mem.eql(u8, arg, "-rdynamic")) {
                         rdynamic = true;
                     } else if (mem.eql(u8, arg, "-fsoname")) {
 @@ -2020,6 +2027,7 @@ fn buildOutputType(
         .use_llvm = use_llvm,
         .use_lld = use_lld,
         .use_clang = use_clang,
+        .use_stage1 = use_stage1,
         .rdynamic = rdynamic,
         .linker_script = linker_script,
         .version_script = version_script,
 @@ -3031,12 +3039,13 @@ const Fmt = struct {
     check_ast: bool,
     color: Color,
     gpa: *Allocator,
+    arena: *Allocator,
     out_buffer: std.ArrayList(u8),
     const SeenMap = std.AutoHashMap(fs.File.INode, void);
 };
-pub fn cmdFmt(gpa: *Allocator, args: []const []const u8) !void {
+pub fn cmdFmt(gpa: *Allocator, arena: *Allocator, args: []const []const u8) !void {
     var color: Color = .auto;
     var stdin_flag: bool = false;
     var check_flag: bool = false;
 @@ -3094,7 +3103,7 @@ pub fn cmdFmt(gpa: *Allocator, args: []const []const u8) !void {
         defer tree.deinit(gpa);
         for (tree.errors) |parse_error| {
-            try printErrMsgToStdErr(gpa, parse_error, tree, "<stdin>", color);
+            try printErrMsgToStdErr(gpa, arena, parse_error, tree, "<stdin>", color);
         }
         var has_ast_error = false;
         if (check_ast_flag) {
 @@ -3162,6 +3171,7 @@ pub fn cmdFmt(gpa: *Allocator, args: []const []const u8) !void {
     var fmt = Fmt{
         .gpa = gpa,
+        .arena = arena,
         .seen = Fmt.SeenMap.init(gpa),
         .any_error = false,
         .check_ast = check_ast_flag,
 @@ -3285,7 +3295,7 @@ fn fmtPathFile(
     defer tree.deinit(fmt.gpa);
     for (tree.errors) |parse_error| {
-        try printErrMsgToStdErr(fmt.gpa, parse_error, tree, file_path, fmt.color);
+        try printErrMsgToStdErr(fmt.gpa, fmt.arena, parse_error, tree, file_path, fmt.color);
     }
     if (tree.errors.len != 0) {
         fmt.any_error = true;
 @@ -3366,12 +3376,14 @@ fn fmtPathFile(
 fn printErrMsgToStdErr(
     gpa: *mem.Allocator,
+    arena: *mem.Allocator,
     parse_error: ast.Error,
     tree: ast.Tree,
     path: []const u8,
     color: Color,
 ) !void {
     const lok_token = parse_error.token;
+    const token_tags = tree.tokens.items(.tag);
     const start_loc = tree.tokenLocation(0, lok_token);
     const source_line = tree.source[start_loc.line_start..start_loc.line_end];
 @@ -3381,6 +3393,27 @@ fn printErrMsgToStdErr(
     try tree.renderError(parse_error, writer);
     const text = text_buf.items;
+    var notes_buffer: [1]Compilation.AllErrors.Message = undefined;
+    var notes_len: usize = 0;
+    if (token_tags[parse_error.token] == .invalid) {
+        const bad_off = @intCast(u32, tree.tokenSlice(parse_error.token).len);
+        const byte_offset = @intCast(u32, start_loc.line_start) + bad_off;
+        notes_buffer[notes_len] = .{
+            .src = .{
+                .src_path = path,
+                .msg = try std.fmt.allocPrint(arena, "invalid byte: '{'}'", .{
+                    std.zig.fmtEscapes(tree.source[byte_offset..][0..1]),
+                }),
+                .byte_offset = byte_offset,
+                .line = @intCast(u32, start_loc.line),
+                .column = @intCast(u32, start_loc.column) + bad_off,
+                .source_line = source_line,
+            },
+        };
+        notes_len += 1;
+    }
     const message: Compilation.AllErrors.Message = .{
         .src = .{
             .src_path = path,
 @@ -3389,6 +3422,7 @@ fn printErrMsgToStdErr(
             .line = @intCast(u32, start_loc.line),
             .column = @intCast(u32, start_loc.column),
             .source_line = source_line,
+            .notes = notes_buffer[0..notes_len],
         },
     };
 @@ -3915,7 +3949,7 @@ pub fn cmdAstCheck(
     defer file.tree.deinit(gpa);
     for (file.tree.errors) |parse_error| {
-        try printErrMsgToStdErr(gpa, parse_error, file.tree, file.sub_file_path, color);
+        try printErrMsgToStdErr(gpa, arena, parse_error, file.tree, file.sub_file_path, color);
     }
     if (file.tree.errors.len != 0) {
         process.exit(1);
 @@ -4041,7 +4075,7 @@ pub fn cmdChangelist(
     defer file.tree.deinit(gpa);
     for (file.tree.errors) |parse_error| {
-        try printErrMsgToStdErr(gpa, parse_error, file.tree, old_source_file, .auto);
+        try printErrMsgToStdErr(gpa, arena, parse_error, file.tree, old_source_file, .auto);
     }
     if (file.tree.errors.len != 0) {
         process.exit(1);
 @@ -4080,7 +4114,7 @@ pub fn cmdChangelist(
     defer new_tree.deinit(gpa);
     for (new_tree.errors) |parse_error| {
-        try printErrMsgToStdErr(gpa, parse_error, new_tree, new_source_file, .auto);
+        try printErrMsgToStdErr(gpa, arena, parse_error, new_tree, new_source_file, .auto);
     }
     if (new_tree.errors.len != 0) {
         process.exit(1);

src/stage1.zig+9-4

 @@ -7,6 +7,7 @@ const assert = std.debug.assert;
 const mem = std.mem;
 const CrossTarget = std.zig.CrossTarget;
 const Target = std.Target;
+const builtin = @import("builtin");
 const build_options = @import("build_options");
 const stage2 = @import("main.zig");
 @@ -16,16 +17,19 @@ const translate_c = @import("translate_c.zig");
 const target_util = @import("target.zig");
 comptime {
-    assert(std.builtin.link_libc);
+    assert(builtin.link_libc);
     assert(build_options.is_stage1);
     assert(build_options.have_llvm);
-    _ = @import("compiler_rt");
+    if (!builtin.is_test) {
+        _ = @import("compiler_rt");
+        @export(main, .{ .name = "main" });
+    }
 }
 pub const log = stage2.log;
 pub const log_level = stage2.log_level;
-pub export fn main(argc: c_int, argv: [*][*:0]u8) c_int {
+pub fn main(argc: c_int, argv: [*][*:0]u8) callconv(.C) c_int {
     std.os.argv = argv[0..@intCast(usize, argc)];
     std.debug.maybeEnableSegfaultHandler();
 @@ -41,7 +45,7 @@ pub export fn main(argc: c_int, argv: [*][*:0]u8) c_int {
     for (args) |*arg, i| {
         arg.* = mem.spanZ(argv[i]);
     }
-    if (std.builtin.mode == .Debug) {
+    if (builtin.mode == .Debug) {
         stage2.mainArgs(gpa, arena, args) catch unreachable;
     } else {
         stage2.mainArgs(gpa, arena, args) catch |err| fatal("{s}", .{@errorName(err)});
 @@ -147,6 +151,7 @@ pub const Module = extern struct {
     }
 };
+pub const os_init = zig_stage1_os_init;
 extern fn zig_stage1_os_init() void;
 pub const create = zig_stage1_create;

src/stage1/all_types.hpp-4

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

src/stage1/analyze.cpp+3-3

src/stage1/astgen.cpp+74-81

src/stage1/ir.cpp+9-19

src/stage1/ir_print.cpp-2

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

src/target.zig+67

...	@@ -170,6 +170,73 @@ pub fn hasValgrindSupport(target: std.Target) bool {	...	@@ -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	pub fn supportsStackProbing(target: std.Target) bool {	240	pub fn supportsStackProbing(target: std.Target) bool {
174	return target.os.tag != .windows and target.os.tag != .uefi and	241	return target.os.tag != .windows and target.os.tag != .uefi and
175	(target.cpu.arch == .i386 or target.cpu.arch == .x86_64);	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,18 +10,25 @@ const enable_wine: bool = build_options.enable_wine;
10	const enable_wasmtime: bool = build_options.enable_wasmtime;	10	const enable_wasmtime: bool = build_options.enable_wasmtime;
11	const enable_darling: bool = build_options.enable_darling;	11	const enable_darling: bool = build_options.enable_darling;
12	const glibc_multi_install_dir: ?[]const u8 = build_options.glibc_multi_install_dir;	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	const ThreadPool = @import("ThreadPool.zig");	14	const ThreadPool = @import("ThreadPool.zig");
14	const CrossTarget = std.zig.CrossTarget;	15	const CrossTarget = std.zig.CrossTarget;
		16	const print = std.debug.print;
		17	const assert = std.debug.assert;
15		18
16	const zig_h = link.File.C.zig_h;	19	const zig_h = link.File.C.zig_h;
17		20
18	const hr = "=" ** 80;	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	var ctx = TestContext.init();	28	var ctx = TestContext.init();
22	defer ctx.deinit();	29	defer ctx.deinit();
23		30
24	try @import("stage2_tests").addCases(&ctx);	31	try @import("test_cases").addCases(&ctx);
25		32
26	try ctx.run();	33	try ctx.run();
27	}	34	}
...	@@ -30,7 +37,11 @@ const ErrorMsg = union(enum) {	...	@@ -30,7 +37,11 @@ const ErrorMsg = union(enum) {
30	src: struct {	37	src: struct {
31	src_path: []const u8,	38	src_path: []const u8,
32	msg: []const u8,	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	line: u32,	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	column: u32,	45	column: u32,
35	kind: Kind,	46	kind: Kind,
36	},	47	},
...	@@ -74,23 +85,32 @@ const ErrorMsg = union(enum) {	...	@@ -74,23 +85,32 @@ const ErrorMsg = union(enum) {
74	_ = options;	85	_ = options;
75	switch (self) {	86	switch (self) {
76	.src => \|src\| {	87	.src => \|src\| {
77	return writer.print("{s}:{d}:{d}: {s}: {s}", .{	88	if (!std.mem.eql(u8, src.src_path, "?") or
78	src.src_path,	89	src.line != std.math.maxInt(u32) or
79	src.line + 1,	90	src.column != std.math.maxInt(u32))
80	src.column + 1,	91	{
81	@tagName(src.kind),	92	try writer.print("{s}:", .{src.src_path});
82	src.msg,	93	if (src.line != std.math.maxInt(u32)) {
83	});	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	.plain => \|plain\| {	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	pub const TestContext = struct {	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	cases: std.ArrayList(Case),	114	cases: std.ArrayList(Case),
95		115
96	pub const Update = struct {	116	pub const Update = struct {
...	@@ -127,6 +147,12 @@ pub const TestContext = struct {	...	@@ -127,6 +147,12 @@ pub const TestContext = struct {
127	path: []const u8,	147	path: []const u8,
128	};	148	};
129		149
		150	pub const Backend = enum {
		151	stage1,
		152	stage2,
		153	llvm,
		154	};
		155
130	/// A `Case` consists of a list of `Update`. The same `Compilation` is used for each	156	/// A `Case` consists of a list of `Update`. The same `Compilation` is used for each
131	/// update, so each update's source is treated as a single file being	157	/// update, so each update's source is treated as a single file being
132	/// updated by the test harness and incrementally compiled.	158	/// updated by the test harness and incrementally compiled.
...	@@ -140,13 +166,20 @@ pub const TestContext = struct {	...	@@ -140,13 +166,20 @@ pub const TestContext = struct {
140	/// In order to be able to run e.g. Execution updates, this must be set	166	/// In order to be able to run e.g. Execution updates, this must be set
141	/// to Executable.	167	/// to Executable.
142	output_mode: std.builtin.OutputMode,	168	output_mode: std.builtin.OutputMode,
		169	optimize_mode: std.builtin.Mode = .Debug,
143	updates: std.ArrayList(Update),	170	updates: std.ArrayList(Update),
144	object_format: ?std.Target.ObjectFormat = null,	171	object_format: ?std.Target.ObjectFormat = null,
145	emit_h: bool = false,	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	files: std.ArrayList(File),	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	/// Adds a subcase in which the module is updated with `src`, and a C	183	/// Adds a subcase in which the module is updated with `src`, and a C
151	/// header is generated.	184	/// header is generated.
152	pub fn addHeader(self: *Case, src: [:0]const u8, result: [:0]const u8) void {	185	pub fn addHeader(self: *Case, src: [:0]const u8, result: [:0]const u8) void {
...	@@ -201,8 +234,14 @@ pub const TestContext = struct {	...	@@ -201,8 +234,14 @@ pub const TestContext = struct {
201	const kind_text = it.next() orelse @panic("missing 'error'/'note'");	234	const kind_text = it.next() orelse @panic("missing 'error'/'note'");
202	const msg = it.rest()[1..]; // skip over the space at end of "error: "	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");	237	const line: ?u32 = if (std.mem.eql(u8, line_text, "?"))
205	const column = std.fmt.parseInt(u32, col_text, 10) catch @panic("bad column number");	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	const kind: ErrorMsg.Kind = if (std.mem.eql(u8, kind_text, " error"))	245	const kind: ErrorMsg.Kind = if (std.mem.eql(u8, kind_text, " error"))
207	.@"error"	246	.@"error"
208	else if (std.mem.eql(u8, kind_text, " note"))	247	else if (std.mem.eql(u8, kind_text, " note"))
...	@@ -210,16 +249,28 @@ pub const TestContext = struct {	...	@@ -210,16 +249,28 @@ pub const TestContext = struct {
210	else	249	else
211	@panic("expected 'error'/'note'");	250	@panic("expected 'error'/'note'");
212		251
213	if (line == 0 or column == 0) {	252	const line_0based: u32 = if (line) \|n\| blk: {
214	@panic("line and column must be specified starting at one");	253	if (n == 0) {
215	}	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	array[i] = .{	268	array[i] = .{
218	.src = .{	269	.src = .{
219	.src_path = src_path,	270	.src_path = src_path,
220	.msg = msg,	271	.msg = msg,
221	.line = line - 1,	272	.line = line_0based,
222	.column = column - 1,	273	.column = column_0based,
223	.kind = kind,	274	.kind = kind,
224	},	275	},
225	};	276	};
...	@@ -254,11 +305,6 @@ pub const TestContext = struct {	...	@@ -254,11 +305,6 @@ pub const TestContext = struct {
254	return ctx.addExe(name, target);	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	pub fn exeFromCompiledC(ctx: TestContext, name: []const u8, target: CrossTarget) Case {	308	pub fn exeFromCompiledC(ctx: TestContext, name: []const u8, target: CrossTarget) Case {
263	const prefixed_name = std.fmt.allocPrint(ctx.cases.allocator, "CBE: {s}", .{name}) catch	309	const prefixed_name = std.fmt.allocPrint(ctx.cases.allocator, "CBE: {s}", .{name}) catch
264	@panic("out of memory");	310	@panic("out of memory");
...	@@ -282,7 +328,7 @@ pub const TestContext = struct {	...	@@ -282,7 +328,7 @@ pub const TestContext = struct {
282	.updates = std.ArrayList(Update).init(ctx.cases.allocator),	328	.updates = std.ArrayList(Update).init(ctx.cases.allocator),
283	.output_mode = .Exe,	329	.output_mode = .Exe,
284	.files = std.ArrayList(File).init(ctx.cases.allocator),	330	.files = std.ArrayList(File).init(ctx.cases.allocator),
285	.llvm_backend = true,	331	.backend = .llvm,
286	}) catch @panic("out of memory");	332	}) catch @panic("out of memory");
287	return &ctx.cases.items[ctx.cases.items.len - 1];	333	return &ctx.cases.items[ctx.cases.items.len - 1];
288	}	334	}
...	@@ -302,6 +348,22 @@ pub const TestContext = struct {	...	@@ -302,6 +348,22 @@ pub const TestContext = struct {
302	return &ctx.cases.items[ctx.cases.items.len - 1];	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	/// Adds a test case for Zig input, producing an object file.	367	/// Adds a test case for Zig input, producing an object file.
306	pub fn obj(ctx: TestContext, name: []const u8, target: CrossTarget) Case {	368	pub fn obj(ctx: TestContext, name: []const u8, target: CrossTarget) Case {
307	return ctx.addObj(name, target);	369	return ctx.addObj(name, target);
...	@@ -333,6 +395,45 @@ pub const TestContext = struct {	...	@@ -333,6 +395,45 @@ pub const TestContext = struct {
333	ctx.addC(name, target).addHeader(src, zig_h ++ out);	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	pub fn addCompareOutput(	437	pub fn addCompareOutput(
337	ctx: *TestContext,	438	ctx: *TestContext,
338	name: []const u8,	439	name: []const u8,
...	@@ -386,18 +487,6 @@ pub const TestContext = struct {	...	@@ -386,18 +487,6 @@ pub const TestContext = struct {
386	ctx.addTransform(name, target, src, result);	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	pub fn addError(	490	pub fn addError(
402	ctx: *TestContext,	491	ctx: *TestContext,
403	name: []const u8,	492	name: []const u8,
...	@@ -555,7 +644,7 @@ pub const TestContext = struct {	...	@@ -555,7 +644,7 @@ pub const TestContext = struct {
555	continue;	644	continue;
556		645
557	// Skip tests that require LLVM backend when it is not available	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	continue;	648	continue;
560		649
561	var prg_node = root_node.start(case.name, case.updates.items.len);	650	var prg_node = root_node.start(case.name, case.updates.items.len);
...	@@ -567,7 +656,7 @@ pub const TestContext = struct {	...	@@ -567,7 +656,7 @@ pub const TestContext = struct {
567	progress.initial_delay_ns = 0;	656	progress.initial_delay_ns = 0;
568	progress.refresh_rate_ns = 0;	657	progress.refresh_rate_ns = 0;
569		658
570	self.runOneCase(	659	runOneCase(
571	std.testing.allocator,	660	std.testing.allocator,
572	&prg_node,	661	&prg_node,
573	case,	662	case,
...	@@ -576,17 +665,16 @@ pub const TestContext = struct {	...	@@ -576,17 +665,16 @@ pub const TestContext = struct {
576	global_cache_directory,	665	global_cache_directory,
577	) catch \|err\| {	666	) catch \|err\| {
578	fail_count += 1;	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	if (fail_count != 0) {	671	if (fail_count != 0) {
583	std.debug.print("{d} tests failed\n", .{fail_count});	672	print("{d} tests failed\n", .{fail_count});
584	return error.TestFailed;	673	return error.TestFailed;
585	}	674	}
586	}	675	}
587		676
588	fn runOneCase(	677	fn runOneCase(
589	self: *TestContext,
590	allocator: *Allocator,	678	allocator: *Allocator,
591	root_node: *std.Progress.Node,	679	root_node: *std.Progress.Node,
592	case: Case,	680	case: Case,
...	@@ -594,7 +682,6 @@ pub const TestContext = struct {	...	@@ -594,7 +682,6 @@ pub const TestContext = struct {
594	thread_pool: *ThreadPool,	682	thread_pool: *ThreadPool,
595	global_cache_directory: Compilation.Directory,	683	global_cache_directory: Compilation.Directory,
596	) !void {	684	) !void {
597	_ = self;
598	const target_info = try std.zig.system.NativeTargetInfo.detect(allocator, case.target);	685	const target_info = try std.zig.system.NativeTargetInfo.detect(allocator, case.target);
599	const target = target_info.target;	686	const target = target_info.target;
600		687
...	@@ -607,14 +694,155 @@ pub const TestContext = struct {	...	@@ -607,14 +694,155 @@ pub const TestContext = struct {
607		694
608	var cache_dir = try tmp.dir.makeOpenPath("zig-cache", .{});	695	var cache_dir = try tmp.dir.makeOpenPath("zig-cache", .{});
609	defer cache_dir.close();	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	const zig_cache_directory: Compilation.Directory = .{	841	const zig_cache_directory: Compilation.Directory = .{
612	.handle = cache_dir,	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	var root_pkg: Package = .{	846	var root_pkg: Package = .{
619	.root_src_directory = .{ .path = tmp_dir_path, .handle = tmp.dir },	847	.root_src_directory = .{ .path = tmp_dir_path, .handle = tmp.dir },
620	.root_src_path = tmp_src_path,	848	.root_src_path = tmp_src_path,
...	@@ -640,6 +868,14 @@ pub const TestContext = struct {	...	@@ -640,6 +868,14 @@ pub const TestContext = struct {
640	.directory = emit_directory,	868	.directory = emit_directory,
641	.basename = "test_case.h",	869	.basename = "test_case.h",
642	} else null;	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	const comp = try Compilation.create(allocator, .{	879	const comp = try Compilation.create(allocator, .{
644	.local_cache_directory = zig_cache_directory,	880	.local_cache_directory = zig_cache_directory,
645	.global_cache_directory = global_cache_directory,	881	.global_cache_directory = global_cache_directory,
...	@@ -651,8 +887,8 @@ pub const TestContext = struct {	...	@@ -651,8 +887,8 @@ pub const TestContext = struct {
651	// and linking. This will require a rework to support multi-file	887	// and linking. This will require a rework to support multi-file
652	// tests.	888	// tests.
653	.output_mode = case.output_mode,	889	.output_mode = case.output_mode,
654	// TODO: support testing optimizations	890	.is_test = case.is_test,
655	.optimize_mode = .Debug,	891	.optimize_mode = case.optimize_mode,
656	.emit_bin = emit_bin,	892	.emit_bin = emit_bin,
657	.emit_h = emit_h,	893	.emit_h = emit_h,
658	.root_pkg = &root_pkg,	894	.root_pkg = &root_pkg,
...	@@ -661,17 +897,13 @@ pub const TestContext = struct {	...	@@ -661,17 +897,13 @@ pub const TestContext = struct {
661	.is_native_os = case.target.isNativeOs(),	897	.is_native_os = case.target.isNativeOs(),
662	.is_native_abi = case.target.isNativeAbi(),	898	.is_native_abi = case.target.isNativeAbi(),
663	.dynamic_linker = target_info.dynamic_linker.get(),	899	.dynamic_linker = target_info.dynamic_linker.get(),
664	.link_libc = case.llvm_backend,	900	.link_libc = case.backend == .llvm,
665	.use_llvm = case.llvm_backend,	901	.use_llvm = use_llvm,
666	.use_lld = case.llvm_backend,	902	.use_stage1 = use_stage1,
667	.self_exe_path = std.testing.zig_exe_path,	903	.self_exe_path = std.testing.zig_exe_path,
668	});	904	});
669	defer comp.destroy();	905	defer comp.destroy();
670		906
671	for (case.files.items) \|file\| {
672	try tmp.dir.writeFile(file.path, file.src);
673	}
674
675	for (case.updates.items) \|update, update_index\| {	907	for (case.updates.items) \|update, update_index\| {
676	var update_node = root_node.start("update", 3);	908	var update_node = root_node.start("update", 3);
677	update_node.activate();	909	update_node.activate();
...	@@ -692,19 +924,19 @@ pub const TestContext = struct {	...	@@ -692,19 +924,19 @@ pub const TestContext = struct {
692	var all_errors = try comp.getAllErrorsAlloc();	924	var all_errors = try comp.getAllErrorsAlloc();
693	defer all_errors.deinit(allocator);	925	defer all_errors.deinit(allocator);
694	if (all_errors.list.len != 0) {	926	if (all_errors.list.len != 0) {
695	std.debug.print(	927	print(
696	"\nCase '{s}': unexpected errors at update_index={d}:\n{s}\n",	928	"\nCase '{s}': unexpected errors at update_index={d}:\n{s}\n",
697	.{ case.name, update_index, hr },	929	.{ case.name, update_index, hr },
698	);	930	);
699	for (all_errors.list) \|err_msg\| {	931	for (all_errors.list) \|err_msg\| {
700	switch (err_msg) {	932	switch (err_msg) {
701	.src => \|src\| {	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	src.src_path, src.line + 1, src.column + 1, src.msg, hr,	935	src.src_path, src.line + 1, src.column + 1, src.msg, hr,
704	});	936	});
705	},	937	},
706	.plain => \|plain\| {	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,10 +989,20 @@ pub const TestContext = struct {
757	const src_path_ok = case_msg.src.src_path.len == 0 or	989	const src_path_ok = case_msg.src.src_path.len == 0 or
758	std.mem.eql(u8, case_msg.src.src_path, actual_msg.src_path);	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	if (src_path_ok and	1000	if (src_path_ok and
761	actual_msg.line == case_msg.src.line and	1001	(case_msg.src.line == std.math.maxInt(u32) or
762	actual_msg.column == case_msg.src.column and	1002	actual_msg.line == case_msg.src.line) and
763	std.mem.eql(u8, case_msg.src.msg, actual_msg.msg) 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	case_msg.src.kind == .@"error")	1006	case_msg.src.kind == .@"error")
765	{	1007	{
766	handled_errors[i] = true;	1008	handled_errors[i] = true;
...	@@ -779,7 +1021,7 @@ pub const TestContext = struct {	...	@@ -779,7 +1021,7 @@ pub const TestContext = struct {
779	},	1021	},
780	}	1022	}
781	} else {	1023	} else {
782	std.debug.print(	1024	print(
783	"\nUnexpected error:\n{s}\n{}\n{s}",	1025	"\nUnexpected error:\n{s}\n{}\n{s}",
784	.{ hr, ErrorMsg.init(actual_error, .@"error"), hr },	1026	.{ hr, ErrorMsg.init(actual_error, .@"error"), hr },
785	);	1027	);
...	@@ -796,9 +1038,19 @@ pub const TestContext = struct {	...	@@ -796,9 +1038,19 @@ pub const TestContext = struct {
796	}	1038	}
797	if (ex_tag != .src) continue;	1039	if (ex_tag != .src) continue;
798		1040
799	if (actual_msg.line == case_msg.src.line and	1041	const expected_msg = try std.mem.replaceOwned(
800	actual_msg.column == case_msg.src.column and	1042	u8,
801	std.mem.eql(u8, case_msg.src.msg, actual_msg.msg) and	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	case_msg.src.kind == .note)	1054	case_msg.src.kind == .note)
803	{	1055	{
804	handled_errors[i] = true;	1056	handled_errors[i] = true;
...	@@ -817,7 +1069,7 @@ pub const TestContext = struct {	...	@@ -817,7 +1069,7 @@ pub const TestContext = struct {
817	},	1069	},
818	}	1070	}
819	} else {	1071	} else {
820	std.debug.print(	1072	print(
821	"\nUnexpected note:\n{s}\n{}\n{s}",	1073	"\nUnexpected note:\n{s}\n{}\n{s}",
822	.{ hr, ErrorMsg.init(note.*, .note), hr },	1074	.{ hr, ErrorMsg.init(note.*, .note), hr },
823	);	1075	);
...	@@ -827,7 +1079,7 @@ pub const TestContext = struct {	...	@@ -827,7 +1079,7 @@ pub const TestContext = struct {
827		1079
828	for (handled_errors) \|handled, i\| {	1080	for (handled_errors) \|handled, i\| {
829	if (!handled) {	1081	if (!handled) {
830	std.debug.print(	1082	print(
831	"\nExpected error not found:\n{s}\n{}\n{s}",	1083	"\nExpected error not found:\n{s}\n{}\n{s}",
832	.{ hr, case_error_list[i], hr },	1084	.{ hr, case_error_list[i], hr },
833	);	1085	);
...	@@ -836,7 +1088,7 @@ pub const TestContext = struct {	...	@@ -836,7 +1088,7 @@ pub const TestContext = struct {
836	}	1088	}
837		1089
838	if (any_failed) {	1090	if (any_failed) {
839	std.debug.print("\nupdate_index={d} ", .{update_index});	1091	print("\nupdate_index={d} ", .{update_index});
840	return error.WrongCompileErrors;	1092	return error.WrongCompileErrors;
841	}	1093	}
842	},	1094	},
...	@@ -932,7 +1184,7 @@ pub const TestContext = struct {	...	@@ -932,7 +1184,7 @@ pub const TestContext = struct {
932	.cwd_dir = tmp.dir,	1184	.cwd_dir = tmp.dir,
933	.cwd = tmp_dir_path,	1185	.cwd = tmp_dir_path,
934	}) catch \|err\| {	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	update_index, @errorName(err),	1188	update_index, @errorName(err),
937	});	1189	});
938	dumpArgs(argv.items);	1190	dumpArgs(argv.items);
...	@@ -947,7 +1199,7 @@ pub const TestContext = struct {	...	@@ -947,7 +1199,7 @@ pub const TestContext = struct {
947	switch (exec_result.term) {	1199	switch (exec_result.term) {
948	.Exited => \|code\| {	1200	.Exited => \|code\| {
949	if (code != 0) {	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	exec_result.stderr, case.name, code,	1203	exec_result.stderr, case.name, code,
952	});	1204	});
953	dumpArgs(argv.items);	1205	dumpArgs(argv.items);
...	@@ -955,7 +1207,7 @@ pub const TestContext = struct {	...	@@ -955,7 +1207,7 @@ pub const TestContext = struct {
955	}	1207	}
956	},	1208	},
957	else => {	1209	else => {
958	std.debug.print("\n{s}\n{s}: execution crashed:\n", .{	1210	print("\n{s}\n{s}: execution crashed:\n", .{
959	exec_result.stderr, case.name,	1211	exec_result.stderr, case.name,
960	});	1212	});
961	dumpArgs(argv.items);	1213	dumpArgs(argv.items);
...	@@ -974,7 +1226,9 @@ pub const TestContext = struct {	...	@@ -974,7 +1226,9 @@ pub const TestContext = struct {
974		1226
975	fn dumpArgs(argv: []const []const u8) void {	1227	fn dumpArgs(argv: []const []const u8) void {
976	for (argv) \|arg\| {	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,7 +754,7 @@ pub fn render(gpa: *Allocator, nodes: []const Node) !std.zig.ast.Tree {
754	});	754	});
755		755
756	return std.zig.ast.Tree{	756	return std.zig.ast.Tree{
757	.source = ctx.buf.toOwnedSlice(),	757	.source = try ctx.buf.toOwnedSliceSentinel(0),
758	.tokens = ctx.tokens.toOwnedSlice(),	758	.tokens = ctx.tokens.toOwnedSlice(),
759	.nodes = ctx.nodes.toOwnedSlice(),	759	.nodes = ctx.nodes.toOwnedSlice(),
760	.extra_data = ctx.extra_data.toOwnedSlice(gpa),	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 @@
-const tests = @import("tests.zig");
 const std = @import("std");
+const TestContext = @import("../src/test.zig").TestContext;
-pub fn addCases(cases: *tests.CompileErrorContext) void {
+pub fn addCases(ctx: *TestContext) !void {
-    cases.add("std.fmt error for unused arguments",
+    ctx.exeErrStage1("std.fmt error for unused arguments",
         \\pub fn main() !void {
         \\    @import("std").debug.print("{d} {d} {d} {d} {d}", .{1,2,3,4,5,6,7,8,9,10,11,12,13,14,15});
         \\}
     , &.{
-        \\error: 10 unused arguments in "{d} {d} {d} {d} {d}"
+        "?:?:?: error: 10 unused arguments in '{d} {d} {d} {d} {d}'",
     });
-    cases.add("lazy pointer with undefined element type",
+    ctx.objErrStage1("lazy pointer with undefined element type",
         \\export fn foo() void {
         \\    comptime var T: type = undefined;
         \\    const S = struct { x: *T };
         \\    const I = @typeInfo(S);
+        \\    _ = I;
         \\}
     , &[_][]const u8{
-        "tmp.zig:3:28: error: use of undefined value here causes undefined behavior",
+        ":3:28: error: use of undefined value here causes undefined behavior",
     });
-    cases.add("pointer arithmetic on pointer-to-array",
+    ctx.objErrStage1("pointer arithmetic on pointer-to-array",
         \\export fn foo() void {
         \\    var x: [10]u8 = undefined;
         \\    var y = &x;
         \\    var z = y + 1;
+        \\    _ = z;
         \\}
     , &[_][]const u8{
         "tmp.zig:4:17: error: integer value 1 cannot be coerced to type '*[10]u8'",
     });
-    cases.add("pointer attributes checked when coercing pointer to anon literal",
+    ctx.objErrStage1("pointer attributes checked when coercing pointer to anon literal",
         \\comptime {
         \\    const c: [][]const u8 = &.{"hello", "world" };
+        \\    _ = c;
         \\}
         \\comptime {
         \\    const c: *[2][]const u8 = &.{"hello", "world" };
+        \\    _ = c;
         \\}
         \\const S = struct {a: u8 = 1, b: u32 = 2};
         \\comptime {
         \\    const c: *S = &.{};
+        \\    _ = c;
         \\}
     , &[_][]const u8{
         "tmp.zig:2:31: error: expected type '[][]const u8', found '*const struct:2:31'",
-        "tmp.zig:5:33: error: expected type '*[2][]const u8', found '*const struct:5:33'",
+        "tmp.zig:6:33: error: expected type '*[2][]const u8', found '*const struct:6:33'",
-        "tmp.zig:9:21: error: expected type '*S', found '*const struct:9:21'",
+        "tmp.zig:11:21: error: expected type '*S', found '*const struct:11:21'",
     });
-    cases.add("@Type() union payload is undefined",
+    ctx.objErrStage1("@Type() union payload is undefined",
         \\const Foo = @Type(@import("std").builtin.TypeInfo{
         \\    .Struct = undefined,
         \\});
 @@ -56,7 +61,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         "tmp.zig:1:50: error: use of undefined value here causes undefined behavior",
     });
-    cases.add("wrong initializer for union payload of type 'type'",
+    ctx.objErrStage1("wrong initializer for union payload of type 'type'",
         \\const U = union(enum) {
         \\    A: type,
         \\};
 @@ -71,7 +76,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         "tmp.zig:9:8: error: use of undefined value here causes undefined behavior",
     });
-    cases.add("union with too small explicit signed tag type",
+    ctx.objErrStage1("union with too small explicit signed tag type",
         \\const U = union(enum(i2)) {
         \\    A: u8,
         \\    B: u8,
 @@ -86,7 +91,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         "tmp.zig:1:22: note: type i2 cannot fit values in range 0...3",
     });
-    cases.add("union with too small explicit unsigned tag type",
+    ctx.objErrStage1("union with too small explicit unsigned tag type",
         \\const U = union(enum(u2)) {
         \\    A: u8,
         \\    B: u8,
 @@ -102,56 +107,60 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         "tmp.zig:1:22: note: type u2 cannot fit values in range 0...4",
     });
-    cases.addCase(x: {
+    {
-        var tc = cases.create("callconv(.Interrupt) on unsupported platform",
+        const case = ctx.obj("callconv(.Interrupt) on unsupported platform", .{
+            .cpu_arch = .aarch64,
+            .os_tag = .linux,
+            .abi = .none,
+        });
+        case.backend = .stage1;
+        case.addError(
             \\export fn entry() callconv(.Interrupt) void {}
         , &[_][]const u8{
             "tmp.zig:1:28: error: callconv 'Interrupt' is only available on x86, x86_64, AVR, and MSP430, not aarch64",
         });
-        tc.target = std.zig.CrossTarget{
+    }
-            .cpu_arch = .aarch64,
+    {
+        var case = ctx.obj("callconv(.Signal) on unsupported platform", .{
+            .cpu_arch = .x86_64,
             .os_tag = .linux,
             .abi = .none,
-        };
+        });
-        break :x tc;
+        case.backend = .stage1;
-    });
+        case.addError(
-    cases.addCase(x: {
-        var tc = cases.create("callconv(.Signal) on unsupported platform",
             \\export fn entry() callconv(.Signal) void {}
         , &[_][]const u8{
             "tmp.zig:1:28: error: callconv 'Signal' is only available on AVR, not x86_64",
         });
-        tc.target = std.zig.CrossTarget{
+    }
+    {
+        const case = ctx.obj("callconv(.Stdcall, .Fastcall, .Thiscall) on unsupported platform", .{
             .cpu_arch = .x86_64,
             .os_tag = .linux,
             .abi = .none,
-        };
+        });
-        break :x tc;
+        case.backend = .stage1;
-    });
+        case.addError(
-    cases.addCase(x: {
-        var tc = cases.create("callconv(.Stdcall, .Fastcall, .Thiscall) on unsupported platform",
             \\const F1 = fn () callconv(.Stdcall) void;
             \\const F2 = fn () callconv(.Fastcall) void;
             \\const F3 = fn () callconv(.Thiscall) void;
-            \\export fn entry1() void { var a: F1 = undefined; }
+            \\export fn entry1() void { var a: F1 = undefined; _ = a; }
-            \\export fn entry2() void { var a: F2 = undefined; }
+            \\export fn entry2() void { var a: F2 = undefined; _ = a; }
-            \\export fn entry3() void { var a: F3 = undefined; }
+            \\export fn entry3() void { var a: F3 = undefined; _ = a; }
         , &[_][]const u8{
             "tmp.zig:1:27: error: callconv 'Stdcall' is only available on x86, not x86_64",
             "tmp.zig:2:27: error: callconv 'Fastcall' is only available on x86, not x86_64",
             "tmp.zig:3:27: error: callconv 'Thiscall' is only available on x86, not x86_64",
         });
-        tc.target = std.zig.CrossTarget{
+    }
+    {
+        const case = ctx.obj("callconv(.Stdcall, .Fastcall, .Thiscall) on unsupported platform", .{
             .cpu_arch = .x86_64,
             .os_tag = .linux,
             .abi = .none,
-        };
+        });
-        break :x tc;
+        case.backend = .stage1;
-    });
+        case.addError(
-    cases.addCase(x: {
-        var tc = cases.create("callconv(.Stdcall, .Fastcall, .Thiscall) on unsupported platform",
             \\export fn entry1() callconv(.Stdcall) void {}
             \\export fn entry2() callconv(.Fastcall) void {}
             \\export fn entry3() callconv(.Thiscall) void {}
 @@ -160,30 +169,28 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
             "tmp.zig:2:29: error: callconv 'Fastcall' is only available on x86, not x86_64",
             "tmp.zig:3:29: error: callconv 'Thiscall' is only available on x86, not x86_64",
         });
-        tc.target = std.zig.CrossTarget{
+    }
+    {
+        const case = ctx.obj("callconv(.Vectorcall) on unsupported platform", .{
             .cpu_arch = .x86_64,
             .os_tag = .linux,
             .abi = .none,
-        };
+        });
-        break :x tc;
+        case.backend = .stage1;
-    });
+        case.addError(
-    cases.addCase(x: {
-        var tc = cases.create("callconv(.Vectorcall) on unsupported platform",
             \\export fn entry() callconv(.Vectorcall) void {}
         , &[_][]const u8{
             "tmp.zig:1:28: error: callconv 'Vectorcall' is only available on x86 and AArch64, not x86_64",
         });
-        tc.target = std.zig.CrossTarget{
+    }
+    {
+        const case = ctx.obj("callconv(.APCS, .AAPCS, .AAPCSVFP) on unsupported platform", .{
             .cpu_arch = .x86_64,
             .os_tag = .linux,
             .abi = .none,
-        };
+        });
-        break :x tc;
+        case.backend = .stage1;
-    });
+        case.addError(
-    cases.addCase(x: {
-        var tc = cases.create("callconv(.APCS, .AAPCS, .AAPCSVFP) on unsupported platform",
             \\export fn entry1() callconv(.APCS) void {}
             \\export fn entry2() callconv(.AAPCS) void {}
             \\export fn entry3() callconv(.AAPCSVFP) void {}
 @@ -192,15 +199,9 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
             "tmp.zig:2:29: error: callconv 'AAPCS' is only available on ARM, not x86_64",
             "tmp.zig:3:29: error: callconv 'AAPCSVFP' is only available on ARM, not x86_64",
         });
-        tc.target = std.zig.CrossTarget{
+    }
-            .cpu_arch = .x86_64,
-            .os_tag = .linux,
-            .abi = .none,
-        };
-        break :x tc;
-    });
-    cases.add("unreachable executed at comptime",
+    ctx.objErrStage1("unreachable executed at comptime",
         \\fn foo(comptime x: i32) i32 {
         \\    comptime {
         \\        if (x >= 0) return -x;
 @@ -215,7 +216,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         "tmp.zig:8:12: note: called from here",
     });
-    cases.add("@Type with TypeInfo.Int",
+    ctx.objErrStage1("@Type with TypeInfo.Int",
         \\const builtin = @import("std").builtin;
         \\export fn entry() void {
         \\    _ = @Type(builtin.TypeInfo.Int {
 @@ -227,7 +228,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         "tmp.zig:3:36: error: expected type 'std.builtin.TypeInfo', found 'std.builtin.Int'",
     });
-    cases.add("indexing a undefined slice at comptime",
+    ctx.objErrStage1("indexing a undefined slice at comptime",
         \\comptime {
         \\    var slice: []u8 = undefined;
         \\    slice[0] = 2;
 @@ -236,7 +237,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         "tmp.zig:3:10: error: index 0 outside slice of size 0",
     });
-    cases.add("array in c exported function",
+    ctx.objErrStage1("array in c exported function",
         \\export fn zig_array(x: [10]u8) void {
         \\try expect(std.mem.eql(u8, &x, "1234567890"));
         \\}
 @@ -249,7 +250,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         "tmp.zig:5:30: error: return type '[10]u8' not allowed in function with calling convention 'C'",
     });
-    cases.add("@Type for exhaustive enum with undefined tag type",
+    ctx.objErrStage1("@Type for exhaustive enum with undefined tag type",
         \\const TypeInfo = @import("std").builtin.TypeInfo;
         \\const Tag = @Type(.{
         \\    .Enum = .{
 @@ -267,19 +268,20 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         "tmp.zig:2:20: error: use of undefined value here causes undefined behavior",
     });
-    cases.add("extern struct with non-extern-compatible integer tag type",
+    ctx.objErrStage1("extern struct with non-extern-compatible integer tag type",
         \\pub const E = enum(u31) { A, B, C };
         \\pub const S = extern struct {
         \\    e: E,
         \\};
         \\export fn entry() void {
         \\    const s: S = undefined;
+        \\    _ = s;
         \\}
     , &[_][]const u8{
         "tmp.zig:3:5: error: extern structs cannot contain fields of type 'E'",
     });
-    cases.add("@Type for exhaustive enum with non-integer tag type",
+    ctx.objErrStage1("@Type for exhaustive enum with non-integer tag type",
         \\const TypeInfo = @import("std").builtin.TypeInfo;
         \\const Tag = @Type(.{
         \\    .Enum = .{
 @@ -297,7 +299,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         "tmp.zig:2:20: error: TypeInfo.Enum.tag_type must be an integer type, not 'bool'",
     });
-    cases.add("extern struct with extern-compatible but inferred integer tag type",
+    ctx.objErrStage1("extern struct with extern-compatible but inferred integer tag type",
         \\pub const E = enum {
         \\@"0",@"1",@"2",@"3",@"4",@"5",@"6",@"7",@"8",@"9",@"10",@"11",@"12",
         \\@"13",@"14",@"15",@"16",@"17",@"18",@"19",@"20",@"21",@"22",@"23",
 @@ -333,12 +335,13 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         \\export fn entry() void {
         \\    if (@typeInfo(E).Enum.tag_type != u8) @compileError("did not infer u8 tag type");
         \\    const s: S = undefined;
+        \\    _ = s;
         \\}
     , &[_][]const u8{
         "tmp.zig:31:5: error: extern structs cannot contain fields of type 'E'",
     });
-    cases.add("@Type for tagged union with extra enum field",
+    ctx.objErrStage1("@Type for tagged union with extra enum field",
         \\const TypeInfo = @import("std").builtin.TypeInfo;
         \\const Tag = @Type(.{
         \\    .Enum = .{
 @@ -373,7 +376,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         "tmp.zig:27:24: note: referenced here",
     });
-    cases.add("field access of opaque type",
+    ctx.objErrStage1("field access of opaque type",
         \\const MyType = opaque {};
         \\
         \\export fn entry() bool {
 @@ -388,16 +391,17 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         "tmp.zig:9:13: error: no member named 'blah' in opaque type 'MyType'",
     });
-    cases.add("opaque type with field",
+    ctx.objErrStage1("opaque type with field",
         \\const Opaque = opaque { foo: i32 };
         \\export fn entry() void {
         \\    const foo: ?*Opaque = null;
+        \\    _ = foo;
         \\}
     , &[_][]const u8{
         "tmp.zig:1:25: error: opaque types cannot have fields",
     });
-    cases.add("@Type(.Fn) with is_generic = true",
+    ctx.objErrStage1("@Type(.Fn) with is_generic = true",
         \\const Foo = @Type(.{
         \\    .Fn = .{
         \\        .calling_convention = .Unspecified,
 @@ -413,7 +417,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         "tmp.zig:1:20: error: TypeInfo.Fn.is_generic must be false for @Type",
     });
-    cases.add("@Type(.Fn) with is_var_args = true and non-C callconv",
+    ctx.objErrStage1("@Type(.Fn) with is_var_args = true and non-C callconv",
         \\const Foo = @Type(.{
         \\    .Fn = .{
         \\        .calling_convention = .Unspecified,
 @@ -429,7 +433,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         "tmp.zig:1:20: error: varargs functions must have C calling convention",
     });
-    cases.add("@Type(.Fn) with return_type = null",
+    ctx.objErrStage1("@Type(.Fn) with return_type = null",
         \\const Foo = @Type(.{
         \\    .Fn = .{
         \\        .calling_convention = .Unspecified,
 @@ -445,7 +449,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         "tmp.zig:1:20: error: TypeInfo.Fn.return_type must be non-null for @Type",
     });
-    cases.add("@Type for union with opaque field",
+    ctx.objErrStage1("@Type for union with opaque field",
         \\const TypeInfo = @import("std").builtin.TypeInfo;
         \\const Untagged = @Type(.{
         \\    .Union = .{
 @@ -465,23 +469,25 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         "tmp.zig:13:17: note: referenced here",
     });
-    cases.add("slice sentinel mismatch",
+    ctx.objErrStage1("slice sentinel mismatch",
         \\export fn entry() void {
         \\    const x = @import("std").meta.Vector(3, f32){ 25, 75, 5, 0 };
+        \\    _ = x;
         \\}
     , &[_][]const u8{
         "tmp.zig:2:62: error: index 3 outside vector of size 3",
     });
-    cases.add("slice sentinel mismatch",
+    ctx.objErrStage1("slice sentinel mismatch",
         \\export fn entry() void {
         \\    const y: [:1]const u8 = &[_:2]u8{ 1, 2 };
+        \\    _ = y;
         \\}
     , &[_][]const u8{
         "tmp.zig:2:37: error: expected type '[:1]const u8', found '*const [2:2]u8'",
     });
-    cases.add("@Type for union with zero fields",
+    ctx.objErrStage1("@Type for union with zero fields",
         \\const TypeInfo = @import("std").builtin.TypeInfo;
         \\const Untagged = @Type(.{
         \\    .Union = .{
 @@ -499,7 +505,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         "tmp.zig:11:17: note: referenced here",
     });
-    cases.add("@Type for exhaustive enum with zero fields",
+    ctx.objErrStage1("@Type for exhaustive enum with zero fields",
         \\const TypeInfo = @import("std").builtin.TypeInfo;
         \\const Tag = @Type(.{
         \\    .Enum = .{
 @@ -518,7 +524,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         "tmp.zig:12:9: note: referenced here",
     });
-    cases.add("@Type for tagged union with extra union field",
+    ctx.objErrStage1("@Type for tagged union with extra union field",
         \\const TypeInfo = @import("std").builtin.TypeInfo;
         \\const Tag = @Type(.{
         \\    .Enum = .{
 @@ -554,7 +560,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         "tmp.zig:27:24: note: referenced here",
     });
-    cases.add("@Type with undefined",
+    ctx.objErrStage1("@Type with undefined",
         \\comptime {
         \\    _ = @Type(.{ .Array = .{ .len = 0, .child = u8, .sentinel = undefined } });
         \\}
 @@ -573,7 +579,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         "tmp.zig:5:16: error: use of undefined value here causes undefined behavior",
     });
-    cases.add("struct with declarations unavailable for @Type",
+    ctx.objErrStage1("struct with declarations unavailable for @Type",
         \\export fn entry() void {
         \\    _ = @Type(@typeInfo(struct { const foo = 1; }));
         \\}
 @@ -581,7 +587,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         "tmp.zig:2:15: error: TypeInfo.Struct.decls must be empty for @Type",
     });
-    cases.add("enum with declarations unavailable for @Type",
+    ctx.objErrStage1("enum with declarations unavailable for @Type",
         \\export fn entry() void {
         \\    _ = @Type(@typeInfo(enum { foo, const bar = 1; }));
         \\}
 @@ -589,36 +595,44 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         "tmp.zig:2:15: error: TypeInfo.Enum.decls must be empty for @Type",
     });
-    cases.addTest("reject extern variables with initializers",
+    ctx.testErrStage1("reject extern variables with initializers",
         \\extern var foo: int = 2;
     , &[_][]const u8{
-        "tmp.zig:1:1: error: extern variables have no initializers",
+        "tmp.zig:1:23: error: extern variables have no initializers",
     });
-    cases.addTest("duplicate/unused labels",
+    ctx.testErrStage1("duplicate/unused labels",
         \\comptime {
         \\    blk: { blk: while (false) {} }
+        \\}
+        \\comptime {
         \\    blk: while (false) { blk: for (@as([0]void, undefined)) |_| {} }
+        \\}
+        \\comptime {
         \\    blk: for (@as([0]void, undefined)) |_| { blk: {} }
         \\}
         \\comptime {
         \\    blk: {}
+        \\}
+        \\comptime {
         \\    blk: while(false) {}
+        \\}
+        \\comptime {
         \\    blk: for(@as([0]void, undefined)) |_| {}
         \\}
     , &[_][]const u8{
-        "tmp.zig:2:17: error: redeclaration of label 'blk'",
+        "tmp.zig:2:12: error: redefinition of label 'blk'",
-        "tmp.zig:2:10: note: previous declaration is here",
+        "tmp.zig:2:5: note: previous definition here",
-        "tmp.zig:3:31: error: redeclaration of label 'blk'",
+        "tmp.zig:5:26: error: redefinition of label 'blk'",
-        "tmp.zig:3:10: note: previous declaration is here",
+        "tmp.zig:5:5: note: previous definition here",
-        "tmp.zig:4:51: error: redeclaration of label 'blk'",
+        "tmp.zig:8:46: error: redefinition of label 'blk'",
-        "tmp.zig:4:10: note: previous declaration is here",
+        "tmp.zig:8:5: note: previous definition here",
-        "tmp.zig:7:10: error: unused block label",
+        "tmp.zig:11:5: error: unused block label",
-        "tmp.zig:8:10: error: unused while label",
+        "tmp.zig:14:5: error: unused while loop label",
-        "tmp.zig:9:10: error: unused for label",
+        "tmp.zig:17:5: error: unused for loop label",
     });
-    cases.addTest("@alignCast of zero sized types",
+    ctx.testErrStage1("@alignCast of zero sized types",
         \\export fn foo() void {
         \\    const a: *void = undefined;
         \\    _ = @alignCast(2, a);
 @@ -633,7 +647,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         \\}
         \\export fn qux() void {
         \\    const a = struct {
-        \\        fn a(comptime b: u32) void {}
+        \\        fn a(comptime b: u32) void { _ = b; }
         \\    }.a;
         \\    _ = @alignCast(2, a);
         \\}
 @@ -644,7 +658,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         "tmp.zig:17:23: error: cannot adjust alignment of zero sized type 'fn(u32) anytype'",
     });
-    cases.addTest("invalid non-exhaustive enum to union",
+    ctx.testErrStage1("invalid non-exhaustive enum to union",
         \\const E = enum(u8) {
         \\    a,
         \\    b,
 @@ -657,17 +671,19 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         \\export fn foo() void {
         \\    var e = @intToEnum(E, 15);
         \\    var u: U = e;
+        \\    _ = u;
         \\}
         \\export fn bar() void {
         \\    const e = @intToEnum(E, 15);
         \\    var u: U = e;
+        \\    _ = u;
         \\}
     , &[_][]const u8{
         "tmp.zig:12:16: error: runtime cast to union 'U' from non-exhustive enum",
-        "tmp.zig:16:16: error: no tag by value 15",
+        "tmp.zig:17:16: error: no tag by value 15",
     });
-    cases.addTest("switching with exhaustive enum has '_' prong ",
+    ctx.testErrStage1("switching with exhaustive enum has '_' prong ",
         \\const E = enum{
         \\    a,
         \\    b,
 @@ -684,7 +700,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         "tmp.zig:7:5: error: switch on exhaustive enum has `_` prong",
     });
-    cases.addTest("invalid pointer with @Type",
+    ctx.testErrStage1("invalid pointer with @Type",
         \\export fn entry() void {
         \\    _ = @Type(.{ .Pointer = .{
         \\        .size = .One,
 @@ -700,7 +716,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         "tmp.zig:2:16: error: sentinels are only allowed on slices and unknown-length pointers",
     });
-    cases.addTest("helpful return type error message",
+    ctx.testErrStage1("helpful return type error message",
         \\export fn foo() u32 {
         \\    return error.Ohno;
         \\}
 @@ -728,7 +744,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         "tmp.zig:14:5: note: cannot store an error in type 'u32'",
     });
-    cases.addTest("int/float conversion to comptime_int/float",
+    ctx.testErrStage1("int/float conversion to comptime_int/float",
         \\export fn foo() void {
         \\    var a: f32 = 2;
         \\    _ = @floatToInt(comptime_int, a);
 @@ -744,16 +760,16 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         "tmp.zig:7:9: note: referenced here",
     });
-    cases.add("extern variable has no type",
+    ctx.objErrStage1("extern variable has no type",
         \\extern var foo;
         \\pub export fn entry() void {
         \\    foo;
         \\}
     , &[_][]const u8{
-        "tmp.zig:1:1: error: unable to infer variable type",
+        "tmp.zig:1:8: error: unable to infer variable type",
     });
-    cases.add("@src outside function",
+    ctx.objErrStage1("@src outside function",
         \\comptime {
         \\    @src();
         \\}
 @@ -761,7 +777,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         "tmp.zig:2:5: error: @src outside function",
     });
-    cases.add("call assigned to constant",
+    ctx.objErrStage1("call assigned to constant",
         \\const Foo = struct {
         \\    x: i32,
         \\};
 @@ -784,15 +800,15 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         "tmp.zig:16:14: error: cannot assign to constant",
     });
-    cases.add("invalid pointer syntax",
+    ctx.objErrStage1("invalid pointer syntax",
         \\export fn foo() void {
         \\    var guid: *:0 const u8 = undefined;
         \\}
     , &[_][]const u8{
-        "tmp.zig:2:15: error: sentinels are only allowed on unknown-length pointers",
+        "tmp.zig:2:16: error: expected type expression, found ':'",
     });
-    cases.add("declaration between fields",
+    ctx.objErrStage1("declaration between fields",
         \\const S = struct {
         \\    const foo = 2;
         \\    const bar = 2;
 @@ -810,16 +826,16 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         "tmp.zig:6:5: error: declarations are not allowed between container fields",
     });
-    cases.add("non-extern function with var args",
+    ctx.objErrStage1("non-extern function with var args",
         \\fn foo(args: ...) void {}
         \\export fn entry() void {
         \\    foo();
         \\}
     , &[_][]const u8{
-        "tmp.zig:1:1: error: non-extern function is variadic",
+        "tmp.zig:1:14: error: expected type expression, found '...'",
     });
-    cases.addTest("invalid int casts",
+    ctx.testErrStage1("invalid int casts",
         \\export fn foo() void {
         \\    var a: u32 = 2;
         \\    _ = @intCast(comptime_int, a);
 @@ -847,7 +863,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         "tmp.zig:15:9: note: referenced here",
     });
-    cases.addTest("invalid float casts",
+    ctx.testErrStage1("invalid float casts",
         \\export fn foo() void {
         \\    var a: f32 = 2;
         \\    _ = @floatCast(comptime_float, a);
 @@ -875,7 +891,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         "tmp.zig:15:9: note: referenced here",
     });
-    cases.addTest("invalid assignments",
+    ctx.testErrStage1("invalid assignments",
         \\export fn entry1() void {
         \\    var a: []const u8 = "foo";
         \\    a[0..2] = "bar";
 @@ -893,7 +909,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         "tmp.zig:10:7: error: invalid left-hand side to assignment",
     });
-    cases.addTest("reassign to array parameter",
+    ctx.testErrStage1("reassign to array parameter",
         \\fn reassign(a: [3]f32) void {
         \\    a = [3]f32{4, 5, 6};
         \\}
 @@ -904,7 +920,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         "tmp.zig:2:15: error: cannot assign to constant",
     });
-    cases.addTest("reassign to slice parameter",
+    ctx.testErrStage1("reassign to slice parameter",
         \\pub fn reassign(s: []const u8) void {
         \\    s = s[0..];
         \\}
 @@ -915,7 +931,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         "tmp.zig:2:10: error: cannot assign to constant",
     });
-    cases.addTest("reassign to struct parameter",
+    ctx.testErrStage1("reassign to struct parameter",
         \\const S = struct {
         \\    x: u32,
         \\};
 @@ -929,7 +945,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         "tmp.zig:5:10: error: cannot assign to constant",
     });
-    cases.addTest("reference to const data",
+    ctx.testErrStage1("reference to const data",
         \\export fn foo() void {
         \\    var ptr = &[_]u8{0,0,0,0};
         \\    ptr[1] = 2;
 @@ -957,7 +973,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         "tmp.zig:19:13: error: cannot assign to constant",
     });
-    cases.addTest("cast between ?T where T is not a pointer",
+    ctx.testErrStage1("cast between ?T where T is not a pointer",
         \\pub const fnty1 = ?fn (i8) void;
         \\pub const fnty2 = ?fn (u64) void;
         \\export fn entry() void {
 @@ -970,7 +986,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         "tmp.zig:6:9: note: optional type child 'fn(u64) void' cannot cast into optional type child 'fn(i8) void'",
     });
-    cases.addTest("unused variable error on errdefer",
+    ctx.testErrStage1("unused variable error on errdefer",
         \\fn foo() !void {
         \\    errdefer |a| unreachable;
         \\    return error.A;
 @@ -982,18 +998,19 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         "tmp.zig:2:15: error: unused variable: 'a'",
     });
-    cases.addTest("comparison of non-tagged union and enum literal",
+    ctx.testErrStage1("comparison of non-tagged union and enum literal",
         \\export fn entry() void {
         \\    const U = union { A: u32, B: u64 };
         \\    var u = U{ .A = 42 };
         \\    var ok = u == .A;
+        \\    _ = ok;
         \\}
     , &[_][]const u8{
         "tmp.zig:4:16: error: comparison of union and enum literal is only valid for tagged union types",
         "tmp.zig:2:15: note: type U is not a tagged union",
     });
-    cases.addTest("shift on type with non-power-of-two size",
+    ctx.testErrStage1("shift on type with non-power-of-two size",
         \\export fn entry() void {
         \\    const S = struct {
         \\        fn a() void {
 @@ -1025,7 +1042,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         "tmp.zig:17:17: error: RHS of shift is too large for LHS type",
     });
-    cases.addTest("combination of nosuspend and async",
+    ctx.testErrStage1("combination of nosuspend and async",
         \\export fn entry() void {
         \\    nosuspend {
         \\        const bar = async foo();
 @@ -1035,10 +1052,11 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         \\}
         \\fn foo() void {}
     , &[_][]const u8{
-        "tmp.zig:4:9: error: suspend in nosuspend scope",
+        "tmp.zig:4:9: error: suspend inside nosuspend block",
+        "tmp.zig:2:5: note: nosuspend block here",
     });
-    cases.add("atomicrmw with bool op not .Xchg",
+    ctx.objErrStage1("atomicrmw with bool op not .Xchg",
         \\export fn entry() void {
         \\    var x = false;
         \\    _ = @atomicRmw(bool, &x, .Add, true, .SeqCst);
 @@ -1047,7 +1065,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         "tmp.zig:3:30: error: @atomicRmw with bool only allowed with .Xchg",
     });
-    cases.addTest("@TypeOf with no arguments",
+    ctx.testErrStage1("@TypeOf with no arguments",
         \\export fn entry() void {
         \\    _ = @TypeOf();
         \\}
 @@ -1055,7 +1073,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         "tmp.zig:2:9: error: expected at least 1 argument, found 0",
     });
-    cases.addTest("@TypeOf with incompatible arguments",
+    ctx.testErrStage1("@TypeOf with incompatible arguments",
         \\export fn entry() void {
         \\    var var_1: f32 = undefined;
         \\    var var_2: u32 = undefined;
 @@ -1065,7 +1083,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         "tmp.zig:4:9: error: incompatible types: 'f32' and 'u32'",
     });
-    cases.addTest("type mismatch with tuple concatenation",
+    ctx.testErrStage1("type mismatch with tuple concatenation",
         \\export fn entry() void {
         \\    var x = .{};
         \\    x = x ++ .{ 1, 2, 3 };
 @@ -1074,7 +1092,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         "tmp.zig:3:11: error: expected type 'struct:2:14', found 'struct:3:11'",
     });
-    cases.addTest("@tagName on invalid value of non-exhaustive enum",
+    ctx.testErrStage1("@tagName on invalid value of non-exhaustive enum",
         \\test "enum" {
         \\    const E = enum(u8) {A, B, _};
         \\    _ = @tagName(@intToEnum(E, 5));
 @@ -1083,16 +1101,17 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         "tmp.zig:3:18: error: no tag by value 5",
     });
-    cases.addTest("@ptrToInt with pointer to zero-sized type",
+    ctx.testErrStage1("@ptrToInt with pointer to zero-sized type",
         \\export fn entry() void {
         \\    var pointer: ?*u0 = null;
         \\    var x = @ptrToInt(pointer);
+        \\    _ = x;
         \\}
     , &[_][]const u8{
         "tmp.zig:3:23: error: pointer to size 0 type has no address",
     });
-    cases.addTest("access invalid @typeInfo decl",
+    ctx.testErrStage1("access invalid @typeInfo decl",
         \\const A = B;
         \\test "Crash" {
         \\    _ = @typeInfo(@This()).Struct.decls[0];
 @@ -1101,7 +1120,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         "tmp.zig:1:11: error: use of undeclared identifier 'B'",
     });
-    cases.addTest("reject extern function definitions with body",
+    ctx.testErrStage1("reject extern function definitions with body",
         \\extern "c" fn definitelyNotInLibC(a: i32, b: i32) i32 {
         \\    return a + b;
         \\}
 @@ -1109,7 +1128,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         "tmp.zig:1:1: error: extern functions have no body",
     });
-    cases.addTest("duplicate field in anonymous struct literal",
+    ctx.testErrStage1("duplicate field in anonymous struct literal",
         \\export fn entry() void {
         \\    const anon = .{
         \\        .inner = .{
 @@ -1119,31 +1138,33 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         \\            .a = .{},
         \\        },
         \\    };
+        \\    _ = anon;
         \\}
     , &[_][]const u8{
         "tmp.zig:7:13: error: duplicate field",
         "tmp.zig:4:13: note: other field here",
     });
-    cases.addTest("type mismatch in C prototype with varargs",
+    ctx.testErrStage1("type mismatch in C prototype with varargs",
         \\const fn_ty = ?fn ([*c]u8, ...) callconv(.C) void;
         \\extern fn fn_decl(fmt: [*:0]u8, ...) void;
         \\
         \\export fn main() void {
         \\    const x: fn_ty = fn_decl;
+        \\    _ = x;
         \\}
     , &[_][]const u8{
         "tmp.zig:5:22: error: expected type 'fn([*c]u8, ...) callconv(.C) void', found 'fn([*:0]u8, ...) callconv(.C) void'",
     });
-    cases.addTest("dependency loop in top-level decl with @TypeInfo when accessing the decls",
+    ctx.testErrStage1("dependency loop in top-level decl with @TypeInfo when accessing the decls",
         \\export const foo = @typeInfo(@This()).Struct.decls;
     , &[_][]const u8{
         "tmp.zig:1:20: error: dependency loop detected",
         "tmp.zig:1:45: note: referenced here",
     });
-    cases.add("function call assigned to incorrect type",
+    ctx.objErrStage1("function call assigned to incorrect type",
         \\export fn entry() void {
         \\    var arr: [4]f32 = undefined;
         \\    arr = concat();
 @@ -1155,7 +1176,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         "tmp.zig:3:17: error: expected type '[4]f32', found '[16]f32'",
     });
-    cases.add("generic function call assigned to incorrect type",
+    ctx.objErrStage1("generic function call assigned to incorrect type",
         \\pub export fn entry() void {
         \\    var res: []i32 = undefined;
         \\    res = myAlloc(i32);
 @@ -1167,12 +1188,25 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         "tmp.zig:3:18: error: expected type '[]i32', found 'anyerror!i32",
     });
-    cases.addTest("non-exhaustive enums",
+    ctx.testErrStage1("non-exhaustive enum marker assigned a value",
         \\const A = enum {
         \\    a,
         \\    b,
         \\    _ = 1,
         \\};
+        \\const B = enum {
+        \\    a,
+        \\    b,
+        \\    _,
+        \\};
+        \\comptime { _ = A; _ = B; }
+    , &[_][]const u8{
+        "tmp.zig:4:9: error: '_' is used to mark an enum as non-exhaustive and cannot be assigned a value",
+        "tmp.zig:6:11: error: non-exhaustive enum missing integer tag type",
+        "tmp.zig:9:5: note: marked non-exhaustive here",
+    });
+    ctx.testErrStage1("non-exhaustive enums",
         \\const B = enum(u1) {
         \\    a,
         \\    _,
 @@ -1184,18 +1218,15 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         \\    _,
         \\};
         \\pub export fn entry() void {
-        \\    _ = A;
         \\    _ = B;
         \\    _ = C;
         \\}
     , &[_][]const u8{
-        "tmp.zig:4:5: error: value assigned to '_' field of non-exhaustive enum",
+        "tmp.zig:3:5: error: '_' field of non-exhaustive enum must be last",
-        "error: non-exhaustive enum must specify size",
+        "tmp.zig:6:11: error: non-exhaustive enum specifies every value",
-        "error: non-exhaustive enum specifies every value",
-        "error: '_' field of non-exhaustive enum must be last",
     });
-    cases.addTest("switching with non-exhaustive enums",
+    ctx.testErrStage1("switching with non-exhaustive enums",
         \\const E = enum(u8) {
         \\    a,
         \\    b,
 @@ -1228,7 +1259,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         "tmp.zig:21:5: error: `_` prong not allowed when switching on tagged union",
     });
-    cases.add("switch expression - unreachable else prong (bool)",
+    ctx.objErrStage1("switch expression - unreachable else prong (bool)",
         \\fn foo(x: bool) void {
         \\    switch (x) {
         \\        true => {},
 @@ -1241,7 +1272,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         "tmp.zig:5:9: error: unreachable else prong, all cases already handled",
     });
-    cases.add("switch expression - unreachable else prong (u1)",
+    ctx.objErrStage1("switch expression - unreachable else prong (u1)",
         \\fn foo(x: u1) void {
         \\    switch (x) {
         \\        0 => {},
 @@ -1254,7 +1285,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         "tmp.zig:5:9: error: unreachable else prong, all cases already handled",
     });
-    cases.add("switch expression - unreachable else prong (u2)",
+    ctx.objErrStage1("switch expression - unreachable else prong (u2)",
         \\fn foo(x: u2) void {
         \\    switch (x) {
         \\        0 => {},
 @@ -1269,7 +1300,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         "tmp.zig:7:9: error: unreachable else prong, all cases already handled",
     });
-    cases.add("switch expression - unreachable else prong (range u8)",
+    ctx.objErrStage1("switch expression - unreachable else prong (range u8)",
         \\fn foo(x: u8) void {
         \\    switch (x) {
         \\        0 => {},
 @@ -1285,7 +1316,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         "tmp.zig:8:9: error: unreachable else prong, all cases already handled",
     });
-    cases.add("switch expression - unreachable else prong (range i8)",
+    ctx.objErrStage1("switch expression - unreachable else prong (range i8)",
         \\fn foo(x: i8) void {
         \\    switch (x) {
         \\        -128...0 => {},
 @@ -1301,7 +1332,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         "tmp.zig:8:9: error: unreachable else prong, all cases already handled",
     });
-    cases.add("switch expression - unreachable else prong (enum)",
+    ctx.objErrStage1("switch expression - unreachable else prong (enum)",
         \\const TestEnum = enum{ T1, T2 };
         \\
         \\fn err(x: u8) TestEnum {
 @@ -1324,7 +1355,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         "tmp.zig:14:9: error: unreachable else prong, all cases already handled",
     });
-    cases.addTest("@export with empty name string",
+    ctx.testErrStage1("@export with empty name string",
         \\pub export fn entry() void { }
         \\comptime {
         \\    @export(entry, .{ .name = "" });
 @@ -1333,7 +1364,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         "tmp.zig:3:5: error: exported symbol name cannot be empty",
     });
-    cases.addTest("switch ranges endpoints are validated",
+    ctx.testErrStage1("switch ranges endpoints are validated",
         \\pub export fn entry() void {
         \\    var x: i32 = 0;
         \\    switch (x) {
 @@ -1347,16 +1378,16 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         "tmp.zig:5:9: error: range start value is greater than the end value",
     });
-    cases.addTest("errors in for loop bodies are propagated",
+    ctx.testErrStage1("errors in for loop bodies are propagated",
         \\pub export fn entry() void {
         \\    var arr: [100]u8 = undefined;
         \\    for (arr) |bits| _ = @popCount(bits);
         \\}
     , &[_][]const u8{
-        "tmp.zig:3:26: error: expected 2 argument(s), found 1",
+        "tmp.zig:3:26: error: expected 2 arguments, found 1",
     });
-    cases.addTest("@call rejects non comptime-known fn - always_inline",
+    ctx.testErrStage1("@call rejects non comptime-known fn - always_inline",
         \\pub export fn entry() void {
         \\    var call_me: fn () void = undefined;
         \\    @call(.{ .modifier = .always_inline }, call_me, .{});
 @@ -1365,7 +1396,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         "tmp.zig:3:5: error: the specified modifier requires a comptime-known function",
     });
-    cases.addTest("@call rejects non comptime-known fn - compile_time",
+    ctx.testErrStage1("@call rejects non comptime-known fn - compile_time",
         \\pub export fn entry() void {
         \\    var call_me: fn () void = undefined;
         \\    @call(.{ .modifier = .compile_time }, call_me, .{});
 @@ -1374,19 +1405,20 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         "tmp.zig:3:5: error: the specified modifier requires a comptime-known function",
     });
-    cases.addTest("error in struct initializer doesn't crash the compiler",
+    ctx.testErrStage1("error in struct initializer doesn't crash the compiler",
         \\pub export fn entry() void {
         \\    const bitfield = struct {
         \\        e: u8,
         \\        e: u8,
         \\    };
         \\    var a = .{@sizeOf(bitfield)};
+        \\    _ = a;
         \\}
     , &[_][]const u8{
         "tmp.zig:4:9: error: duplicate struct field: 'e'",
     });
-    cases.addTest("repeated invalid field access to generic function returning type crashes compiler. #2655",
+    ctx.testErrStage1("repeated invalid field access to generic function returning type crashes compiler. #2655",
         \\pub fn A() type {
         \\    return Q;
         \\}
 @@ -1398,15 +1430,16 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         "tmp.zig:2:12: error: use of undeclared identifier 'Q'",
     });
-    cases.add("bitCast to enum type",
+    ctx.objErrStage1("bitCast to enum type",
         \\export fn entry() void {
         \\    const y = @bitCast(enum(u32) { a, b }, @as(u32, 3));
+        \\    _ = y;
         \\}
     , &[_][]const u8{
         "tmp.zig:2:24: error: cannot cast a value of type 'y'",
     });
-    cases.add("comparing against undefined produces undefined value",
+    ctx.objErrStage1("comparing against undefined produces undefined value",
         \\export fn entry() void {
         \\    if (2 == undefined) {}
         \\}
 @@ -1414,17 +1447,18 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         "tmp.zig:2:11: error: use of undefined value here causes undefined behavior",
     });
-    cases.add("comptime ptrcast of zero-sized type",
+    ctx.objErrStage1("comptime ptrcast of zero-sized type",
         \\fn foo() void {
         \\    const node: struct {} = undefined;
         \\    const vla_ptr = @ptrCast([*]const u8, &node);
+        \\    _ = vla_ptr;
         \\}
         \\comptime { foo(); }
     , &[_][]const u8{
         "tmp.zig:3:21: error: '*const struct:2:17' and '[*]const u8' do not have the same in-memory representation",
     });
-    cases.add("slice sentinel mismatch",
+    ctx.objErrStage1("slice sentinel mismatch",
         \\fn foo() [:0]u8 {
         \\    var x: []u8 = undefined;
         \\    return x;
 @@ -1435,7 +1469,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         "tmp.zig:3:12: note: destination pointer requires a terminating '0' sentinel",
     });
-    cases.add("cmpxchg with float",
+    ctx.objErrStage1("cmpxchg with float",
         \\export fn entry() void {
         \\    var x: f32 = 0;
         \\    _ = @cmpxchgWeak(f32, &x, 1, 2, .SeqCst, .SeqCst);
 @@ -1444,7 +1478,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         "tmp.zig:3:22: error: expected bool, integer, enum or pointer type, found 'f32'",
     });
-    cases.add("atomicrmw with float op not .Xchg, .Add or .Sub",
+    ctx.objErrStage1("atomicrmw with float op not .Xchg, .Add or .Sub",
         \\export fn entry() void {
         \\    var x: f32 = 0;
         \\    _ = @atomicRmw(f32, &x, .And, 2, .SeqCst);
 @@ -1453,15 +1487,16 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         "tmp.zig:3:29: error: @atomicRmw with float only allowed with .Xchg, .Add and .Sub",
     });
-    cases.add("intToPtr with misaligned address",
+    ctx.objErrStage1("intToPtr with misaligned address",
         \\pub fn main() void {
         \\    var y = @intToPtr([*]align(4) u8, 5);
+        \\    _ = y;
         \\}
     , &[_][]const u8{
         "tmp.zig:2:13: error: pointer type '[*]align(4) u8' requires aligned address",
     });
-    cases.add("invalid float literal",
+    ctx.objErrStage1("invalid float literal",
         \\const std = @import("std");
         \\
         \\pub fn main() void {
 @@ -1473,170 +1508,209 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         "tmp.zig:5:29: error: invalid token: '.'",
     });
-    cases.add("invalid exponent in float literal - 1",
+    ctx.objErrStage1("invalid exponent in float literal - 1",
         \\fn main() void {
         \\    var bad: f128 = 0x1.0p1ab1;
+        \\    _ = bad;
         \\}
     , &[_][]const u8{
-        "tmp.zig:2:28: error: invalid character: 'a'",
+        "tmp.zig:2:21: error: expected expression, found 'invalid'",
+        "tmp.zig:2:28: note: invalid byte: 'a'",
     });
-    cases.add("invalid exponent in float literal - 2",
+    ctx.objErrStage1("invalid exponent in float literal - 2",
         \\fn main() void {
         \\    var bad: f128 = 0x1.0p50F;
+        \\    _ = bad;
         \\}
     , &[_][]const u8{
-        "tmp.zig:2:29: error: invalid character: 'F'",
+        "tmp.zig:2:21: error: expected expression, found 'invalid'",
+        "tmp.zig:2:29: note: invalid byte: 'F'",
     });
-    cases.add("invalid underscore placement in float literal - 1",
+    ctx.objErrStage1("invalid underscore placement in float literal - 1",
         \\fn main() void {
         \\    var bad: f128 = 0._0;
+        \\    _ = bad;
         \\}
     , &[_][]const u8{
-        "tmp.zig:2:23: error: invalid character: '_'",
+        "tmp.zig:2:21: error: expected expression, found 'invalid'",
+        "tmp.zig:2:23: note: invalid byte: '_'",
     });
-    cases.add("invalid underscore placement in float literal - 2",
+    ctx.objErrStage1("invalid underscore placement in float literal - 2",
         \\fn main() void {
         \\    var bad: f128 = 0_.0;
+        \\    _ = bad;
         \\}
     , &[_][]const u8{
-        "tmp.zig:2:23: error: invalid character: '.'",
+        "tmp.zig:2:21: error: expected expression, found 'invalid'",
+        "tmp.zig:2:23: note: invalid byte: '.'",
     });
-    cases.add("invalid underscore placement in float literal - 3",
+    ctx.objErrStage1("invalid underscore placement in float literal - 3",
         \\fn main() void {
         \\    var bad: f128 = 0.0_;
+        \\    _ = bad;
         \\}
     , &[_][]const u8{
-        "tmp.zig:2:25: error: invalid character: ';'",
+        "tmp.zig:2:21: error: expected expression, found 'invalid'",
+        "tmp.zig:2:25: note: invalid byte: ';'",
     });
-    cases.add("invalid underscore placement in float literal - 4",
+    ctx.objErrStage1("invalid underscore placement in float literal - 4",
         \\fn main() void {
         \\    var bad: f128 = 1.0e_1;
+        \\    _ = bad;
         \\}
     , &[_][]const u8{
-        "tmp.zig:2:25: error: invalid character: '_'",
+        "tmp.zig:2:21: error: expected expression, found 'invalid'",
+        "tmp.zig:2:25: note: invalid byte: '_'",
     });
-    cases.add("invalid underscore placement in float literal - 5",
+    ctx.objErrStage1("invalid underscore placement in float literal - 5",
         \\fn main() void {
         \\    var bad: f128 = 1.0e+_1;
+        \\    _ = bad;
         \\}
     , &[_][]const u8{
-        "tmp.zig:2:26: error: invalid character: '_'",
+        "tmp.zig:2:21: error: expected expression, found 'invalid'",
+        "tmp.zig:2:26: note: invalid byte: '_'",
     });
-    cases.add("invalid underscore placement in float literal - 6",
+    ctx.objErrStage1("invalid underscore placement in float literal - 6",
         \\fn main() void {
         \\    var bad: f128 = 1.0e-_1;
+        \\    _ = bad;
         \\}
     , &[_][]const u8{
-        "tmp.zig:2:26: error: invalid character: '_'",
+        "tmp.zig:2:21: error: expected expression, found 'invalid'",
+        "tmp.zig:2:26: note: invalid byte: '_'",
     });
-    cases.add("invalid underscore placement in float literal - 7",
+    ctx.objErrStage1("invalid underscore placement in float literal - 7",
         \\fn main() void {
         \\    var bad: f128 = 1.0e-1_;
+        \\    _ = bad;
         \\}
     , &[_][]const u8{
-        "tmp.zig:2:28: error: invalid character: ';'",
+        "tmp.zig:2:21: error: expected expression, found 'invalid'",
+        "tmp.zig:2:28: note: invalid byte: ';'",
     });
-    cases.add("invalid underscore placement in float literal - 9",
+    ctx.objErrStage1("invalid underscore placement in float literal - 9",
         \\fn main() void {
         \\    var bad: f128 = 1__0.0e-1;
+        \\    _ = bad;
         \\}
     , &[_][]const u8{
-        "tmp.zig:2:23: error: invalid character: '_'",
+        "tmp.zig:2:21: error: expected expression, found 'invalid'",
+        "tmp.zig:2:23: note: invalid byte: '_'",
     });
-    cases.add("invalid underscore placement in float literal - 10",
+    ctx.objErrStage1("invalid underscore placement in float literal - 10",
         \\fn main() void {
         \\    var bad: f128 = 1.0__0e-1;
+        \\    _ = bad;
         \\}
     , &[_][]const u8{
-        "tmp.zig:2:25: error: invalid character: '_'",
+        "tmp.zig:2:21: error: expected expression, found 'invalid'",
+        "tmp.zig:2:25: note: invalid byte: '_'",
     });
-    cases.add("invalid underscore placement in float literal - 11",
+    ctx.objErrStage1("invalid underscore placement in float literal - 11",
         \\fn main() void {
         \\    var bad: f128 = 1.0e-1__0;
+        \\    _ = bad;
         \\}
     , &[_][]const u8{
-        "tmp.zig:2:28: error: invalid character: '_'",
+        "tmp.zig:2:21: error: expected expression, found 'invalid'",
+        "tmp.zig:2:28: note: invalid byte: '_'",
     });
-    cases.add("invalid underscore placement in float literal - 12",
+    ctx.objErrStage1("invalid underscore placement in float literal - 12",
         \\fn main() void {
         \\    var bad: f128 = 0_x0.0;
+        \\    _ = bad;
         \\}
     , &[_][]const u8{
-        "tmp.zig:2:23: error: invalid character: 'x'",
+        "tmp.zig:2:21: error: expected expression, found 'invalid'",
+        "tmp.zig:2:23: note: invalid byte: 'x'",
     });
-    cases.add("invalid underscore placement in float literal - 13",
+    ctx.objErrStage1("invalid underscore placement in float literal - 13",
         \\fn main() void {
         \\    var bad: f128 = 0x_0.0;
+        \\    _ = bad;
         \\}
     , &[_][]const u8{
-        "tmp.zig:2:23: error: invalid character: '_'",
+        "tmp.zig:2:21: error: expected expression, found 'invalid'",
+        "tmp.zig:2:23: note: invalid byte: '_'",
     });
-    cases.add("invalid underscore placement in float literal - 14",
+    ctx.objErrStage1("invalid underscore placement in float literal - 14",
         \\fn main() void {
         \\    var bad: f128 = 0x0.0_p1;
+        \\    _ = bad;
         \\}
     , &[_][]const u8{
-        "tmp.zig:2:27: error: invalid character: 'p'",
+        "tmp.zig:2:21: error: expected expression, found 'invalid'",
+        "tmp.zig:2:27: note: invalid byte: 'p'",
     });
-    cases.add("invalid underscore placement in int literal - 1",
+    ctx.objErrStage1("invalid underscore placement in int literal - 1",
         \\fn main() void {
         \\    var bad: u128 = 0010_;
+        \\    _ = bad;
         \\}
     , &[_][]const u8{
-        "tmp.zig:2:26: error: invalid character: ';'",
+        "tmp.zig:2:21: error: expected expression, found 'invalid'",
+        "tmp.zig:2:26: note: invalid byte: ';'",
     });
-    cases.add("invalid underscore placement in int literal - 2",
+    ctx.objErrStage1("invalid underscore placement in int literal - 2",
         \\fn main() void {
         \\    var bad: u128 = 0b0010_;
+        \\    _ = bad;
         \\}
     , &[_][]const u8{
-        "tmp.zig:2:28: error: invalid character: ';'",
+        "tmp.zig:2:21: error: expected expression, found 'invalid'",
+        "tmp.zig:2:28: note: invalid byte: ';'",
     });
-    cases.add("invalid underscore placement in int literal - 3",
+    ctx.objErrStage1("invalid underscore placement in int literal - 3",
         \\fn main() void {
         \\    var bad: u128 = 0o0010_;
+        \\    _ = bad;
         \\}
     , &[_][]const u8{
-        "tmp.zig:2:28: error: invalid character: ';'",
+        "tmp.zig:2:21: error: expected expression, found 'invalid'",
+        "tmp.zig:2:28: note: invalid byte: ';'",
     });
-    cases.add("invalid underscore placement in int literal - 4",
+    ctx.objErrStage1("invalid underscore placement in int literal - 4",
         \\fn main() void {
         \\    var bad: u128 = 0x0010_;
+        \\    _ = bad;
         \\}
     , &[_][]const u8{
-        "tmp.zig:2:28: error: invalid character: ';'",
+        "tmp.zig:2:21: error: expected expression, found 'invalid'",
+        "tmp.zig:2:28: note: invalid byte: ';'",
     });
-    cases.add("comptime struct field, no init value",
+    ctx.objErrStage1("comptime struct field, no init value",
         \\const Foo = struct {
         \\    comptime b: i32,
         \\};
         \\export fn entry() void {
         \\    var f: Foo = undefined;
+        \\    _ = f;
         \\}
     , &[_][]const u8{
-        "tmp.zig:2:5: error: comptime struct field missing initialization value",
+        "tmp.zig:2:5: error: comptime field without default initialization value",
     });
-    cases.add("bad usage of @call",
+    ctx.objErrStage1("bad usage of @call",
         \\export fn entry1() void {
         \\    @call(.{}, foo, {});
         \\}
 @@ -1665,20 +1739,26 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         "tmp.zig:15:5: error: the specified modifier requires a comptime-known function",
     });
-    cases.add("exported async function",
+    ctx.objErrStage1("exported async function",
         \\export fn foo() callconv(.Async) void {}
     , &[_][]const u8{
         "tmp.zig:1:1: error: exported function cannot be async",
     });
-    cases.addExe("main missing name",
+    ctx.exeErrStage1("main missing name",
         \\pub fn (main) void {}
     , &[_][]const u8{
         "tmp.zig:1:5: error: missing function name",
     });
-    cases.addCase(x: {
+    {
-        var tc = cases.create("call with new stack on unsupported target",
+        const case = ctx.obj("call with new stack on unsupported target", .{
+            .cpu_arch = .wasm32,
+            .os_tag = .wasi,
+            .abi = .none,
+        });
+        case.backend = .stage1;
+        case.addError(
             \\var buf: [10]u8 align(16) = undefined;
             \\export fn entry() void {
             \\    @call(.{.stack = &buf}, foo, .{});
 @@ -1687,17 +1767,11 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         , &[_][]const u8{
             "tmp.zig:3:5: error: target arch 'wasm32' does not support calling with a new stack",
         });
-        tc.target = std.zig.CrossTarget{
+    }
-            .cpu_arch = .wasm32,
-            .os_tag = .wasi,
-            .abi = .none,
-        };
-        break :x tc;
-    });
     // Note: One of the error messages here is backwards. It would be nice to fix, but that's not
     // going to stop me from merging this branch which fixes a bunch of other stuff.
-    cases.add("incompatible sentinels",
+    ctx.objErrStage1("incompatible sentinels",
         \\export fn entry1(ptr: [*:255]u8) [*:0]u8 {
         \\    return ptr;
         \\}
 @@ -1706,9 +1780,11 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         \\}
         \\export fn entry3() void {
         \\    var array: [2:0]u8 = [_:255]u8{1, 2};
+        \\    _ = array;
         \\}
         \\export fn entry4() void {
         \\    var array: [2:0]u8 = [_]u8{1, 2};
+        \\    _ = array;
         \\}
     , &[_][]const u8{
         "tmp.zig:2:12: error: expected type '[*:0]u8', found '[*:255]u8'",
 @@ -1718,11 +1794,11 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         "tmp.zig:8:35: error: expected type '[2:255]u8', found '[2:0]u8'",
         "tmp.zig:8:35: note: destination array requires a terminating '255' sentinel, but source array has a terminating '0' sentinel",
-        "tmp.zig:11:31: error: expected type '[2:0]u8', found '[2]u8'",
+        "tmp.zig:12:31: error: expected type '[2:0]u8', found '[2]u8'",
-        "tmp.zig:11:31: note: destination array requires a terminating '0' sentinel",
+        "tmp.zig:12:31: note: destination array requires a terminating '0' sentinel",
     });
-    cases.add("empty switch on an integer",
+    ctx.objErrStage1("empty switch on an integer",
         \\export fn entry() void {
         \\    var x: u32 = 0;
         \\    switch(x) {}
 @@ -1731,7 +1807,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         "tmp.zig:3:5: error: switch must handle all possibilities",
     });
-    cases.add("incorrect return type",
+    ctx.objErrStage1("incorrect return type",
         \\ pub export fn entry() void{
         \\     _ = foo();
         \\ }
 @@ -1751,12 +1827,13 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         "tmp.zig:8:16: error: expected type 'A', found 'B'",
     });
-    cases.add("regression test #2980: base type u32 is not type checked properly when assigning a value within a struct",
+    ctx.objErrStage1("regression test #2980: base type u32 is not type checked properly when assigning a value within a struct",
         \\const Foo = struct {
         \\    ptr: ?*usize,
         \\    uval: u32,
         \\};
         \\fn get_uval(x: u32) !u32 {
+        \\    _ = x;
         \\    return error.NotFound;
         \\}
         \\export fn entry() void {
 @@ -1764,12 +1841,13 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         \\        .ptr = null,
         \\        .uval = get_uval(42),
         \\    };
+        \\    _ = afoo;
         \\}
     , &[_][]const u8{
-        "tmp.zig:11:25: error: expected type 'u32', found '@typeInfo(@typeInfo(@TypeOf(get_uval)).Fn.return_type.?).ErrorUnion.error_set!u32'",
+        "tmp.zig:12:25: error: expected type 'u32', found '@typeInfo(@typeInfo(@TypeOf(get_uval)).Fn.return_type.?).ErrorUnion.error_set!u32'",
     });
-    cases.add("assigning to struct or union fields that are not optionals with a function that returns an optional",
+    ctx.objErrStage1("assigning to struct or union fields that are not optionals with a function that returns an optional",
         \\fn maybe(is: bool) ?u8 {
         \\    if (is) return @as(u8, 10) else return null;
         \\}
 @@ -1782,12 +1860,14 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         \\export fn entry() void {
         \\    var u = U{ .Ye = maybe(false) };
         \\    var s = S{ .num = maybe(false) };
+        \\    _ = u;
+        \\    _ = s;
         \\}
     , &[_][]const u8{
         "tmp.zig:11:27: error: expected type 'u8', found '?u8'",
     });
-    cases.add("missing result type for phi node",
+    ctx.objErrStage1("missing result type for phi node",
         \\fn foo() !void {
         \\    return anyerror.Foo;
         \\}
 @@ -1798,7 +1878,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         "tmp.zig:5:17: error: integer value 0 cannot be coerced to type 'void'",
     });
-    cases.add("atomicrmw with enum op not .Xchg",
+    ctx.objErrStage1("atomicrmw with enum op not .Xchg",
         \\export fn entry() void {
         \\    const E = enum(u8) {
         \\        a,
 @@ -1813,7 +1893,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         "tmp.zig:9:27: error: @atomicRmw with enum only allowed with .Xchg",
     });
-    cases.add("disallow coercion from non-null-terminated pointer to null-terminated pointer",
+    ctx.objErrStage1("disallow coercion from non-null-terminated pointer to null-terminated pointer",
         \\extern fn puts(s: [*:0]const u8) c_int;
         \\pub fn main() void {
         \\    const no_zero_array = [_]u8{'h', 'e', 'l', 'l', 'o'};
 @@ -1824,7 +1904,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         "tmp.zig:5:14: error: expected type '[*:0]const u8', found '[*]const u8'",
     });
-    cases.add("atomic orderings of atomicStore Acquire or AcqRel",
+    ctx.objErrStage1("atomic orderings of atomicStore Acquire or AcqRel",
         \\export fn entry() void {
         \\    var x: u32 = 0;
         \\    @atomicStore(u32, &x, 1, .Acquire);
 @@ -1833,7 +1913,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         "tmp.zig:3:30: error: @atomicStore atomic ordering must not be Acquire or AcqRel",
     });
-    cases.add("missing const in slice with nested array type",
+    ctx.objErrStage1("missing const in slice with nested array type",
         \\const Geo3DTex2D = struct { vertices: [][2]f32 };
         \\pub fn getGeo3DTex2D() Geo3DTex2D {
         \\    return Geo3DTex2D{
 @@ -1844,12 +1924,13 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         \\}
         \\export fn entry() void {
         \\    var geo_data = getGeo3DTex2D();
+        \\    _ = geo_data;
         \\}
     , &[_][]const u8{
         "tmp.zig:4:30: error: array literal requires address-of operator to coerce to slice type '[][2]f32'",
     });
-    cases.add("slicing of global undefined pointer",
+    ctx.objErrStage1("slicing of global undefined pointer",
         \\var buf: *[1]u8 = undefined;
         \\export fn entry() void {
         \\    _ = buf[0..1];
 @@ -1858,18 +1939,17 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         "tmp.zig:3:12: error: non-zero length slice of undefined pointer",
     });
-    cases.add("using invalid types in function call raises an error",
+    ctx.objErrStage1("using invalid types in function call raises an error",
         \\const MenuEffect = enum {};
-        \\fn func(effect: MenuEffect) void {}
+        \\fn func(effect: MenuEffect) void { _ = effect; }
         \\export fn entry() void {
         \\    func(MenuEffect.ThisDoesNotExist);
         \\}
     , &[_][]const u8{
-        "tmp.zig:1:20: error: enums must have 1 or more fields",
+        "tmp.zig:1:20: error: enum declarations must have at least one tag",
-        "tmp.zig:4:20: note: referenced here",
     });
-    cases.add("store vector pointer with unknown runtime index",
+    ctx.objErrStage1("store vector pointer with unknown runtime index",
         \\export fn entry() void {
         \\    var v: @import("std").meta.Vector(4, i32) = [_]i32{ 1, 5, 3, undefined };
         \\
 @@ -1884,22 +1964,23 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         "tmp.zig:9:8: error: unable to determine vector element index of type '*align(16:0:4:?) i32",
     });
-    cases.add("load vector pointer with unknown runtime index",
+    ctx.objErrStage1("load vector pointer with unknown runtime index",
         \\export fn entry() void {
         \\    var v: @import("std").meta.Vector(4, i32) = [_]i32{ 1, 5, 3, undefined };
         \\
         \\    var i: u32 = 0;
         \\    var x = loadv(&v[i]);
+        \\    _ = x;
         \\}
         \\
         \\fn loadv(ptr: anytype) i32 {
         \\    return ptr.*;
         \\}
     , &[_][]const u8{
-        "tmp.zig:9:12: error: unable to determine vector element index of type '*align(16:0:4:?) i32",
+        "tmp.zig:10:12: error: unable to determine vector element index of type '*align(16:0:4:?) i32",
     });
-    cases.add("using an unknown len ptr type instead of array",
+    ctx.objErrStage1("using an unknown len ptr type instead of array",
         \\const resolutions = [*][*]const u8{
         \\    "[320 240  ]",
         \\    null,
 @@ -1911,7 +1992,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         "tmp.zig:1:21: error: expected array type or [_], found '[*][*]const u8'",
     });
-    cases.add("comparison with error union and error value",
+    ctx.objErrStage1("comparison with error union and error value",
         \\export fn entry() void {
         \\    var number_or_error: anyerror!i32 = error.SomethingAwful;
         \\    _ = number_or_error == error.SomethingAwful;
 @@ -1920,7 +2001,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         "tmp.zig:3:25: error: operator not allowed for type 'anyerror!i32'",
     });
-    cases.add("switch with overlapping case ranges",
+    ctx.objErrStage1("switch with overlapping case ranges",
         \\export fn entry() void {
         \\    var q: u8 = 0;
         \\    switch (q) {
 @@ -1932,28 +2013,29 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         "tmp.zig:5:9: error: duplicate switch value",
     });
-    cases.add("invalid optional type in extern struct",
+    ctx.objErrStage1("invalid optional type in extern struct",
         \\const stroo = extern struct {
         \\    moo: ?[*c]u8,
         \\};
-        \\export fn testf(fluff: *stroo) void {}
+        \\export fn testf(fluff: *stroo) void { _ = fluff; }
     , &[_][]const u8{
         "tmp.zig:2:5: error: extern structs cannot contain fields of type '?[*c]u8'",
     });
-    cases.add("attempt to negate a non-integer, non-float or non-vector type",
+    ctx.objErrStage1("attempt to negate a non-integer, non-float or non-vector type",
         \\fn foo() anyerror!u32 {
         \\    return 1;
         \\}
         \\
         \\export fn entry() void {
         \\    const x = -foo();
+        \\    _ = x;
         \\}
     , &[_][]const u8{
         "tmp.zig:6:15: error: negation of type 'anyerror!u32'",
     });
-    cases.add("attempt to create 17 bit float type",
+    ctx.objErrStage1("attempt to create 17 bit float type",
         \\const builtin = @import("std").builtin;
         \\comptime {
         \\    _ = @Type(builtin.TypeInfo { .Float = builtin.TypeInfo.Float { .bits = 17 } });
 @@ -1962,7 +2044,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         "tmp.zig:3:32: error: 17-bit float unsupported",
     });
-    cases.add("wrong type for @Type",
+    ctx.objErrStage1("wrong type for @Type",
         \\export fn entry() void {
         \\    _ = @Type(0);
         \\}
 @@ -1970,7 +2052,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         "tmp.zig:2:15: error: expected type 'std.builtin.TypeInfo', found 'comptime_int'",
     });
-    cases.add("@Type with non-constant expression",
+    ctx.objErrStage1("@Type with non-constant expression",
         \\const builtin = @import("std").builtin;
         \\var globalTypeInfo : builtin.TypeInfo = undefined;
         \\export fn entry() void {
 @@ -1980,7 +2062,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         "tmp.zig:4:15: error: unable to evaluate constant expression",
     });
-    cases.add("wrong type for argument tuple to @asyncCall",
+    ctx.objErrStage1("wrong type for argument tuple to @asyncCall",
         \\export fn entry1() void {
         \\    var frame: @Frame(foo) = undefined;
         \\    @asyncCall(&frame, {}, foo, {});
 @@ -1993,7 +2075,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         "tmp.zig:3:33: error: expected tuple or struct, found 'void'",
     });
-    cases.add("wrong type for result ptr to @asyncCall",
+    ctx.objErrStage1("wrong type for result ptr to @asyncCall",
         \\export fn entry() void {
         \\    _ = async amain();
         \\}
 @@ -2008,25 +2090,27 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         "tmp.zig:6:37: error: expected type '*i32', found 'bool'",
     });
-    cases.add("shift amount has to be an integer type",
+    ctx.objErrStage1("shift amount has to be an integer type",
         \\export fn entry() void {
         \\    const x = 1 << &@as(u8, 10);
+        \\    _ = x;
         \\}
     , &[_][]const u8{
         "tmp.zig:2:21: error: shift amount has to be an integer type, but found '*const u8'",
         "tmp.zig:2:17: note: referenced here",
     });
-    cases.add("bit shifting only works on integer types",
+    ctx.objErrStage1("bit shifting only works on integer types",
         \\export fn entry() void {
         \\    const x = &@as(u8, 1) << 10;
+        \\    _ = x;
         \\}
     , &[_][]const u8{
         "tmp.zig:2:16: error: bit shifting operation expected integer type, found '*const u8'",
         "tmp.zig:2:27: note: referenced here",
     });
-    cases.add("struct depends on itself via optional field",
+    ctx.objErrStage1("struct depends on itself via optional field",
         \\const LhsExpr = struct {
         \\    rhsExpr: ?AstObject,
         \\};
 @@ -2036,6 +2120,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         \\export fn entry() void {
         \\    const lhsExpr = LhsExpr{ .rhsExpr = null };
         \\    const obj = AstObject{ .lhsExpr = lhsExpr };
+        \\    _ = obj;
         \\}
     , &[_][]const u8{
         "tmp.zig:1:17: error: struct 'LhsExpr' depends on itself",
 @@ -2043,51 +2128,54 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         "tmp.zig:2:5: note: while checking this field",
     });
-    cases.add("alignment of enum field specified",
+    ctx.objErrStage1("alignment of enum field specified",
         \\const Number = enum {
         \\    a,
         \\    b align(i32),
         \\};
         \\export fn entry1() void {
         \\    var x: Number = undefined;
+        \\    _ = x;
         \\}
     , &[_][]const u8{
-        "tmp.zig:3:13: error: structs and unions, not enums, support field alignment",
+        "tmp.zig:3:7: error: expected ',', found 'align'",
-        "tmp.zig:1:16: note: consider 'union(enum)' here",
     });
-    cases.add("bad alignment type",
+    ctx.objErrStage1("bad alignment type",
         \\export fn entry1() void {
         \\    var x: []align(true) i32 = undefined;
+        \\    _ = x;
         \\}
         \\export fn entry2() void {
         \\    var x: *align(@as(f64, 12.34)) i32 = undefined;
+        \\    _ = x;
         \\}
     , &[_][]const u8{
         "tmp.zig:2:20: error: expected type 'u29', found 'bool'",
-        "tmp.zig:5:19: error: fractional component prevents float value 12.340000 from being casted to type 'u29'",
+        "tmp.zig:6:19: error: fractional component prevents float value 12.340000 from being casted to type 'u29'",
     });
-    cases.addCase(x: {
+    {
-        var tc = cases.create("variable in inline assembly template cannot be found",
+        const case = ctx.obj("variable in inline assembly template cannot be found", .{
+            .cpu_arch = .x86_64,
+            .os_tag = .linux,
+            .abi = .gnu,
+        });
+        case.backend = .stage1;
+        case.addError(
             \\export fn entry() void {
             \\    var sp = asm volatile (
             \\        "mov %[foo], sp"
             \\        : [bar] "=r" (-> usize)
             \\    );
+            \\    _ = sp;
             \\}
         , &[_][]const u8{
             "tmp.zig:2:14: error: could not find 'foo' in the inputs or outputs",
         });
-        tc.target = std.zig.CrossTarget{
+    }
-            .cpu_arch = .x86_64,
-            .os_tag = .linux,
-            .abi = .gnu,
-        };
-        break :x tc;
-    });
-    cases.add("indirect recursion of async functions detected",
+    ctx.objErrStage1("indirect recursion of async functions detected",
         \\var frame: ?anyframe = null;
         \\
         \\export fn a() void {
 @@ -2122,7 +2210,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         "tmp.zig:26:25: note: when analyzing type '@Frame(rangeSumIndirect)' here",
     });
-    cases.add("non-async function pointer eventually is inferred to become async",
+    ctx.objErrStage1("non-async function pointer eventually is inferred to become async",
         \\export fn a() void {
         \\    var non_async_fn: fn () void = undefined;
         \\    non_async_fn = func;
 @@ -2136,20 +2224,26 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         "tmp.zig:6:5: note: suspends here",
     });
-    cases.add("bad alignment in @asyncCall",
+    {
-        \\export fn entry() void {
+        const case = ctx.obj("bad alignment in @asyncCall", .{
-        \\    var ptr: fn () callconv(.Async) void = func;
+            .cpu_arch = .aarch64,
-        \\    var bytes: [64]u8 = undefined;
+            .os_tag = .linux,
-        \\    _ = @asyncCall(&bytes, {}, ptr, .{});
+            .abi = .none,
-        \\}
+        });
-        \\fn func() callconv(.Async) void {}
+        case.backend = .stage1;
-    , &[_][]const u8{
+        case.addError(
-        // Split the check in two as the alignment value is target dependent.
+            \\export fn entry() void {
-        "tmp.zig:4:21: error: expected type '[]align(",
+            \\    var ptr: fn () callconv(.Async) void = func;
-        ") u8', found '*[64]u8'",
+            \\    var bytes: [64]u8 = undefined;
-    });
+            \\    _ = @asyncCall(&bytes, {}, ptr, .{});
+            \\}
+            \\fn func() callconv(.Async) void {}
+        , &[_][]const u8{
+            "tmp.zig:4:21: error: expected type '[]align(8) u8', found '*[64]u8'",
+        });
+    }
-    cases.add("atomic orderings of fence Acquire or stricter",
+    ctx.objErrStage1("atomic orderings of fence Acquire or stricter",
         \\export fn entry() void {
         \\    @fence(.Monotonic);
         \\}
 @@ -2157,20 +2251,22 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         "tmp.zig:2:12: error: atomic ordering must be Acquire or stricter",
     });
-    cases.add("bad alignment in implicit cast from array pointer to slice",
+    ctx.objErrStage1("bad alignment in implicit cast from array pointer to slice",
         \\export fn a() void {
         \\    var x: [10]u8 = undefined;
         \\    var y: []align(16) u8 = &x;
+        \\    _ = y;
         \\}
     , &[_][]const u8{
         "tmp.zig:3:30: error: expected type '[]align(16) u8', found '*[10]u8'",
     });
-    cases.add("result location incompatibility mismatching handle_is_ptr (generic call)",
+    ctx.objErrStage1("result location incompatibility mismatching handle_is_ptr (generic call)",
         \\export fn entry() void {
         \\    var damn = Container{
         \\        .not_optional = getOptional(i32),
         \\    };
+        \\    _ = damn;
         \\}
         \\pub fn getOptional(comptime T: type) ?T {
         \\    return 0;
 @@ -2182,11 +2278,12 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         "tmp.zig:3:36: error: expected type 'i32', found '?i32'",
     });
-    cases.add("result location incompatibility mismatching handle_is_ptr",
+    ctx.objErrStage1("result location incompatibility mismatching handle_is_ptr",
         \\export fn entry() void {
         \\    var damn = Container{
         \\        .not_optional = getOptional(),
         \\    };
+        \\    _ = damn;
         \\}
         \\pub fn getOptional() ?i32 {
         \\    return 0;
 @@ -2198,7 +2295,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         "tmp.zig:3:36: error: expected type 'i32', found '?i32'",
     });
-    cases.add("const frame cast to anyframe",
+    ctx.objErrStage1("const frame cast to anyframe",
         \\export fn a() void {
         \\    const f = async func();
         \\    resume f;
 @@ -2206,6 +2303,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         \\export fn b() void {
         \\    const f = async func();
         \\    var x: anyframe = &f;
+        \\    _ = x;
         \\}
         \\fn func() void {
         \\    suspend {}
 @@ -2215,27 +2313,30 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         "tmp.zig:7:24: error: expected type 'anyframe', found '*const @Frame(func)'",
     });
-    cases.add("prevent bad implicit casting of anyframe types",
+    ctx.objErrStage1("prevent bad implicit casting of anyframe types",
         \\export fn a() void {
         \\    var x: anyframe = undefined;
         \\    var y: anyframe->i32 = x;
+        \\    _ = y;
         \\}
         \\export fn b() void {
         \\    var x: i32 = undefined;
         \\    var y: anyframe->i32 = x;
+        \\    _ = y;
         \\}
         \\export fn c() void {
         \\    var x: @Frame(func) = undefined;
         \\    var y: anyframe->i32 = &x;
+        \\    _ = y;
         \\}
         \\fn func() void {}
     , &[_][]const u8{
         "tmp.zig:3:28: error: expected type 'anyframe->i32', found 'anyframe'",
-        "tmp.zig:7:28: error: expected type 'anyframe->i32', found 'i32'",
+        "tmp.zig:8:28: error: expected type 'anyframe->i32', found 'i32'",
-        "tmp.zig:11:29: error: expected type 'anyframe->i32', found '*@Frame(func)'",
+        "tmp.zig:13:29: error: expected type 'anyframe->i32', found '*@Frame(func)'",
     });
-    cases.add("wrong frame type used for async call",
+    ctx.objErrStage1("wrong frame type used for async call",
         \\export fn entry() void {
         \\    var frame: @Frame(foo) = undefined;
         \\    frame = async bar();
 @@ -2250,18 +2351,20 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         "tmp.zig:3:13: error: expected type '*@Frame(bar)', found '*@Frame(foo)'",
     });
-    cases.add("@Frame() of generic function",
+    ctx.objErrStage1("@Frame() of generic function",
         \\export fn entry() void {
         \\    var frame: @Frame(func) = undefined;
+        \\    _ = frame;
         \\}
         \\fn func(comptime T: type) void {
         \\    var x: T = undefined;
+        \\    _ = x;
         \\}
     , &[_][]const u8{
         "tmp.zig:2:16: error: @Frame() of generic function",
     });
-    cases.add("@frame() causes function to be async",
+    ctx.objErrStage1("@frame() causes function to be async",
         \\export fn entry() void {
         \\    func();
         \\}
 @@ -2273,10 +2376,11 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         "tmp.zig:5:9: note: @frame() causes function to be async",
     });
-    cases.add("invalid suspend in exported function",
+    ctx.objErrStage1("invalid suspend in exported function",
         \\export fn entry() void {
         \\    var frame = async func();
         \\    var result = await frame;
+        \\    _ = result;
         \\}
         \\fn func() void {
         \\    suspend {}
 @@ -2286,7 +2390,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         "tmp.zig:3:18: note: await here is a suspend point",
     });
-    cases.add("async function indirectly depends on its own frame",
+    ctx.objErrStage1("async function indirectly depends on its own frame",
         \\export fn entry() void {
         \\    _ = async amain();
         \\}
 @@ -2295,6 +2399,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         \\}
         \\fn other() void {
         \\    var x: [@sizeOf(@Frame(amain))]u8 = undefined;
+        \\    _ = x;
         \\}
     , &[_][]const u8{
         "tmp.zig:4:1: error: unable to determine async function frame of 'amain'",
 @@ -2302,19 +2407,20 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         "tmp.zig:8:13: note: referenced here",
     });
-    cases.add("async function depends on its own frame",
+    ctx.objErrStage1("async function depends on its own frame",
         \\export fn entry() void {
         \\    _ = async amain();
         \\}
         \\fn amain() callconv(.Async) void {
         \\    var x: [@sizeOf(@Frame(amain))]u8 = undefined;
+        \\    _ = x;
         \\}
     , &[_][]const u8{
         "tmp.zig:4:1: error: cannot resolve '@Frame(amain)': function not fully analyzed yet",
         "tmp.zig:5:13: note: referenced here",
     });
-    cases.add("non async function pointer passed to @asyncCall",
+    ctx.objErrStage1("non async function pointer passed to @asyncCall",
         \\export fn entry() void {
         \\    var ptr = afunc;
         \\    var bytes: [100]u8 align(16) = undefined;
 @@ -2325,7 +2431,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         "tmp.zig:4:32: error: expected async function, found 'fn() void'",
     });
-    cases.add("runtime-known async function called",
+    ctx.objErrStage1("runtime-known async function called",
         \\export fn entry() void {
         \\    _ = async amain();
         \\}
 @@ -2338,7 +2444,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         "tmp.zig:6:12: error: function is not comptime-known; @asyncCall required",
     });
-    cases.add("runtime-known function called with async keyword",
+    ctx.objErrStage1("runtime-known function called with async keyword",
         \\export fn entry() void {
         \\    var ptr = afunc;
         \\    _ = async ptr();
 @@ -2349,7 +2455,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         "tmp.zig:3:15: error: function is not comptime-known; @asyncCall required",
     });
-    cases.add("function with ccc indirectly calling async function",
+    ctx.objErrStage1("function with ccc indirectly calling async function",
         \\export fn entry() void {
         \\    foo();
         \\}
 @@ -2366,7 +2472,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         "tmp.zig:8:5: note: suspends here",
     });
-    cases.add("capture group on switch prong with incompatible payload types",
+    ctx.objErrStage1("capture group on switch prong with incompatible payload types",
         \\const Union = union(enum) {
         \\    A: usize,
         \\    B: isize,
 @@ -2374,7 +2480,10 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         \\comptime {
         \\    var u = Union{ .A = 8 };
         \\    switch (u) {
-        \\        .A, .B => |e| unreachable,
+        \\        .A, .B => |e| {
+        \\            _ = e;
+        \\            unreachable;
+        \\        },
         \\    }
         \\}
     , &[_][]const u8{
 @@ -2383,7 +2492,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         "tmp.zig:8:13: note: type 'isize' here",
     });
-    cases.add("wrong type to @hasField",
+    ctx.objErrStage1("wrong type to @hasField",
         \\export fn entry() bool {
         \\    return @hasField(i32, "hi");
         \\}
 @@ -2391,44 +2500,49 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         "tmp.zig:2:22: error: type 'i32' does not support @hasField",
     });
-    cases.add("slice passed as array init type with elems",
+    ctx.objErrStage1("slice passed as array init type with elems",
         \\export fn entry() void {
         \\    const x = []u8{1, 2};
+        \\    _ = x;
         \\}
     , &[_][]const u8{
         "tmp.zig:2:15: error: array literal requires address-of operator to coerce to slice type '[]u8'",
     });
-    cases.add("slice passed as array init type",
+    ctx.objErrStage1("slice passed as array init type",
         \\export fn entry() void {
         \\    const x = []u8{};
+        \\    _ = x;
         \\}
     , &[_][]const u8{
         "tmp.zig:2:15: error: array literal requires address-of operator to coerce to slice type '[]u8'",
     });
-    cases.add("inferred array size invalid here",
+    ctx.objErrStage1("inferred array size invalid here",
         \\export fn entry() void {
         \\    const x = [_]u8;
+        \\    _ = x;
         \\}
         \\export fn entry2() void {
         \\    const S = struct { a: *const [_]u8 };
         \\    var a = .{ S{} };
+        \\    _ = a;
         \\}
     , &[_][]const u8{
-        "tmp.zig:2:15: error: inferred array size invalid here",
+        "tmp.zig:2:16: error: unable to infer array size",
-        "tmp.zig:5:34: error: inferred array size invalid here",
+        "tmp.zig:6:35: error: unable to infer array size",
     });
-    cases.add("initializing array with struct syntax",
+    ctx.objErrStage1("initializing array with struct syntax",
         \\export fn entry() void {
         \\    const x = [_]u8{ .y = 2 };
+        \\    _ = x;
         \\}
     , &[_][]const u8{
         "tmp.zig:2:15: error: initializing array with struct syntax",
     });
-    cases.add("compile error in struct init expression",
+    ctx.objErrStage1("compile error in struct init expression",
         \\const Foo = struct {
         \\    a: i32 = crap,
         \\    b: i32,
 @@ -2437,23 +2551,25 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         \\    var x = Foo{
         \\        .b = 5,
         \\    };
+        \\    _ = x;
         \\}
     , &[_][]const u8{
         "tmp.zig:2:14: error: use of undeclared identifier 'crap'",
     });
-    cases.add("undefined as field type is rejected",
+    ctx.objErrStage1("undefined as field type is rejected",
         \\const Foo = struct {
         \\    a: undefined,
         \\};
         \\export fn entry1() void {
         \\    const foo: Foo = undefined;
+        \\    _ = foo;
         \\}
     , &[_][]const u8{
         "tmp.zig:2:8: error: use of undefined value here causes undefined behavior",
     });
-    cases.add("@hasDecl with non-container",
+    ctx.objErrStage1("@hasDecl with non-container",
         \\export fn entry() void {
         \\    _ = @hasDecl(i32, "hi");
         \\}
 @@ -2461,16 +2577,17 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         "tmp.zig:2:18: error: expected struct, enum, or union; found 'i32'",
     });
-    cases.add("field access of slices",
+    ctx.objErrStage1("field access of slices",
         \\export fn entry() void {
         \\    var slice: []i32 = undefined;
         \\    const info = @TypeOf(slice).unknown;
+        \\    _ = info;
         \\}
     , &[_][]const u8{
         "tmp.zig:3:32: error: type 'type' does not support field access",
     });
-    cases.add("peer cast then implicit cast const pointer to mutable C pointer",
+    ctx.objErrStage1("peer cast then implicit cast const pointer to mutable C pointer",
         \\export fn func() void {
         \\    var strValue: [*c]u8 = undefined;
         \\    strValue = strValue orelse "";
 @@ -2480,19 +2597,20 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         "tmp.zig:3:32: note: cast discards const qualifier",
     });
-    cases.add("overflow in enum value allocation",
+    ctx.objErrStage1("overflow in enum value allocation",
         \\const Moo = enum(u8) {
         \\    Last = 255,
         \\    Over,
         \\};
         \\pub fn main() void {
         \\  var y = Moo.Last;
+        \\  _ = y;
         \\}
     , &[_][]const u8{
         "tmp.zig:3:5: error: enumeration value 256 too large for type 'u8'",
     });
-    cases.add("attempt to cast enum literal to error",
+    ctx.objErrStage1("attempt to cast enum literal to error",
         \\export fn entry() void {
         \\    switch (error.Hi) {
         \\        .Hi => {},
 @@ -2502,7 +2620,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         "tmp.zig:3:9: error: expected type 'error{Hi}', found '(enum literal)'",
     });
-    cases.add("@sizeOf bad type",
+    ctx.objErrStage1("@sizeOf bad type",
         \\export fn entry() usize {
         \\    return @sizeOf(@TypeOf(null));
         \\}
 @@ -2510,7 +2628,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         "tmp.zig:2:20: error: no size available for type '(null)'",
     });
-    cases.add("generic function where return type is self-referenced",
+    ctx.objErrStage1("generic function where return type is self-referenced",
         \\fn Foo(comptime T: type) Foo(T) {
         \\    return struct{ x: T };
         \\}
 @@ -2518,34 +2636,37 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         \\    const t = Foo(u32) {
         \\      .x = 1
         \\    };
+        \\    _ = t;
         \\}
     , &[_][]const u8{
         "tmp.zig:1:29: error: evaluation exceeded 1000 backwards branches",
         "tmp.zig:5:18: note: referenced here",
     });
-    cases.add("@ptrToInt 0 to non optional pointer",
+    ctx.objErrStage1("@ptrToInt 0 to non optional pointer",
         \\export fn entry() void {
         \\    var b = @intToPtr(*i32, 0);
+        \\    _ = b;
         \\}
     , &[_][]const u8{
         "tmp.zig:2:13: error: pointer type '*i32' does not allow address zero",
     });
-    cases.add("cast enum literal to enum but it doesn't match",
+    ctx.objErrStage1("cast enum literal to enum but it doesn't match",
         \\const Foo = enum {
         \\    a,
         \\    b,
         \\};
         \\export fn entry() void {
         \\    const x: Foo = .c;
+        \\    _ = x;
         \\}
     , &[_][]const u8{
         "tmp.zig:6:20: error: enum 'Foo' has no field named 'c'",
         "tmp.zig:1:13: note: 'Foo' declared here",
     });
-    cases.add("discarding error value",
+    ctx.objErrStage1("discarding error value",
         \\export fn entry() void {
         \\    _ = foo();
         \\}
 @@ -2556,7 +2677,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         "tmp.zig:2:12: error: error is discarded. consider using `try`, `catch`, or `if`",
     });
-    cases.add("volatile on global assembly",
+    ctx.objErrStage1("volatile on global assembly",
         \\comptime {
         \\    asm volatile ("");
         \\}
 @@ -2564,7 +2685,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         "tmp.zig:2:9: error: volatile is meaningless on global assembly",
     });
-    cases.add("invalid multiple dereferences",
+    ctx.objErrStage1("invalid multiple dereferences",
         \\export fn a() void {
         \\    var box = Box{ .field = 0 };
         \\    box.*.field = 1;
 @@ -2582,13 +2703,13 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         "tmp.zig:8:13: error: attempt to dereference non-pointer type 'Box'",
     });
-    cases.add("usingnamespace with wrong type",
+    ctx.objErrStage1("usingnamespace with wrong type",
         \\usingnamespace void;
     , &[_][]const u8{
         "tmp.zig:1:1: error: expected struct, enum, or union; found 'void'",
     });
-    cases.add("ignored expression in while continuation",
+    ctx.objErrStage1("ignored expression in while continuation",
         \\export fn a() void {
         \\    while (true) : (bad()) {}
         \\}
 @@ -2609,31 +2730,31 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         "tmp.zig:10:25: error: error is ignored. consider using `try`, `catch`, or `if`",
     });
-    cases.add("empty while loop body",
+    ctx.objErrStage1("empty while loop body",
         \\export fn a() void {
         \\    while(true);
         \\}
     , &[_][]const u8{
-        "tmp.zig:2:16: error: expected loop body, found ';'",
+        "tmp.zig:2:16: error: expected block or assignment, found ';'",
     });
-    cases.add("empty for loop body",
+    ctx.objErrStage1("empty for loop body",
         \\export fn a() void {
         \\    for(undefined) |x|;
         \\}
     , &[_][]const u8{
-        "tmp.zig:2:23: error: expected loop body, found ';'",
+        "tmp.zig:2:23: error: expected block or assignment, found ';'",
     });
-    cases.add("empty if body",
+    ctx.objErrStage1("empty if body",
         \\export fn a() void {
         \\    if(true);
         \\}
     , &[_][]const u8{
-        "tmp.zig:2:13: error: expected if body, found ';'",
+        "tmp.zig:2:13: error: expected block or assignment, found ';'",
     });
-    cases.add("import outside package path",
+    ctx.objErrStage1("import outside package path",
         \\comptime{
         \\    _ = @import("../a.zig");
         \\}
 @@ -2641,14 +2762,14 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         "tmp.zig:2:9: error: import of file outside package path: '../a.zig'",
     });
-    cases.add("bogus compile var",
+    ctx.objErrStage1("bogus compile var",
         \\const x = @import("builtin").bogus;
         \\export fn entry() usize { return @sizeOf(@TypeOf(x)); }
     , &[_][]const u8{
         "tmp.zig:1:29: error: container 'builtin' has no member called 'bogus'",
     });
-    cases.add("wrong panic signature, runtime function",
+    ctx.objErrStage1("wrong panic signature, runtime function",
         \\test "" {}
         \\
         \\pub fn panic() void {}
 @@ -2657,8 +2778,9 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         "error: expected type 'fn([]const u8, ?*std.builtin.StackTrace) noreturn', found 'fn() void'",
     });
-    cases.add("wrong panic signature, generic function",
+    ctx.objErrStage1("wrong panic signature, generic function",
         \\pub fn panic(comptime msg: []const u8, error_return_trace: ?*builtin.StackTrace) noreturn {
+        \\    _ = msg; _ = error_return_trace;
         \\    while (true) {}
         \\}
     , &[_][]const u8{
 @@ -2666,14 +2788,14 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         "note: only one of the functions is generic",
     });
-    cases.add("direct struct loop",
+    ctx.objErrStage1("direct struct loop",
         \\const A = struct { a : A, };
         \\export fn entry() usize { return @sizeOf(A); }
     , &[_][]const u8{
         "tmp.zig:1:11: error: struct 'A' depends on itself",
     });
-    cases.add("indirect struct loop",
+    ctx.objErrStage1("indirect struct loop",
         \\const A = struct { b : B, };
         \\const B = struct { c : C, };
         \\const C = struct { a : A, };
 @@ -2682,7 +2804,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         "tmp.zig:1:11: error: struct 'A' depends on itself",
     });
-    cases.add("instantiating an undefined value for an invalid struct that contains itself",
+    ctx.objErrStage1("instantiating an undefined value for an invalid struct that contains itself",
         \\const Foo = struct {
         \\    x: Foo,
         \\};
 @@ -2697,23 +2819,25 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         "tmp.zig:8:28: note: referenced here",
     });
-    cases.add("enum field value references enum",
+    ctx.objErrStage1("enum field value references enum",
-        \\pub const Foo = extern enum {
+        \\pub const Foo = enum(c_int) {
         \\    A = Foo.B,
         \\    C = D,
         \\};
         \\export fn entry() void {
         \\    var s: Foo = Foo.E;
+        \\    _ = s;
         \\}
     , &[_][]const u8{
         "tmp.zig:1:17: error: enum 'Foo' depends on itself",
     });
-    cases.add("top level decl dependency loop",
+    ctx.objErrStage1("top level decl dependency loop",
         \\const a : @TypeOf(b) = 0;
         \\const b : @TypeOf(a) = 0;
         \\export fn entry() void {
         \\    const c = a + b;
+        \\    _ = c;
         \\}
     , &[_][]const u8{
         "tmp.zig:2:19: error: dependency loop detected",
 @@ -2721,7 +2845,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         "tmp.zig:4:15: note: referenced here",
     });
-    cases.addTest("not an enum type",
+    ctx.testErrStage1("not an enum type",
         \\export fn entry() void {
         \\    var self: Error = undefined;
         \\    switch (self) {
 @@ -2739,18 +2863,19 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         "tmp.zig:4:9: error: expected type '@typeInfo(Error).Union.tag_type.?', found 'type'",
     });
-    cases.addTest("binary OR operator on error sets",
+    ctx.testErrStage1("binary OR operator on error sets",
         \\pub const A = error.A;
         \\pub const AB = A | error.B;
         \\export fn entry() void {
         \\    var x: AB = undefined;
+        \\    _ = x;
         \\}
     , &[_][]const u8{
         "tmp.zig:2:18: error: invalid operands to binary expression: 'error{A}' and 'error{B}'",
     });
     if (std.Target.current.os.tag == .linux) {
-        cases.addTest("implicit dependency on libc",
+        ctx.testErrStage1("implicit dependency on libc",
             \\extern "c" fn exit(u8) void;
             \\export fn entry() void {
             \\    exit(0);
 @@ -2759,7 +2884,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
             "tmp.zig:3:5: error: dependency on libc must be explicitly specified in the build command",
         });
-        cases.addTest("libc headers note",
+        ctx.testErrStage1("libc headers note",
             \\const c = @cImport(@cInclude("stdio.h"));
             \\export fn entry() void {
             \\    _ = c.printf("hello, world!\n");
 @@ -2770,18 +2895,19 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         });
     }
-    cases.addTest("comptime vector overflow shows the index",
+    ctx.testErrStage1("comptime vector overflow shows the index",
         \\comptime {
         \\    var a: @import("std").meta.Vector(4, u8) = [_]u8{ 1, 2, 255, 4 };
         \\    var b: @import("std").meta.Vector(4, u8) = [_]u8{ 5, 6, 1, 8 };
         \\    var x = a + b;
+        \\    _ = x;
         \\}
     , &[_][]const u8{
         "tmp.zig:4:15: error: operation caused overflow",
         "tmp.zig:4:15: note: when computing vector element at index 2",
     });
-    cases.addTest("packed struct with fields of not allowed types",
+    ctx.testErrStage1("packed struct with fields of not allowed types",
         \\const A = packed struct {
         \\    x: anyerror,
         \\};
 @@ -2805,24 +2931,31 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         \\};
         \\export fn entry1() void {
         \\    var a: A = undefined;
+        \\    _ = a;
         \\}
         \\export fn entry2() void {
         \\    var b: B = undefined;
+        \\    _ = b;
         \\}
         \\export fn entry3() void {
         \\    var r: C = undefined;
+        \\    _ = r;
         \\}
         \\export fn entry4() void {
         \\    var d: D = undefined;
+        \\    _ = d;
         \\}
         \\export fn entry5() void {
         \\    var e: E = undefined;
+        \\    _ = e;
         \\}
         \\export fn entry6() void {
         \\    var f: F = undefined;
+        \\    _ = f;
         \\}
         \\export fn entry7() void {
         \\    var g: G = undefined;
+        \\    _ = g;
         \\}
         \\const S = struct {
         \\    x: i32,
 @@ -2843,42 +2976,40 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         "tmp.zig:14:5: error: non-packed, non-extern struct 'U' not allowed in packed struct; no guaranteed in-memory representation",
         "tmp.zig:17:5: error: type '?anyerror' not allowed in packed struct; no guaranteed in-memory representation",
         "tmp.zig:20:5: error: type 'Enum' not allowed in packed struct; no guaranteed in-memory representation",
-        "tmp.zig:50:14: note: enum declaration does not specify an integer tag type",
+        "tmp.zig:57:14: note: enum declaration does not specify an integer tag type",
     });
-    cases.addCase(x: {
+    ctx.objErrStage1("deduplicate undeclared identifier",
-        var tc = cases.create("deduplicate undeclared identifier",
+        \\export fn a() void {
-            \\export fn a() void {
+        \\    x += 1;
-            \\    x += 1;
+        \\}
-            \\}
+        \\export fn b() void {
-            \\export fn b() void {
+        \\    x += 1;
-            \\    x += 1;
+        \\}
-            \\}
+    , &[_][]const u8{
-        , &[_][]const u8{
+        "tmp.zig:2:5: error: use of undeclared identifier 'x'",
-            "tmp.zig:2:5: error: use of undeclared identifier 'x'",
-        });
-        tc.expect_exact = true;
-        break :x tc;
     });
-    cases.add("export generic function",
+    ctx.objErrStage1("export generic function",
         \\export fn foo(num: anytype) i32 {
+        \\    _ = num;
         \\    return 0;
         \\}
     , &[_][]const u8{
         "tmp.zig:1:15: error: parameter of type 'anytype' not allowed in function with calling convention 'C'",
     });
-    cases.add("C pointer to c_void",
+    ctx.objErrStage1("C pointer to c_void",
         \\export fn a() void {
         \\    var x: *c_void = undefined;
         \\    var y: [*c]c_void = x;
+        \\    _ = y;
         \\}
     , &[_][]const u8{
         "tmp.zig:3:16: error: C pointers cannot point to opaque types",
     });
-    cases.add("directly embedding opaque type in struct and union",
+    ctx.objErrStage1("directly embedding opaque type in struct and union",
         \\const O = opaque {};
         \\const Foo = struct {
         \\    o: O,
 @@ -2889,74 +3020,85 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         \\};
         \\export fn a() void {
         \\    var foo: Foo = undefined;
+        \\    _ = foo;
         \\}
         \\export fn b() void {
         \\    var bar: Bar = undefined;
+        \\    _ = bar;
         \\}
         \\export fn c() void {
         \\    var baz: *opaque {} = undefined;
         \\    const qux = .{baz.*};
+        \\    _ = qux;
         \\}
     , &[_][]const u8{
         "tmp.zig:3:5: error: opaque types have unknown size and therefore cannot be directly embedded in structs",
         "tmp.zig:7:5: error: opaque types have unknown size and therefore cannot be directly embedded in unions",
-        "tmp.zig:17:22: error: opaque types have unknown size and therefore cannot be directly embedded in structs",
+        "tmp.zig:19:22: error: opaque types have unknown size and therefore cannot be directly embedded in structs",
     });
-    cases.add("implicit cast between C pointer and Zig pointer - bad const/align/child",
+    ctx.objErrStage1("implicit cast between C pointer and Zig pointer - bad const/align/child",
         \\export fn a() void {
         \\    var x: [*c]u8 = undefined;
         \\    var y: *align(4) u8 = x;
+        \\    _ = y;
         \\}
         \\export fn b() void {
         \\    var x: [*c]const u8 = undefined;
         \\    var y: *u8 = x;
+        \\    _ = y;
         \\}
         \\export fn c() void {
         \\    var x: [*c]u8 = undefined;
         \\    var y: *u32 = x;
+        \\    _ = y;
         \\}
         \\export fn d() void {
         \\    var y: *align(1) u32 = undefined;
         \\    var x: [*c]u32 = y;
+        \\    _ = x;
         \\}
         \\export fn e() void {
         \\    var y: *const u8 = undefined;
         \\    var x: [*c]u8 = y;
+        \\    _ = x;
         \\}
         \\export fn f() void {
         \\    var y: *u8 = undefined;
         \\    var x: [*c]u32 = y;
+        \\    _ = x;
         \\}
     , &[_][]const u8{
         "tmp.zig:3:27: error: cast increases pointer alignment",
-        "tmp.zig:7:18: error: cast discards const qualifier",
+        "tmp.zig:8:18: error: cast discards const qualifier",
-        "tmp.zig:11:19: error: expected type '*u32', found '[*c]u8'",
+        "tmp.zig:13:19: error: expected type '*u32', found '[*c]u8'",
-        "tmp.zig:11:19: note: pointer type child 'u8' cannot cast into pointer type child 'u32'",
+        "tmp.zig:13:19: note: pointer type child 'u8' cannot cast into pointer type child 'u32'",
-        "tmp.zig:15:22: error: cast increases pointer alignment",
+        "tmp.zig:18:22: error: cast increases pointer alignment",
-        "tmp.zig:19:21: error: cast discards const qualifier",
+        "tmp.zig:23:21: error: cast discards const qualifier",
-        "tmp.zig:23:22: error: expected type '[*c]u32', found '*u8'",
+        "tmp.zig:28:22: error: expected type '[*c]u32', found '*u8'",
     });
-    cases.add("implicit casting null c pointer to zig pointer",
+    ctx.objErrStage1("implicit casting null c pointer to zig pointer",
         \\comptime {
         \\    var c_ptr: [*c]u8 = 0;
         \\    var zig_ptr: *u8 = c_ptr;
+        \\    _ = zig_ptr;
         \\}
     , &[_][]const u8{
         "tmp.zig:3:24: error: null pointer casted to type '*u8'",
     });
-    cases.add("implicit casting undefined c pointer to zig pointer",
+    ctx.objErrStage1("implicit casting undefined c pointer to zig pointer",
         \\comptime {
         \\    var c_ptr: [*c]u8 = undefined;
         \\    var zig_ptr: *u8 = c_ptr;
+        \\    _ = zig_ptr;
         \\}
     , &[_][]const u8{
         "tmp.zig:3:24: error: use of undefined value here causes undefined behavior",
     });
-    cases.add("implicit casting C pointers which would mess up null semantics",
+    ctx.objErrStage1("implicit casting C pointers which would mess up null semantics",
         \\export fn entry() void {
         \\    var slice: []const u8 = "aoeu";
         \\    const opt_many_ptr: [*]const u8 = slice.ptr;
 @@ -2970,6 +3112,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         \\    var opt_many_ptr: [*]u8 = slice.ptr;
         \\    var ptr_opt_many_ptr = &opt_many_ptr;
         \\    var c_ptr: [*c][*c]const u8 = ptr_opt_many_ptr;
+        \\    _ = c_ptr;
         \\}
     , &[_][]const u8{
         "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 {
         "tmp.zig:13:35: note: mutable '[*c]const u8' allows illegal null values stored to type '[*]u8'",
     });
-    cases.add("implicit casting too big integers to C pointers",
+    ctx.objErrStage1("implicit casting too big integers to C pointers",
         \\export fn a() void {
         \\    var ptr: [*c]u8 = (1 << 64) + 1;
+        \\    _ = ptr;
         \\}
         \\export fn b() void {
         \\    var x: u65 = 0x1234;
         \\    var ptr: [*c]u8 = x;
+        \\    _ = ptr;
         \\}
     , &[_][]const u8{
         "tmp.zig:2:33: error: integer value 18446744073709551617 cannot be coerced to type 'usize'",
-        "tmp.zig:6:23: error: integer type 'u65' too big for implicit @intToPtr to type '[*c]u8'",
+        "tmp.zig:7:23: error: integer type 'u65' too big for implicit @intToPtr to type '[*c]u8'",
     });
-    cases.add("C pointer pointing to non C ABI compatible type or has align attr",
+    ctx.objErrStage1("C pointer pointing to non C ABI compatible type or has align attr",
         \\const Foo = struct {};
         \\export fn a() void {
         \\    const T = [*c]Foo;
         \\    var t: T = undefined;
+        \\    _ = t;
         \\}
     , &[_][]const u8{
         "tmp.zig:3:19: error: C pointers cannot point to non-C-ABI-compatible type 'Foo'",
     });
-    cases.addCase(x: {
+    ctx.objErrStage1("compile log statement warning deduplication in generic fn",
-        var tc = cases.create("compile log statement warning deduplication in generic fn",
+        \\export fn entry() void {
-            \\export fn entry() void {
+        \\    inner(1);
-            \\    inner(1);
+        \\    inner(2);
-            \\    inner(2);
+        \\}
-            \\}
+        \\fn inner(comptime n: usize) void {
-            \\fn inner(comptime n: usize) void {
+        \\    comptime var i = 0;
-            \\    comptime var i = 0;
+        \\    inline while (i < n) : (i += 1) { @compileLog("!@#$"); }
-            \\    inline while (i < n) : (i += 1) { @compileLog("!@#$"); }
+        \\}
-            \\}
+    , &[_][]const u8{
-        , &[_][]const u8{
+        "tmp.zig:7:39: error: found compile log statement",
-            "tmp.zig:7:39: error: found compile log statement",
-        });
-        tc.expect_exact = true;
-        break :x tc;
     });
-    cases.add("assign to invalid dereference",
+    ctx.objErrStage1("assign to invalid dereference",
         \\export fn entry() void {
         \\    'a'.* = 1;
         \\}
 @@ -3028,54 +3170,58 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         "tmp.zig:2:8: error: attempt to dereference non-pointer type 'comptime_int'",
     });
-    cases.add("take slice of invalid dereference",
+    ctx.objErrStage1("take slice of invalid dereference",
         \\export fn entry() void {
         \\    const x = 'a'.*[0..];
+        \\    _ = x;
         \\}
     , &[_][]const u8{
         "tmp.zig:2:18: error: attempt to dereference non-pointer type 'comptime_int'",
     });
-    cases.add("@truncate undefined value",
+    ctx.objErrStage1("@truncate undefined value",
         \\export fn entry() void {
         \\    var z = @truncate(u8, @as(u16, undefined));
+        \\    _ = z;
         \\}
     , &[_][]const u8{
         "tmp.zig:2:27: error: use of undefined value here causes undefined behavior",
     });
-    cases.addTest("return invalid type from test",
+    ctx.testErrStage1("return invalid type from test",
         \\test "example" { return 1; }
     , &[_][]const u8{
         "tmp.zig:1:25: error: expected type 'void', found 'comptime_int'",
     });
-    cases.add("threadlocal qualifier on const",
+    ctx.objErrStage1("threadlocal qualifier on const",
         \\threadlocal const x: i32 = 1234;
         \\export fn entry() i32 {
         \\    return x;
         \\}
     , &[_][]const u8{
-        "tmp.zig:1:13: error: threadlocal variable cannot be constant",
+        "tmp.zig:1:1: error: threadlocal variable cannot be constant",
     });
-    cases.add("@bitCast same size but bit count mismatch",
+    ctx.objErrStage1("@bitCast same size but bit count mismatch",
         \\export fn entry(byte: u8) void {
         \\    var oops = @bitCast(u7, byte);
+        \\    _ = oops;
         \\}
     , &[_][]const u8{
         "tmp.zig:2:25: error: destination type 'u7' has 7 bits but source type 'u8' has 8 bits",
     });
-    cases.add("@bitCast with different sizes inside an expression",
+    ctx.objErrStage1("@bitCast with different sizes inside an expression",
         \\export fn entry() void {
         \\    var foo = (@bitCast(u8, @as(f32, 1.0)) == 0xf);
+        \\    _ = foo;
         \\}
     , &[_][]const u8{
         "tmp.zig:2:25: error: destination type 'u8' has size 1 but source type 'f32' has size 4",
     });
-    cases.add("attempted `&&`",
+    ctx.objErrStage1("attempted `&&`",
         \\export fn entry(a: bool, b: bool) i32 {
         \\    if (a && b) {
         \\        return 1234;
 @@ -3083,10 +3229,10 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         \\    return 5678;
         \\}
     , &[_][]const u8{
-        "tmp.zig:2:12: error: `&&` is invalid. Note that `and` is boolean AND",
+        "tmp.zig:2:11: error: `&&` is invalid; note that `and` is boolean AND",
     });
-    cases.add("attempted `||` on boolean values",
+    ctx.objErrStage1("attempted `||` on boolean values",
         \\export fn entry(a: bool, b: bool) i32 {
         \\    if (a || b) {
         \\        return 1234;
 @@ -3098,7 +3244,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         "tmp.zig:2:11: note: `||` merges error sets; `or` performs boolean OR",
     });
-    cases.add("compile log a pointer to an opaque value",
+    ctx.objErrStage1("compile log a pointer to an opaque value",
         \\export fn entry() void {
         \\    @compileLog(@ptrCast(*const c_void, &entry));
         \\}
 @@ -3106,13 +3252,14 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         "tmp.zig:2:5: error: found compile log statement",
     });
-    cases.add("duplicate boolean switch value",
+    ctx.objErrStage1("duplicate boolean switch value",
         \\comptime {
         \\    const x = switch (true) {
         \\        true => false,
         \\        false => true,
         \\        true => false,
         \\    };
+        \\    _ = x;
         \\}
         \\comptime {
         \\    const x = switch (true) {
 @@ -3120,42 +3267,46 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         \\        true => false,
         \\        false => true,
         \\    };
+        \\    _ = x;
         \\}
     , &[_][]const u8{
         "tmp.zig:5:9: error: duplicate switch value",
-        "tmp.zig:12:9: error: duplicate switch value",
+        "tmp.zig:13:9: error: duplicate switch value",
     });
-    cases.add("missing boolean switch value",
+    ctx.objErrStage1("missing boolean switch value",
         \\comptime {
         \\    const x = switch (true) {
         \\        true => false,
         \\    };
+        \\    _ = x;
         \\}
         \\comptime {
         \\    const x = switch (true) {
         \\        false => true,
         \\    };
+        \\    _ = x;
         \\}
     , &[_][]const u8{
         "tmp.zig:2:15: error: switch must handle all possibilities",
-        "tmp.zig:7:15: error: switch must handle all possibilities",
+        "tmp.zig:8:15: error: switch must handle all possibilities",
     });
-    cases.add("reading past end of pointer casted array",
+    ctx.objErrStage1("reading past end of pointer casted array",
         \\comptime {
         \\    const array: [4]u8 = "aoeu".*;
         \\    const sub_array = array[1..];
         \\    const int_ptr = @ptrCast(*const u24, sub_array);
         \\    const deref = int_ptr.*;
+        \\    _ = deref;
         \\}
     , &[_][]const u8{
         "tmp.zig:5:26: error: attempt to read 4 bytes from [4]u8 at index 1 which is 3 bytes",
     });
-    cases.add("error note for function parameter incompatibility",
+    ctx.objErrStage1("error note for function parameter incompatibility",
-        \\fn do_the_thing(func: fn (arg: i32) void) void {}
+        \\fn do_the_thing(func: fn (arg: i32) void) void { _ = func; }
-        \\fn bar(arg: bool) void {}
+        \\fn bar(arg: bool) void { _ = arg; }
         \\export fn entry() void {
         \\    do_the_thing(bar);
         \\}
 @@ -3163,56 +3314,63 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         "tmp.zig:4:18: error: expected type 'fn(i32) void', found 'fn(bool) void",
         "tmp.zig:4:18: note: parameter 0: 'bool' cannot cast into 'i32'",
     });
-    cases.add("cast negative value to unsigned integer",
+    ctx.objErrStage1("cast negative value to unsigned integer",
         \\comptime {
         \\    const value: i32 = -1;
         \\    const unsigned = @intCast(u32, value);
+        \\    _ = unsigned;
         \\}
         \\export fn entry1() void {
         \\    const value: i32 = -1;
         \\    const unsigned: u32 = value;
+        \\    _ = unsigned;
         \\}
     , &[_][]const u8{
         "tmp.zig:3:22: error: attempt to cast negative value to unsigned integer",
-        "tmp.zig:7:27: error: cannot cast negative value -1 to unsigned integer type 'u32'",
+        "tmp.zig:8:27: error: cannot cast negative value -1 to unsigned integer type 'u32'",
     });
-    cases.add("integer cast truncates bits",
+    ctx.objErrStage1("integer cast truncates bits",
         \\export fn entry1() void {
         \\    const spartan_count: u16 = 300;
         \\    const byte = @intCast(u8, spartan_count);
+        \\    _ = byte;
         \\}
         \\export fn entry2() void {
         \\    const spartan_count: u16 = 300;
         \\    const byte: u8 = spartan_count;
+        \\    _ = byte;
         \\}
         \\export fn entry3() void {
         \\    var spartan_count: u16 = 300;
         \\    var byte: u8 = spartan_count;
+        \\    _ = byte;
         \\}
         \\export fn entry4() void {
         \\    var signed: i8 = -1;
         \\    var unsigned: u64 = signed;
+        \\    _ = unsigned;
         \\}
     , &[_][]const u8{
         "tmp.zig:3:18: error: cast from 'u16' to 'u8' truncates bits",
-        "tmp.zig:7:22: error: integer value 300 cannot be coerced to type 'u8'",
+        "tmp.zig:8:22: error: integer value 300 cannot be coerced to type 'u8'",
-        "tmp.zig:11:20: error: expected type 'u8', found 'u16'",
+        "tmp.zig:13:20: error: expected type 'u8', found 'u16'",
-        "tmp.zig:11:20: note: unsigned 8-bit int cannot represent all possible unsigned 16-bit values",
+        "tmp.zig:13:20: note: unsigned 8-bit int cannot represent all possible unsigned 16-bit values",
-        "tmp.zig:15:25: error: expected type 'u64', found 'i8'",
+        "tmp.zig:18:25: error: expected type 'u64', found 'i8'",
-        "tmp.zig:15:25: note: unsigned 64-bit int cannot represent all possible signed 8-bit values",
+        "tmp.zig:18:25: note: unsigned 64-bit int cannot represent all possible signed 8-bit values",
     });
-    cases.add("comptime implicit cast f64 to f32",
+    ctx.objErrStage1("comptime implicit cast f64 to f32",
         \\export fn entry() void {
         \\    const x: f64 = 16777217;
         \\    const y: f32 = x;
+        \\    _ = y;
         \\}
     , &[_][]const u8{
         "tmp.zig:3:20: error: cast of value 16777217.000000 to type 'f32' loses information",
     });
-    cases.add("implicit cast from f64 to f32",
+    ctx.objErrStage1("implicit cast from f64 to f32",
         \\var x: f64 = 1.0;
         \\var y: f32 = x;
         \\
 @@ -3221,41 +3379,46 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         "tmp.zig:2:14: error: expected type 'f32', found 'f64'",
     });
-    cases.add("exceeded maximum bit width of integer",
+    ctx.objErrStage1("exceeded maximum bit width of integer",
         \\export fn entry1() void {
         \\    const T = u65536;
+        \\    _ = T;
         \\}
         \\export fn entry2() void {
         \\    var x: i65536 = 1;
+        \\    _ = x;
         \\}
     , &[_][]const u8{
-        "tmp.zig:5:12: error: primitive integer type 'i65536' exceeds maximum bit width of 65535",
+        "tmp.zig:2:15: error: primitive integer type 'u65536' exceeds maximum bit width of 65535",
+        "tmp.zig:6:12: error: primitive integer type 'i65536' exceeds maximum bit width of 65535",
     });
-    cases.add("compile error when evaluating return type of inferred error set",
+    ctx.objErrStage1("compile error when evaluating return type of inferred error set",
         \\const Car = struct {
         \\    foo: *SymbolThatDoesNotExist,
         \\    pub fn init() !Car {}
         \\};
         \\export fn entry() void {
         \\    const car = Car.init();
+        \\    _ = car;
         \\}
     , &[_][]const u8{
         "tmp.zig:2:11: error: use of undeclared identifier 'SymbolThatDoesNotExist'",
     });
-    cases.add("don't implicit cast double pointer to *c_void",
+    ctx.objErrStage1("don't implicit cast double pointer to *c_void",
         \\export fn entry() void {
         \\    var a: u32 = 1;
         \\    var ptr: *align(@alignOf(u32)) c_void = &a;
         \\    var b: *u32 = @ptrCast(*u32, ptr);
         \\    var ptr2: *c_void = &b;
+        \\    _ = ptr2;
         \\}
     , &[_][]const u8{
         "tmp.zig:5:26: error: expected type '*c_void', found '**u32'",
     });
-    cases.add("runtime index into comptime type slice",
+    ctx.objErrStage1("runtime index into comptime type slice",
         \\const Struct = struct {
         \\    a: u32,
         \\};
 @@ -3265,12 +3428,13 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         \\export fn entry() void {
         \\    const index = getIndex();
         \\    const field = @typeInfo(Struct).Struct.fields[index];
+        \\    _ = field;
         \\}
     , &[_][]const u8{
         "tmp.zig:9:51: error: values of type 'std.builtin.StructField' must be comptime known, but index value is runtime known",
     });
-    cases.add("compile log statement inside function which must be comptime evaluated",
+    ctx.objErrStage1("compile log statement inside function which must be comptime evaluated",
         \\fn Foo(comptime T: type) type {
         \\    @compileLog(@typeName(T));
         \\    return T;
 @@ -3283,25 +3447,27 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         "tmp.zig:2:5: error: found compile log statement",
     });
-    cases.add("comptime slice of an undefined slice",
+    ctx.objErrStage1("comptime slice of an undefined slice",
         \\comptime {
         \\    var a: []u8 = undefined;
         \\    var b = a[0..10];
+        \\    _ = b;
         \\}
     , &[_][]const u8{
         "tmp.zig:3:14: error: slice of undefined",
     });
-    cases.add("implicit cast const array to mutable slice",
+    ctx.objErrStage1("implicit cast const array to mutable slice",
         \\export fn entry() void {
         \\    const buffer: [1]u8 = [_]u8{8};
         \\    const sliceA: []u8 = &buffer;
+        \\    _ = sliceA;
         \\}
     , &[_][]const u8{
         "tmp.zig:3:27: error: expected type '[]u8', found '*const [1]u8'",
     });
-    cases.add("deref slice and get len field",
+    ctx.objErrStage1("deref slice and get len field",
         \\export fn entry() void {
         \\    var a: []u8 = undefined;
         \\    _ = a.*.len;
 @@ -3310,7 +3476,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         "tmp.zig:3:10: error: attempt to dereference non-pointer type '[]u8'",
     });
-    cases.add("@ptrCast a 0 bit type to a non- 0 bit type",
+    ctx.objErrStage1("@ptrCast a 0 bit type to a non- 0 bit type",
         \\export fn entry() bool {
         \\    var x: u0 = 0;
         \\    const p = @ptrCast(?*u0, &x);
 @@ -3322,7 +3488,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         "tmp.zig:3:24: note: '?*u0' has in-memory bits",
     });
-    cases.add("comparing a non-optional pointer against null",
+    ctx.objErrStage1("comparing a non-optional pointer against null",
         \\export fn entry() void {
         \\    var x: i32 = 1;
         \\    _ = &x == null;
 @@ -3331,21 +3497,23 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         "tmp.zig:3:12: error: comparison of '*i32' with null",
     });
-    cases.add("non error sets used in merge error sets operator",
+    ctx.objErrStage1("non error sets used in merge error sets operator",
         \\export fn foo() void {
         \\    const Errors = u8 || u16;
+        \\    _ = Errors;
         \\}
         \\export fn bar() void {
         \\    const Errors = error{} || u16;
+        \\    _ = Errors;
         \\}
     , &[_][]const u8{
         "tmp.zig:2:20: error: expected error set type, found type 'u8'",
         "tmp.zig:2:23: note: `||` merges error sets; `or` performs boolean OR",
-        "tmp.zig:5:31: error: expected error set type, found type 'u16'",
+        "tmp.zig:6:31: error: expected error set type, found type 'u16'",
-        "tmp.zig:5:28: note: `||` merges error sets; `or` performs boolean OR",
+        "tmp.zig:6:28: note: `||` merges error sets; `or` performs boolean OR",
     });
-    cases.add("variable initialization compile error then referenced",
+    ctx.objErrStage1("variable initialization compile error then referenced",
         \\fn Undeclared() type {
         \\    return T;
         \\}
 @@ -3357,12 +3525,13 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         \\}
         \\export fn entry() void {
         \\    const S = Gen();
+        \\    _ = S;
         \\}
     , &[_][]const u8{
         "tmp.zig:2:12: error: use of undeclared identifier 'T'",
     });
-    cases.add("refer to the type of a generic function",
+    ctx.objErrStage1("refer to the type of a generic function",
         \\export fn entry() void {
         \\    const Func = fn (type) void;
         \\    const f: Func = undefined;
 @@ -3372,7 +3541,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         "tmp.zig:4:5: error: use of undefined value here causes undefined behavior",
     });
-    cases.add("accessing runtime parameter from outer function",
+    ctx.objErrStage1("accessing runtime parameter from outer function",
         \\fn outer(y: u32) fn (u32) u32 {
         \\    const st = struct {
         \\        fn get(z: u32) u32 {
 @@ -3384,6 +3553,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         \\export fn entry() void {
         \\    var func = outer(10);
         \\    var x = func(3);
+        \\    _ = x;
         \\}
     , &[_][]const u8{
         "tmp.zig:4:24: error: 'y' not accessible from inner function",
 @@ -3391,69 +3561,74 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         "tmp.zig:1:10: note: declared here",
     });
-    cases.add("non int passed to @intToFloat",
+    ctx.objErrStage1("non int passed to @intToFloat",
         \\export fn entry() void {
         \\    const x = @intToFloat(f32, 1.1);
+        \\    _ = x;
         \\}
     , &[_][]const u8{
         "tmp.zig:2:32: error: expected int type, found 'comptime_float'",
     });
-    cases.add("non float passed to @floatToInt",
+    ctx.objErrStage1("non float passed to @floatToInt",
         \\export fn entry() void {
         \\    const x = @floatToInt(i32, @as(i32, 54));
+        \\    _ = x;
         \\}
     , &[_][]const u8{
         "tmp.zig:2:32: error: expected float type, found 'i32'",
     });
-    cases.add("out of range comptime_int passed to @floatToInt",
+    ctx.objErrStage1("out of range comptime_int passed to @floatToInt",
         \\export fn entry() void {
         \\    const x = @floatToInt(i8, 200);
+        \\    _ = x;
         \\}
     , &[_][]const u8{
         "tmp.zig:2:31: error: integer value 200 cannot be coerced to type 'i8'",
     });
-    cases.add("load too many bytes from comptime reinterpreted pointer",
+    ctx.objErrStage1("load too many bytes from comptime reinterpreted pointer",
         \\export fn entry() void {
         \\    const float: f32 = 5.99999999999994648725e-01;
         \\    const float_ptr = &float;
         \\    const int_ptr = @ptrCast(*const i64, float_ptr);
         \\    const int_val = int_ptr.*;
+        \\    _ = int_val;
         \\}
     , &[_][]const u8{
         "tmp.zig:5:28: error: attempt to read 8 bytes from pointer to f32 which is 4 bytes",
     });
-    cases.add("invalid type used in array type",
+    ctx.objErrStage1("invalid type used in array type",
         \\const Item = struct {
         \\    field: SomeNonexistentType,
         \\};
         \\var items: [100]Item = undefined;
         \\export fn entry() void {
         \\    const a = items[0];
+        \\    _ = a;
         \\}
     , &[_][]const u8{
         "tmp.zig:2:12: error: use of undeclared identifier 'SomeNonexistentType'",
     });
-    cases.add("comptime continue inside runtime catch",
+    ctx.objErrStage1("comptime continue inside runtime catch",
-        \\export fn entry(c: bool) void {
+        \\export fn entry() void {
         \\    const ints = [_]u8{ 1, 2 };
         \\    inline for (ints) |_| {
-        \\        bad() catch |_| continue;
+        \\        bad() catch continue;
         \\    }
         \\}
         \\fn bad() !void {
         \\    return error.Bad;
         \\}
     , &[_][]const u8{
-        "tmp.zig:4:25: error: comptime control flow inside runtime block",
+        "tmp.zig:4:21: error: comptime control flow inside runtime block",
         "tmp.zig:4:15: note: runtime block created here",
     });
-    cases.add("comptime continue inside runtime switch",
+    ctx.objErrStage1("comptime continue inside runtime switch",
         \\export fn entry() void {
         \\    var p: i32 = undefined;
         \\    comptime var q = true;
 @@ -3470,7 +3645,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         "tmp.zig:5:9: note: runtime block created here",
     });
-    cases.add("comptime continue inside runtime while error",
+    ctx.objErrStage1("comptime continue inside runtime while error",
         \\export fn entry() void {
         \\    var p: anyerror!usize = undefined;
         \\    comptime var q = true;
 @@ -3486,7 +3661,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         "tmp.zig:5:9: note: runtime block created here",
     });
-    cases.add("comptime continue inside runtime while optional",
+    ctx.objErrStage1("comptime continue inside runtime while optional",
         \\export fn entry() void {
         \\    var p: ?usize = undefined;
         \\    comptime var q = true;
 @@ -3500,7 +3675,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         "tmp.zig:5:9: note: runtime block created here",
     });
-    cases.add("comptime continue inside runtime while bool",
+    ctx.objErrStage1("comptime continue inside runtime while bool",
         \\export fn entry() void {
         \\    var p: usize = undefined;
         \\    comptime var q = true;
 @@ -3514,7 +3689,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         "tmp.zig:5:9: note: runtime block created here",
     });
-    cases.add("comptime continue inside runtime if error",
+    ctx.objErrStage1("comptime continue inside runtime if error",
         \\export fn entry() void {
         \\    var p: anyerror!i32 = undefined;
         \\    comptime var q = true;
 @@ -3528,7 +3703,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         "tmp.zig:5:9: note: runtime block created here",
     });
-    cases.add("comptime continue inside runtime if optional",
+    ctx.objErrStage1("comptime continue inside runtime if optional",
         \\export fn entry() void {
         \\    var p: ?i32 = undefined;
         \\    comptime var q = true;
 @@ -3542,7 +3717,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         "tmp.zig:5:9: note: runtime block created here",
     });
-    cases.add("comptime continue inside runtime if bool",
+    ctx.objErrStage1("comptime continue inside runtime if bool",
         \\export fn entry() void {
         \\    var p: usize = undefined;
         \\    comptime var q = true;
 @@ -3556,22 +3731,23 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         "tmp.zig:5:9: note: runtime block created here",
     });
-    cases.add("switch with invalid expression parameter",
+    ctx.objErrStage1("switch with invalid expression parameter",
         \\export fn entry() void {
         \\    Test(i32);
         \\}
         \\fn Test(comptime T: type) void {
         \\    const x = switch (T) {
-        \\        []u8 => |x| 123,
+        \\        []u8 => |x| x,
-        \\        i32 => |x| 456,
+        \\        i32 => |x| x,
         \\        else => unreachable,
         \\    };
+        \\    _ = x;
         \\}
     , &[_][]const u8{
         "tmp.zig:7:17: error: switch on type 'type' provides no expression parameter",
     });
-    cases.add("function prototype with no body",
+    ctx.objErrStage1("function prototype with no body",
         \\fn foo() void;
         \\export fn entry() void {
         \\    foo();
 @@ -3580,7 +3756,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         "tmp.zig:1:1: error: non-extern function has no body",
     });
-    cases.add("@frame() called outside of function definition",
+    ctx.objErrStage1("@frame() called outside of function definition",
         \\var handle_undef: anyframe = undefined;
         \\var handle_dummy: anyframe = @frame();
         \\export fn entry() bool {
 @@ -3590,16 +3766,16 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         "tmp.zig:2:30: error: @frame() called outside of function definition",
     });
-    cases.add("`_` is not a declarable symbol",
+    ctx.objErrStage1("`_` is not a declarable symbol",
         \\export fn f1() usize {
         \\    var _: usize = 2;
         \\    return _;
         \\}
     , &[_][]const u8{
-        "tmp.zig:2:5: error: `_` is not a declarable symbol",
+        "tmp.zig:2:9: error: '_' used as an identifier without @\"_\" syntax",
     });
-    cases.add("`_` should not be usable inside for",
+    ctx.objErrStage1("`_` should not be usable inside for",
         \\export fn returns() void {
         \\    for ([_]void{}) |_, i| {
         \\        for ([_]void{}) |_, j| {
 @@ -3608,10 +3784,10 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         \\    }
         \\}
     , &[_][]const u8{
-        "tmp.zig:4:20: error: `_` may only be used to assign things to",
+        "tmp.zig:4:20: error: '_' used as an identifier without @\"_\" syntax",
     });
-    cases.add("`_` should not be usable inside while",
+    ctx.objErrStage1("`_` should not be usable inside while",
         \\export fn returns() void {
         \\    while (optionalReturn()) |_| {
         \\        while (optionalReturn()) |_| {
 @@ -3623,10 +3799,10 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         \\    return 1;
         \\}
     , &[_][]const u8{
-        "tmp.zig:4:20: error: `_` may only be used to assign things to",
+        "tmp.zig:4:20: error: '_' used as an identifier without @\"_\" syntax",
     });
-    cases.add("`_` should not be usable inside while else",
+    ctx.objErrStage1("`_` should not be usable inside while else",
         \\export fn returns() void {
         \\    while (optionalReturnError()) |_| {
         \\        while (optionalReturnError()) |_| {
 @@ -3640,10 +3816,10 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         \\    return error.optionalReturnError;
         \\}
     , &[_][]const u8{
-        "tmp.zig:6:17: error: `_` may only be used to assign things to",
+        "tmp.zig:6:17: error: '_' used as an identifier without @\"_\" syntax",
     });
-    cases.add("while loop body expression ignored",
+    ctx.objErrStage1("while loop body expression ignored",
         \\fn returns() usize {
         \\    return 2;
         \\}
 @@ -3664,7 +3840,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         "tmp.zig:13:26: error: expression value is ignored",
     });
-    cases.add("missing parameter name of generic function",
+    ctx.objErrStage1("missing parameter name of generic function",
         \\fn dump(anytype) void {}
         \\export fn entry() void {
         \\    var a: u8 = 9;
 @@ -3674,20 +3850,20 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         "tmp.zig:1:9: error: missing parameter name",
     });
-    cases.add("non-inline for loop on a type that requires comptime",
+    ctx.objErrStage1("non-inline for loop on a type that requires comptime",
         \\const Foo = struct {
         \\    name: []const u8,
         \\    T: type,
         \\};
         \\export fn entry() void {
         \\    const xx: [2]Foo = undefined;
-        \\    for (xx) |f| {}
+        \\    for (xx) |f| { _ = f;}
         \\}
     , &[_][]const u8{
         "tmp.zig:7:5: error: values of type 'Foo' must be comptime known, but index value is runtime known",
     });
-    cases.add("generic fn as parameter without comptime keyword",
+    ctx.objErrStage1("generic fn as parameter without comptime keyword",
         \\fn f(_: fn (anytype) void) void {}
         \\fn g(_: anytype) void {}
         \\export fn entry() void {
 @@ -3697,7 +3873,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         "tmp.zig:1:9: error: parameter of type 'fn(anytype) anytype' must be declared comptime",
     });
-    cases.add("optional pointer to void in extern struct",
+    ctx.objErrStage1("optional pointer to void in extern struct",
         \\const Foo = extern struct {
         \\    x: ?*const void,
         \\};
 @@ -3705,12 +3881,12 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         \\    foo: Foo,
         \\    y: i32,
         \\};
-        \\export fn entry(bar: *Bar) void {}
+        \\export fn entry(bar: *Bar) void {_ = bar;}
     , &[_][]const u8{
         "tmp.zig:2:5: error: extern structs cannot contain fields of type '?*const void'",
     });
-    cases.add("use of comptime-known undefined function value",
+    ctx.objErrStage1("use of comptime-known undefined function value",
         \\const Cmd = struct {
         \\    exec: fn () void,
         \\};
 @@ -3722,7 +3898,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         "tmp.zig:6:12: error: use of undefined value here causes undefined behavior",
     });
-    cases.add("use of comptime-known undefined function value",
+    ctx.objErrStage1("use of comptime-known undefined function value",
         \\const Cmd = struct {
         \\    exec: fn () void,
         \\};
 @@ -3734,16 +3910,17 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         "tmp.zig:6:12: error: use of undefined value here causes undefined behavior",
     });
-    cases.add("bad @alignCast at comptime",
+    ctx.objErrStage1("bad @alignCast at comptime",
         \\comptime {
         \\    const ptr = @intToPtr(*align(1) i32, 0x1);
         \\    const aligned = @alignCast(4, ptr);
+        \\    _ = aligned;
         \\}
     , &[_][]const u8{
         "tmp.zig:3:35: error: pointer address 0x1 is not aligned to 4 bytes",
     });
-    cases.add("@ptrToInt on *void",
+    ctx.objErrStage1("@ptrToInt on *void",
         \\export fn entry() bool {
         \\    return @ptrToInt(&{}) == @ptrToInt(&{});
         \\}
 @@ -3751,7 +3928,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         "tmp.zig:2:23: error: pointer to size 0 type has no address",
     });
-    cases.add("@popCount - non-integer",
+    ctx.objErrStage1("@popCount - non-integer",
         \\export fn entry(x: f32) u32 {
         \\    return @popCount(f32, x);
         \\}
 @@ -3759,8 +3936,23 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         "tmp.zig:2:22: error: expected integer type, found 'f32'",
     });
-    cases.addCase(x: {
+    {
-        const tc = cases.create("wrong same named struct",
+        const case = ctx.obj("wrong same named struct", .{});
+        case.backend = .stage1;
+        case.addSourceFile("a.zig",
+            \\pub const Foo = struct {
+            \\    x: i32,
+            \\};
+        );
+        case.addSourceFile("b.zig",
+            \\pub const Foo = struct {
+            \\    z: f64,
+            \\};
+        );
+        case.addError(
             \\const a = @import("a.zig");
             \\const b = @import("b.zig");
             \\
 @@ -3769,30 +3961,16 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
             \\    bar(&a1);
             \\}
             \\
-            \\fn bar(x: *b.Foo) void {}
+            \\fn bar(x: *b.Foo) void {_ = x;}
         , &[_][]const u8{
             "tmp.zig:6:10: error: expected type '*b.Foo', found '*a.Foo'",
             "tmp.zig:6:10: note: pointer type child 'a.Foo' cannot cast into pointer type child 'b.Foo'",
             "a.zig:1:17: note: a.Foo declared here",
             "b.zig:1:17: note: b.Foo declared here",
         });
+    }
-        tc.addSourceFile("a.zig",
+    ctx.objErrStage1("@floatToInt comptime safety",
-            \\pub const Foo = struct {
-            \\    x: i32,
-            \\};
-        );
-        tc.addSourceFile("b.zig",
-            \\pub const Foo = struct {
-            \\    z: f64,
-            \\};
-        );
-        break :x tc;
-    });
-    cases.add("@floatToInt comptime safety",
         \\comptime {
         \\    _ = @floatToInt(i8, @as(f32, -129.1));
         \\}
 @@ -3808,35 +3986,38 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         "tmp.zig:8:9: error: integer value '256' cannot be stored in type 'u8'",
     });
-    cases.add("use c_void as return type of fn ptr",
+    ctx.objErrStage1("use c_void as return type of fn ptr",
         \\export fn entry() void {
         \\    const a: fn () c_void = undefined;
+        \\    _ = a;
         \\}
     , &[_][]const u8{
         "tmp.zig:2:20: error: return type cannot be opaque",
     });
-    cases.add("use implicit casts to assign null to non-nullable pointer",
+    ctx.objErrStage1("use implicit casts to assign null to non-nullable pointer",
         \\export fn entry() void {
         \\    var x: i32 = 1234;
         \\    var p: *i32 = &x;
         \\    var pp: *?*i32 = &p;
         \\    pp.* = null;
         \\    var y = p.*;
+        \\    _ = y;
         \\}
     , &[_][]const u8{
         "tmp.zig:4:23: error: expected type '*?*i32', found '**i32'",
     });
-    cases.add("attempted implicit cast from T to [*]const T",
+    ctx.objErrStage1("attempted implicit cast from T to [*]const T",
         \\export fn entry() void {
         \\    const x: [*]const bool = true;
+        \\    _ = x;
         \\}
     , &[_][]const u8{
         "tmp.zig:2:30: error: expected type '[*]const bool', found 'bool'",
     });
-    cases.add("dereference unknown length pointer",
+    ctx.objErrStage1("dereference unknown length pointer",
         \\export fn entry(x: [*]i32) i32 {
         \\    return x.*;
         \\}
 @@ -3844,7 +4025,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         "tmp.zig:2:13: error: index syntax required for unknown-length pointer type '[*]i32'",
     });
-    cases.add("field access of unknown length pointer",
+    ctx.objErrStage1("field access of unknown length pointer",
         \\const Foo = extern struct {
         \\    a: i32,
         \\};
 @@ -3856,13 +4037,13 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         "tmp.zig:6:8: error: type '[*]Foo' does not support field access",
     });
-    cases.add("unknown length pointer to opaque",
+    ctx.objErrStage1("unknown length pointer to opaque",
         \\export const T = [*]opaque {};
     , &[_][]const u8{
         "tmp.zig:1:21: error: unknown-length pointer to opaque",
     });
-    cases.add("error when evaluating return type",
+    ctx.objErrStage1("error when evaluating return type",
         \\const Foo = struct {
         \\    map: @as(i32, i32),
         \\
 @@ -3872,20 +4053,22 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         \\};
         \\export fn entry() void {
         \\    var rule_set = try Foo.init();
+        \\    _ = rule_set;
         \\}
     , &[_][]const u8{
         "tmp.zig:2:19: error: expected type 'i32', found 'type'",
     });
-    cases.add("slicing single-item pointer",
+    ctx.objErrStage1("slicing single-item pointer",
         \\export fn entry(ptr: *i32) void {
         \\    const slice = ptr[0..2];
+        \\    _ = slice;
         \\}
     , &[_][]const u8{
         "tmp.zig:2:22: error: slice of single-item pointer",
     });
-    cases.add("indexing single-item pointer",
+    ctx.objErrStage1("indexing single-item pointer",
         \\export fn entry(ptr: *i32) i32 {
         \\    return ptr[1];
         \\}
 @@ -3893,12 +4076,13 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         "tmp.zig:2:15: error: index of single-item pointer",
     });
-    cases.add("nested error set mismatch",
+    ctx.objErrStage1("nested error set mismatch",
         \\const NextError = error{NextError};
         \\const OtherError = error{OutOfMemory};
         \\
         \\export fn entry() void {
         \\    const a: ?NextError!i32 = foo();
+        \\    _ = a;
         \\}
         \\
         \\fn foo() ?OtherError!i32 {
 @@ -3911,7 +4095,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         "tmp.zig:2:26: note: 'error.OutOfMemory' not a member of destination error set",
     });
-    cases.add("invalid deref on switch target",
+    ctx.objErrStage1("invalid deref on switch target",
         \\comptime {
         \\    var tile = Tile.Empty;
         \\    switch (tile.*) {
 @@ -3927,13 +4111,13 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         "tmp.zig:3:17: error: attempt to dereference non-pointer type 'Tile'",
     });
-    cases.add("invalid field access in comptime",
+    ctx.objErrStage1("invalid field access in comptime",
-        \\comptime { var x = doesnt_exist.whatever; }
+        \\comptime { var x = doesnt_exist.whatever; _ = x; }
     , &[_][]const u8{
         "tmp.zig:1:20: error: use of undeclared identifier 'doesnt_exist'",
     });
-    cases.add("suspend inside suspend block",
+    ctx.objErrStage1("suspend inside suspend block",
         \\export fn entry() void {
         \\    _ = async foo();
         \\}
 @@ -3948,17 +4132,18 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         "tmp.zig:5:5: note: other suspend block here",
     });
-    cases.add("assign inline fn to non-comptime var",
+    ctx.objErrStage1("assign inline fn to non-comptime var",
         \\export fn entry() void {
         \\    var a = b;
+        \\    _ = a;
         \\}
         \\fn b() callconv(.Inline) void { }
     , &[_][]const u8{
         "tmp.zig:2:5: error: functions marked inline must be stored in const or comptime var",
-        "tmp.zig:4:1: note: declared here",
+        "tmp.zig:5:1: note: declared here",
     });
-    cases.add("wrong type passed to @panic",
+    ctx.objErrStage1("wrong type passed to @panic",
         \\export fn entry() void {
         \\    var e = error.Foo;
         \\    @panic(e);
 @@ -3967,7 +4152,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         "tmp.zig:3:12: error: expected type '[]const u8', found 'error{Foo}'",
     });
-    cases.add("@tagName used on union with no associated enum tag",
+    ctx.objErrStage1("@tagName used on union with no associated enum tag",
         \\const FloatInt = extern union {
         \\    Float: f32,
         \\    Int: i32,
 @@ -3975,13 +4160,14 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         \\export fn entry() void {
         \\    var fi = FloatInt{.Float = 123.45};
         \\    var tagName = @tagName(fi);
+        \\    _ = tagName;
         \\}
     , &[_][]const u8{
         "tmp.zig:7:19: error: union has no associated enum",
         "tmp.zig:1:18: note: declared here",
     });
-    cases.add("returning error from void async function",
+    ctx.objErrStage1("returning error from void async function",
         \\export fn entry() void {
         \\    _ = async amain();
         \\}
 @@ -3992,37 +4178,40 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         "tmp.zig:5:17: error: expected type 'void', found 'error{ShouldBeCompileError}'",
     });
-    cases.add("var makes structs required to be comptime known",
+    ctx.objErrStage1("var makes structs required to be comptime known",
         \\export fn entry() void {
         \\   const S = struct{v: anytype};
         \\   var s = S{.v=@as(i32, 10)};
+        \\   _ = s;
         \\}
     , &[_][]const u8{
         "tmp.zig:3:4: error: variable of type 'S' must be const or comptime",
     });
-    cases.add("@ptrCast discards const qualifier",
+    ctx.objErrStage1("@ptrCast discards const qualifier",
         \\export fn entry() void {
         \\    const x: i32 = 1234;
         \\    const y = @ptrCast(*i32, &x);
+        \\    _ = y;
         \\}
     , &[_][]const u8{
         "tmp.zig:3:15: error: cast discards const qualifier",
     });
-    cases.add("comptime slice of undefined pointer non-zero len",
+    ctx.objErrStage1("comptime slice of undefined pointer non-zero len",
         \\export fn entry() void {
         \\    const slice = @as([*]i32, undefined)[0..1];
+        \\    _ = slice;
         \\}
     , &[_][]const u8{
         "tmp.zig:2:41: error: non-zero length slice of undefined pointer",
     });
-    cases.add("type checking function pointers",
+    ctx.objErrStage1("type checking function pointers",
         \\fn a(b: fn (*const u8) void) void {
         \\    b('a');
         \\}
-        \\fn c(d: u8) void {}
+        \\fn c(d: u8) void {_ = d;}
         \\export fn entry() void {
         \\    a(c);
         \\}
 @@ -4030,7 +4219,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         "tmp.zig:6:7: error: expected type 'fn(*const u8) void', found 'fn(u8) void'",
     });
-    cases.add("no else prong on switch on global error set",
+    ctx.objErrStage1("no else prong on switch on global error set",
         \\export fn entry() void {
         \\    foo(error.A);
         \\}
 @@ -4043,7 +4232,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         "tmp.zig:5:5: error: else prong required when switching on type 'anyerror'",
     });
-    cases.add("error not handled in switch",
+    ctx.objErrStage1("error not handled in switch",
         \\export fn entry() void {
         \\    foo(452) catch |err| switch (err) {
         \\        error.Foo => {},
 @@ -4062,7 +4251,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         "tmp.zig:2:26: error: error.Bar not handled in switch",
     });
-    cases.add("duplicate error in switch",
+    ctx.objErrStage1("duplicate error in switch",
         \\export fn entry() void {
         \\    foo(452) catch |err| switch (err) {
         \\        error.Foo => {},
 @@ -4080,10 +4269,10 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         \\}
     , &[_][]const u8{
         "tmp.zig:5:14: error: duplicate switch value: '@typeInfo(@typeInfo(@TypeOf(foo)).Fn.return_type.?).ErrorUnion.error_set.Foo'",
-        "tmp.zig:3:14: note: other value is here",
+        "tmp.zig:3:14: note: other value here",
     });
-    cases.add("invalid cast from integral type to enum",
+    ctx.objErrStage1("invalid cast from integral type to enum",
         \\const E = enum(usize) { One, Two };
         \\
         \\export fn entry() void {
 @@ -4099,7 +4288,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         "tmp.zig:9:10: error: expected type 'usize', found 'E'",
     });
-    cases.add("range operator in switch used on error set",
+    ctx.objErrStage1("range operator in switch used on error set",
         \\export fn entry() void {
         \\    try foo(452) catch |err| switch (err) {
         \\        error.A ... error.B => {},
 @@ -4117,33 +4306,35 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         "tmp.zig:3:17: error: operator not allowed for errors",
     });
-    cases.add("inferring error set of function pointer",
+    ctx.objErrStage1("inferring error set of function pointer",
         \\comptime {
         \\    const z: ?fn()!void = null;
         \\}
     , &[_][]const u8{
-        "tmp.zig:2:15: error: inferring error set of return type valid only for function definitions",
+        "tmp.zig:2:19: error: function prototype may not have inferred error set",
     });
-    cases.add("access non-existent member of error set",
+    ctx.objErrStage1("access non-existent member of error set",
         \\const Foo = error{A};
         \\comptime {
         \\    const z = Foo.Bar;
+        \\    _ = z;
         \\}
     , &[_][]const u8{
         "tmp.zig:3:18: error: no error named 'Bar' in 'Foo'",
     });
-    cases.add("error union operator with non error set LHS",
+    ctx.objErrStage1("error union operator with non error set LHS",
         \\comptime {
         \\    const z = i32!i32;
         \\    var x: z = undefined;
+        \\    _ = x;
         \\}
     , &[_][]const u8{
         "tmp.zig:2:15: error: expected error set type, found type 'i32'",
     });
-    cases.add("error equality but sets have no common members",
+    ctx.objErrStage1("error equality but sets have no common members",
         \\const Set1 = error{A, C};
         \\const Set2 = error{B, D};
         \\export fn entry() void {
 @@ -4158,29 +4349,32 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         "tmp.zig:7:11: error: error sets 'Set1' and 'Set2' have no common errors",
     });
-    cases.add("only equality binary operator allowed for error sets",
+    ctx.objErrStage1("only equality binary operator allowed for error sets",
         \\comptime {
         \\    const z = error.A > error.B;
+        \\    _ = z;
         \\}
     , &[_][]const u8{
         "tmp.zig:2:23: error: operator not allowed for errors",
     });
-    cases.add("explicit error set cast known at comptime violates error sets",
+    ctx.objErrStage1("explicit error set cast known at comptime violates error sets",
         \\const Set1 = error {A, B};
         \\const Set2 = error {A, C};
         \\comptime {
         \\    var x = Set1.B;
         \\    var y = @errSetCast(Set2, x);
+        \\    _ = y;
         \\}
     , &[_][]const u8{
         "tmp.zig:5:13: error: error.B not a member of error set 'Set2'",
     });
-    cases.add("cast error union of global error set to error union of smaller error set",
+    ctx.objErrStage1("cast error union of global error set to error union of smaller error set",
         \\const SmallErrorSet = error{A};
         \\export fn entry() void {
         \\    var x: SmallErrorSet!i32 = foo();
+        \\    _ = x;
         \\}
         \\fn foo() anyerror!i32 {
         \\    return error.B;
 @@ -4191,10 +4385,11 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         "tmp.zig:3:35: note: cannot cast global error set into smaller set",
     });
-    cases.add("cast global error set to error set",
+    ctx.objErrStage1("cast global error set to error set",
         \\const SmallErrorSet = error{A};
         \\export fn entry() void {
         \\    var x: SmallErrorSet = foo();
+        \\    _ = x;
         \\}
         \\fn foo() anyerror {
         \\    return error.B;
 @@ -4203,7 +4398,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         "tmp.zig:3:31: error: expected type 'SmallErrorSet', found 'anyerror'",
         "tmp.zig:3:31: note: cannot cast global error set into smaller set",
     });
-    cases.add("recursive inferred error set",
+    ctx.objErrStage1("recursive inferred error set",
         \\export fn entry() void {
         \\    foo() catch unreachable;
         \\}
 @@ -4214,7 +4409,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         "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",
     });
-    cases.add("implicit cast of error set not a subset",
+    ctx.objErrStage1("implicit cast of error set not a subset",
         \\const Set1 = error{A, B};
         \\const Set2 = error{A, C};
         \\export fn entry() void {
 @@ -4222,13 +4417,14 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         \\}
         \\fn foo(set1: Set1) void {
         \\    var x: Set2 = set1;
+        \\    _ = x;
         \\}
     , &[_][]const u8{
         "tmp.zig:7:19: error: expected type 'Set2', found 'Set1'",
         "tmp.zig:1:23: note: 'error.B' not a member of destination error set",
     });
-    cases.add("int to err global invalid number",
+    ctx.objErrStage1("int to err global invalid number",
         \\const Set1 = error{
         \\    A,
         \\    B,
 @@ -4236,12 +4432,13 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         \\comptime {
         \\    var x: u16 = 3;
         \\    var y = @intToError(x);
+        \\    _ = y;
         \\}
     , &[_][]const u8{
         "tmp.zig:7:13: error: integer value 3 represents no error",
     });
-    cases.add("int to err non global invalid number",
+    ctx.objErrStage1("int to err non global invalid number",
         \\const Set1 = error{
         \\    A,
         \\    B,
 @@ -4253,68 +4450,74 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         \\comptime {
         \\    var x = @errorToInt(Set1.B);
         \\    var y = @errSetCast(Set2, @intToError(x));
+        \\    _ = y;
         \\}
     , &[_][]const u8{
         "tmp.zig:11:13: error: error.B not a member of error set 'Set2'",
     });
-    cases.add("duplicate error value in error set",
+    ctx.objErrStage1("duplicate error value in error set",
         \\const Foo = error {
         \\    Bar,
         \\    Bar,
         \\};
         \\export fn entry() void {
         \\    const a: Foo = undefined;
+        \\    _ = a;
         \\}
     , &[_][]const u8{
         "tmp.zig:3:5: error: duplicate error: 'Bar'",
         "tmp.zig:2:5: note: other error here",
     });
-    cases.add("cast negative integer literal to usize",
+    ctx.objErrStage1("cast negative integer literal to usize",
         \\export fn entry() void {
         \\    const x = @as(usize, -10);
+        \\    _ = x;
         \\}
     , &[_][]const u8{
         "tmp.zig:2:26: error: cannot cast negative value -10 to unsigned integer type 'usize'",
     });
-    cases.add("use invalid number literal as array index",
+    ctx.objErrStage1("use invalid number literal as array index",
         \\var v = 25;
         \\export fn entry() void {
         \\    var arr: [v]u8 = undefined;
+        \\    _ = arr;
         \\}
     , &[_][]const u8{
         "tmp.zig:1:1: error: unable to infer variable type",
     });
-    cases.add("duplicate struct field",
+    ctx.objErrStage1("duplicate struct field",
         \\const Foo = struct {
         \\    Bar: i32,
         \\    Bar: usize,
         \\};
         \\export fn entry() void {
         \\    const a: Foo = undefined;
+        \\    _ = a;
         \\}
     , &[_][]const u8{
         "tmp.zig:3:5: error: duplicate struct field: 'Bar'",
         "tmp.zig:2:5: note: other field here",
     });
-    cases.add("duplicate union field",
+    ctx.objErrStage1("duplicate union field",
         \\const Foo = union {
         \\    Bar: i32,
         \\    Bar: usize,
         \\};
         \\export fn entry() void {
         \\    const a: Foo = undefined;
+        \\    _ = a;
         \\}
     , &[_][]const u8{
         "tmp.zig:3:5: error: duplicate union field: 'Bar'",
         "tmp.zig:2:5: note: other field here",
     });
-    cases.add("duplicate enum field",
+    ctx.objErrStage1("duplicate enum field",
         \\const Foo = enum {
         \\    Bar,
         \\    Bar,
 @@ -4322,13 +4525,14 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         \\
         \\export fn entry() void {
         \\    const a: Foo = undefined;
+        \\    _ = a;
         \\}
     , &[_][]const u8{
         "tmp.zig:3:5: error: duplicate enum field: 'Bar'",
         "tmp.zig:2:5: note: other field here",
     });
-    cases.add("calling function with naked calling convention",
+    ctx.objErrStage1("calling function with naked calling convention",
         \\export fn entry() void {
         \\    foo();
         \\}
 @@ -4338,42 +4542,42 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         "tmp.zig:4:1: note: declared here",
     });
-    cases.add("function with invalid return type",
+    ctx.objErrStage1("function with invalid return type",
         \\export fn foo() boid {}
     , &[_][]const u8{
         "tmp.zig:1:17: error: use of undeclared identifier 'boid'",
     });
-    cases.add("function with non-extern non-packed enum parameter",
+    ctx.objErrStage1("function with non-extern non-packed enum parameter",
         \\const Foo = enum { A, B, C };
-        \\export fn entry(foo: Foo) void { }
+        \\export fn entry(foo: Foo) void { _ = foo; }
     , &[_][]const u8{
         "tmp.zig:2:22: error: parameter of type 'Foo' not allowed in function with calling convention 'C'",
     });
-    cases.add("function with non-extern non-packed struct parameter",
+    ctx.objErrStage1("function with non-extern non-packed struct parameter",
         \\const Foo = struct {
         \\    A: i32,
         \\    B: f32,
         \\    C: bool,
         \\};
-        \\export fn entry(foo: Foo) void { }
+        \\export fn entry(foo: Foo) void { _ = foo; }
     , &[_][]const u8{
         "tmp.zig:6:22: error: parameter of type 'Foo' not allowed in function with calling convention 'C'",
     });
-    cases.add("function with non-extern non-packed union parameter",
+    ctx.objErrStage1("function with non-extern non-packed union parameter",
         \\const Foo = union {
         \\    A: i32,
         \\    B: f32,
         \\    C: bool,
         \\};
-        \\export fn entry(foo: Foo) void { }
+        \\export fn entry(foo: Foo) void { _ = foo; }
     , &[_][]const u8{
         "tmp.zig:6:22: error: parameter of type 'Foo' not allowed in function with calling convention 'C'",
     });
-    cases.add("switch on enum with 1 field with no prongs",
+    ctx.objErrStage1("switch on enum with 1 field with no prongs",
         \\const Foo = enum { M };
         \\
         \\export fn entry() void {
 @@ -4384,15 +4588,16 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         "tmp.zig:5:5: error: enumeration value 'Foo.M' not handled in switch",
     });
-    cases.add("shift by negative comptime integer",
+    ctx.objErrStage1("shift by negative comptime integer",
         \\comptime {
         \\    var a = 1 >> -1;
+        \\    _ = a;
         \\}
     , &[_][]const u8{
         "tmp.zig:2:18: error: shift by negative value -1",
     });
-    cases.add("@panic called at compile time",
+    ctx.objErrStage1("@panic called at compile time",
         \\export fn entry() void {
         \\    comptime {
         \\        @panic("aoeu",);
 @@ -4402,20 +4607,20 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         "tmp.zig:3:9: error: encountered @panic at compile-time",
     });
-    cases.add("wrong return type for main",
+    ctx.objErrStage1("wrong return type for main",
         \\pub fn main() f32 { }
     , &[_][]const u8{
         "error: expected return type of main to be 'void', '!void', 'noreturn', 'u8', or '!u8'",
     });
-    cases.add("double ?? on main return value",
+    ctx.objErrStage1("double ?? on main return value",
         \\pub fn main() ??void {
         \\}
     , &[_][]const u8{
         "error: expected return type of main to be 'void', '!void', 'noreturn', 'u8', or '!u8'",
     });
-    cases.add("bad identifier in function with struct defined inside function which references local const",
+    ctx.objErrStage1("bad identifier in function with struct defined inside function which references local const",
         \\export fn entry() void {
         \\    const BlockKind = u32;
         \\
 @@ -4424,12 +4629,14 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         \\    };
         \\
         \\    bogus;
+        \\
+        \\    _ = Block;
         \\}
     , &[_][]const u8{
         "tmp.zig:8:5: error: use of undeclared identifier 'bogus'",
     });
-    cases.add("labeled break not found",
+    ctx.objErrStage1("labeled break not found",
         \\export fn entry() void {
         \\    blah: while (true) {
         \\        while (true) {
 @@ -4438,10 +4645,10 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         \\    }
         \\}
     , &[_][]const u8{
-        "tmp.zig:4:13: error: label not found: 'outer'",
+        "tmp.zig:4:20: error: label not found: 'outer'",
     });
-    cases.add("labeled continue not found",
+    ctx.objErrStage1("labeled continue not found",
         \\export fn entry() void {
         \\    var i: usize = 0;
         \\    blah: while (i < 10) : (i += 1) {
 @@ -4451,17 +4658,17 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         \\    }
         \\}
     , &[_][]const u8{
-        "tmp.zig:5:13: error: labeled loop not found: 'outer'",
+        "tmp.zig:5:23: error: label not found: 'outer'",
     });
-    cases.add("attempt to use 0 bit type in extern fn",
+    ctx.objErrStage1("attempt to use 0 bit type in extern fn",
         \\extern fn foo(ptr: fn(*void) callconv(.C) void) void;
         \\
         \\export fn entry() void {
         \\    foo(bar);
         \\}
         \\
-        \\fn bar(x: *void) callconv(.C) void { }
+        \\fn bar(x: *void) callconv(.C) void { _ = x; }
         \\export fn entry2() void {
         \\    bar(&{});
         \\}
 @@ -4470,7 +4677,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         "tmp.zig:7:11: error: parameter of type '*void' has 0 bits; not allowed in function with calling convention 'C'",
     });
-    cases.add("implicit semicolon - block statement",
+    ctx.objErrStage1("implicit semicolon - block statement",
         \\export fn entry() void {
         \\    {}
         \\    var good = {};
 @@ -4478,10 +4685,10 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         \\    var bad = {};
         \\}
     , &[_][]const u8{
-        "tmp.zig:5:5: error: expected token ';', found 'var'",
+        "tmp.zig:5:5: error: expected ';', found 'var'",
     });
-    cases.add("implicit semicolon - block expr",
+    ctx.objErrStage1("implicit semicolon - block expr",
         \\export fn entry() void {
         \\    _ = {};
         \\    var good = {};
 @@ -4489,10 +4696,10 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         \\    var bad = {};
         \\}
     , &[_][]const u8{
-        "tmp.zig:5:5: error: expected token ';', found 'var'",
+        "tmp.zig:5:5: error: expected ';', found 'var'",
     });
-    cases.add("implicit semicolon - comptime statement",
+    ctx.objErrStage1("implicit semicolon - comptime statement",
         \\export fn entry() void {
         \\    comptime {}
         \\    var good = {};
 @@ -4500,10 +4707,10 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         \\    var bad = {};
         \\}
     , &[_][]const u8{
-        "tmp.zig:5:5: error: expected token ';', found 'var'",
+        "tmp.zig:5:5: error: expected ';', found 'var'",
     });
-    cases.add("implicit semicolon - comptime expression",
+    ctx.objErrStage1("implicit semicolon - comptime expression",
         \\export fn entry() void {
         \\    _ = comptime {};
         \\    var good = {};
 @@ -4511,10 +4718,10 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         \\    var bad = {};
         \\}
     , &[_][]const u8{
-        "tmp.zig:5:5: error: expected token ';', found 'var'",
+        "tmp.zig:5:5: error: expected ';', found 'var'",
     });
-    cases.add("implicit semicolon - defer",
+    ctx.objErrStage1("implicit semicolon - defer",
         \\export fn entry() void {
         \\    defer {}
         \\    var good = {};
 @@ -4522,10 +4729,10 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         \\    var bad = {};
         \\}
     , &[_][]const u8{
-        "tmp.zig:5:5: error: expected token ';', found 'var'",
+        "tmp.zig:5:5: error: expected ';', found 'var'",
     });
-    cases.add("implicit semicolon - if statement",
+    ctx.objErrStage1("implicit semicolon - if statement",
         \\export fn entry() void {
         \\    if(true) {}
         \\    var good = {};
 @@ -4533,10 +4740,10 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         \\    var bad = {};
         \\}
     , &[_][]const u8{
-        "tmp.zig:5:5: error: expected token ';', found 'var'",
+        "tmp.zig:5:5: error: expected ';' or 'else', found 'var'",
     });
-    cases.add("implicit semicolon - if expression",
+    ctx.objErrStage1("implicit semicolon - if expression",
         \\export fn entry() void {
         \\    _ = if(true) {};
         \\    var good = {};
 @@ -4544,10 +4751,10 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         \\    var bad = {};
         \\}
     , &[_][]const u8{
-        "tmp.zig:5:5: error: expected token ';', found 'var'",
+        "tmp.zig:5:5: error: expected ';', found 'var'",
     });
-    cases.add("implicit semicolon - if-else statement",
+    ctx.objErrStage1("implicit semicolon - if-else statement",
         \\export fn entry() void {
         \\    if(true) {} else {}
         \\    var good = {};
 @@ -4555,10 +4762,10 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         \\    var bad = {};
         \\}
     , &[_][]const u8{
-        "tmp.zig:5:5: error: expected token ';', found 'var'",
+        "tmp.zig:5:5: error: expected ';', found 'var'",
     });
-    cases.add("implicit semicolon - if-else expression",
+    ctx.objErrStage1("implicit semicolon - if-else expression",
         \\export fn entry() void {
         \\    _ = if(true) {} else {};
         \\    var good = {};
 @@ -4566,10 +4773,10 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         \\    var bad = {};
         \\}
     , &[_][]const u8{
-        "tmp.zig:5:5: error: expected token ';', found 'var'",
+        "tmp.zig:5:5: error: expected ';', found 'var'",
     });
-    cases.add("implicit semicolon - if-else-if statement",
+    ctx.objErrStage1("implicit semicolon - if-else-if statement",
         \\export fn entry() void {
         \\    if(true) {} else if(true) {}
         \\    var good = {};
 @@ -4577,10 +4784,10 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         \\    var bad = {};
         \\}
     , &[_][]const u8{
-        "tmp.zig:5:5: error: expected token ';', found 'var'",
+        "tmp.zig:5:5: error: expected ';' or 'else', found 'var'",
     });
-    cases.add("implicit semicolon - if-else-if expression",
+    ctx.objErrStage1("implicit semicolon - if-else-if expression",
         \\export fn entry() void {
         \\    _ = if(true) {} else if(true) {};
         \\    var good = {};
 @@ -4588,10 +4795,10 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         \\    var bad = {};
         \\}
     , &[_][]const u8{
-        "tmp.zig:5:5: error: expected token ';', found 'var'",
+        "tmp.zig:5:5: error: expected ';', found 'var'",
     });
-    cases.add("implicit semicolon - if-else-if-else statement",
+    ctx.objErrStage1("implicit semicolon - if-else-if-else statement",
         \\export fn entry() void {
         \\    if(true) {} else if(true) {} else {}
         \\    var good = {};
 @@ -4599,10 +4806,10 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         \\    var bad = {};
         \\}
     , &[_][]const u8{
-        "tmp.zig:5:5: error: expected token ';', found 'var'",
+        "tmp.zig:5:5: error: expected ';', found 'var'",
     });
-    cases.add("implicit semicolon - if-else-if-else expression",
+    ctx.objErrStage1("implicit semicolon - if-else-if-else expression",
         \\export fn entry() void {
         \\    _ = if(true) {} else if(true) {} else {};
         \\    var good = {};
 @@ -4610,10 +4817,10 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         \\    var bad = {};
         \\}
     , &[_][]const u8{
-        "tmp.zig:5:5: error: expected token ';', found 'var'",
+        "tmp.zig:5:5: error: expected ';', found 'var'",
     });
-    cases.add("implicit semicolon - test statement",
+    ctx.objErrStage1("implicit semicolon - test statement",
         \\export fn entry() void {
         \\    if (foo()) |_| {}
         \\    var good = {};
 @@ -4621,10 +4828,10 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         \\    var bad = {};
         \\}
     , &[_][]const u8{
-        "tmp.zig:5:5: error: expected token ';', found 'var'",
+        "tmp.zig:5:5: error: expected ';' or 'else', found 'var'",
     });
-    cases.add("implicit semicolon - test expression",
+    ctx.objErrStage1("implicit semicolon - test expression",
         \\export fn entry() void {
         \\    _ = if (foo()) |_| {};
         \\    var good = {};
 @@ -4632,10 +4839,10 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         \\    var bad = {};
         \\}
     , &[_][]const u8{
-        "tmp.zig:5:5: error: expected token ';', found 'var'",
+        "tmp.zig:5:5: error: expected ';', found 'var'",
     });
-    cases.add("implicit semicolon - while statement",
+    ctx.objErrStage1("implicit semicolon - while statement",
         \\export fn entry() void {
         \\    while(true) {}
         \\    var good = {};
 @@ -4643,10 +4850,10 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         \\    var bad = {};
         \\}
     , &[_][]const u8{
-        "tmp.zig:5:5: error: expected token ';', found 'var'",
+        "tmp.zig:5:5: error: expected ';' or 'else', found 'var'",
     });
-    cases.add("implicit semicolon - while expression",
+    ctx.objErrStage1("implicit semicolon - while expression",
         \\export fn entry() void {
         \\    _ = while(true) {};
         \\    var good = {};
 @@ -4654,10 +4861,10 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         \\    var bad = {};
         \\}
     , &[_][]const u8{
-        "tmp.zig:5:5: error: expected token ';', found 'var'",
+        "tmp.zig:5:5: error: expected ';', found 'var'",
     });
-    cases.add("implicit semicolon - while-continue statement",
+    ctx.objErrStage1("implicit semicolon - while-continue statement",
         \\export fn entry() void {
         \\    while(true):({}) {}
         \\    var good = {};
 @@ -4665,10 +4872,10 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         \\    var bad = {};
         \\}
     , &[_][]const u8{
-        "tmp.zig:5:5: error: expected token ';', found 'var'",
+        "tmp.zig:5:5: error: expected ';' or 'else', found 'var'",
     });
-    cases.add("implicit semicolon - while-continue expression",
+    ctx.objErrStage1("implicit semicolon - while-continue expression",
         \\export fn entry() void {
         \\    _ = while(true):({}) {};
         \\    var good = {};
 @@ -4676,10 +4883,10 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         \\    var bad = {};
         \\}
     , &[_][]const u8{
-        "tmp.zig:5:5: error: expected token ';', found 'var'",
+        "tmp.zig:5:5: error: expected ';', found 'var'",
     });
-    cases.add("implicit semicolon - for statement",
+    ctx.objErrStage1("implicit semicolon - for statement",
         \\export fn entry() void {
         \\    for(foo()) |_| {}
         \\    var good = {};
 @@ -4687,10 +4894,10 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         \\    var bad = {};
         \\}
     , &[_][]const u8{
-        "tmp.zig:5:5: error: expected token ';', found 'var'",
+        "tmp.zig:5:5: error: expected ';' or 'else', found 'var'",
     });
-    cases.add("implicit semicolon - for expression",
+    ctx.objErrStage1("implicit semicolon - for expression",
         \\export fn entry() void {
         \\    _ = for(foo()) |_| {};
         \\    var good = {};
 @@ -4698,32 +4905,33 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         \\    var bad = {};
         \\}
     , &[_][]const u8{
-        "tmp.zig:5:5: error: expected token ';', found 'var'",
+        "tmp.zig:5:5: error: expected ';', found 'var'",
     });
-    cases.add("multiple function definitions",
+    ctx.objErrStage1("multiple function definitions",
         \\fn a() void {}
         \\fn a() void {}
         \\export fn entry() void { a(); }
     , &[_][]const u8{
-        "tmp.zig:2:1: error: redefinition of 'a'",
+        "tmp.zig:2:1: error: redeclaration of 'a'",
+        "tmp.zig:1:1: note: other declaration here",
     });
-    cases.add("unreachable with return",
+    ctx.objErrStage1("unreachable with return",
         \\fn a() noreturn {return;}
         \\export fn entry() void { a(); }
     , &[_][]const u8{
         "tmp.zig:1:18: error: expected type 'noreturn', found 'void'",
     });
-    cases.add("control reaches end of non-void function",
+    ctx.objErrStage1("control reaches end of non-void function",
         \\fn a() i32 {}
         \\export fn entry() void { _ = a(); }
     , &[_][]const u8{
         "tmp.zig:1:12: error: expected type 'i32', found 'void'",
     });
-    cases.add("undefined function call",
+    ctx.objErrStage1("undefined function call",
         \\export fn a() void {
         \\    b();
         \\}
 @@ -4731,30 +4939,30 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         "tmp.zig:2:5: error: use of undeclared identifier 'b'",
     });
-    cases.add("wrong number of arguments",
+    ctx.objErrStage1("wrong number of arguments",
         \\export fn a() void {
-        \\    b(1);
+        \\    c(1);
         \\}
-        \\fn b(a: i32, b: i32, c: i32) void { }
+        \\fn c(d: i32, e: i32, f: i32) void { _ = d; _ = e; _ = f; }
     , &[_][]const u8{
         "tmp.zig:2:6: error: expected 3 argument(s), found 1",
     });
-    cases.add("invalid type",
+    ctx.objErrStage1("invalid type",
         \\fn a() bogus {}
         \\export fn entry() void { _ = a(); }
     , &[_][]const u8{
         "tmp.zig:1:8: error: use of undeclared identifier 'bogus'",
     });
-    cases.add("pointer to noreturn",
+    ctx.objErrStage1("pointer to noreturn",
         \\fn a() *noreturn {}
         \\export fn entry() void { _ = a(); }
     , &[_][]const u8{
         "tmp.zig:1:9: error: pointer to noreturn not allowed",
     });
-    cases.add("unreachable code",
+    ctx.objErrStage1("unreachable code",
         \\export fn a() void {
         \\    return;
         \\    b();
 @@ -4762,17 +4970,17 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         \\
         \\fn b() void {}
     , &[_][]const u8{
-        "tmp.zig:3:5: error: unreachable code",
+        "tmp.zig:3:6: error: unreachable code",
+        "tmp.zig:2:5: note: control flow is diverted here",
     });
-    cases.add("bad import",
+    ctx.objErrStage1("bad import",
         \\const bogus = @import("bogus-does-not-exist.zig",);
-        \\export fn entry() void { bogus.bogo(); }
     , &[_][]const u8{
-        "tmp.zig:1:15: error: unable to find 'bogus-does-not-exist.zig'",
+        "tmp.zig:1:23: error: unable to load '${DIR}bogus-does-not-exist.zig': FileNotFound",
     });
-    cases.add("undeclared identifier",
+    ctx.objErrStage1("undeclared identifier",
         \\export fn a() void {
         \\    return
         \\    b +
 @@ -4782,33 +4990,36 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         "tmp.zig:3:5: error: use of undeclared identifier 'b'",
     });
-    cases.add("parameter redeclaration",
+    ctx.objErrStage1("parameter redeclaration",
         \\fn f(a : i32, a : i32) void {
         \\}
         \\export fn entry() void { f(1, 2); }
     , &[_][]const u8{
-        "tmp.zig:1:15: error: redeclaration of variable 'a'",
+        "tmp.zig:1:15: error: redeclaration of function parameter 'a'",
+        "tmp.zig:1:6: note: previous declaration here",
     });
-    cases.add("local variable redeclaration",
+    ctx.objErrStage1("local variable redeclaration",
         \\export fn f() void {
         \\    const a : i32 = 0;
-        \\    const a = 0;
+        \\    var a = 0;
         \\}
     , &[_][]const u8{
-        "tmp.zig:3:5: error: redeclaration of variable 'a'",
+        "tmp.zig:3:9: error: redeclaration of local constant 'a'",
+        "tmp.zig:2:11: note: previous declaration here",
     });
-    cases.add("local variable redeclares parameter",
+    ctx.objErrStage1("local variable redeclares parameter",
         \\fn f(a : i32) void {
         \\    const a = 0;
         \\}
         \\export fn entry() void { f(1); }
     , &[_][]const u8{
-        "tmp.zig:2:5: error: redeclaration of variable 'a'",
+        "tmp.zig:2:11: error: redeclaration of function parameter 'a'",
+        "tmp.zig:1:6: note: previous declaration here",
     });
-    cases.add("variable has wrong type",
+    ctx.objErrStage1("variable has wrong type",
         \\export fn f() i32 {
         \\    const a = "a";
         \\    return a;
 @@ -4817,7 +5028,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         "tmp.zig:3:12: error: expected type 'i32', found '*const [1:0]u8'",
     });
-    cases.add("if condition is bool, not int",
+    ctx.objErrStage1("if condition is bool, not int",
         \\export fn f() void {
         \\    if (0) {}
         \\}
 @@ -4825,30 +5036,32 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         "tmp.zig:2:9: error: expected type 'bool', found 'comptime_int'",
     });
-    cases.add("assign unreachable",
+    ctx.objErrStage1("assign unreachable",
         \\export fn f() void {
         \\    const a = return;
         \\}
     , &[_][]const u8{
         "tmp.zig:2:5: error: unreachable code",
+        "tmp.zig:2:15: note: control flow is diverted here",
     });
-    cases.add("unreachable variable",
+    ctx.objErrStage1("unreachable variable",
         \\export fn f() void {
         \\    const a: noreturn = {};
+        \\    _ = a;
         \\}
     , &[_][]const u8{
         "tmp.zig:2:25: error: expected type 'noreturn', found 'void'",
     });
-    cases.add("unreachable parameter",
+    ctx.objErrStage1("unreachable parameter",
-        \\fn f(a: noreturn) void {}
+        \\fn f(a: noreturn) void { _ = a; }
         \\export fn entry() void { f(); }
     , &[_][]const u8{
         "tmp.zig:1:9: error: parameter of type 'noreturn' not allowed",
     });
-    cases.add("assign to constant variable",
+    ctx.objErrStage1("assign to constant variable",
         \\export fn f() void {
         \\    const a = 3;
         \\    a = 4;
 @@ -4857,7 +5070,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         "tmp.zig:3:9: error: cannot assign to constant",
     });
-    cases.add("use of undeclared identifier",
+    ctx.objErrStage1("use of undeclared identifier",
         \\export fn f() void {
         \\    b = 3;
         \\}
 @@ -4865,15 +5078,15 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         "tmp.zig:2:5: error: use of undeclared identifier 'b'",
     });
-    cases.add("const is a statement, not an expression",
+    ctx.objErrStage1("const is a statement, not an expression",
         \\export fn f() void {
         \\    (const a = 0);
         \\}
     , &[_][]const u8{
-        "tmp.zig:2:6: error: invalid token: 'const'",
+        "tmp.zig:2:6: error: expected expression, found 'const'",
     });
-    cases.add("array access of undeclared identifier",
+    ctx.objErrStage1("array access of undeclared identifier",
         \\export fn f() void {
         \\    i[i] = i[i];
         \\}
 @@ -4881,7 +5094,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         "tmp.zig:2:5: error: use of undeclared identifier 'i'",
     });
-    cases.add("array access of non array",
+    ctx.objErrStage1("array access of non array",
         \\export fn f() void {
         \\    var bad : bool = undefined;
         \\    bad[0] = bad[0];
 @@ -4895,7 +5108,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         "tmp.zig:7:12: error: array access of non-array type 'bool'",
     });
-    cases.add("array access with non integer index",
+    ctx.objErrStage1("array access with non integer index",
         \\export fn f() void {
         \\    var array = "aoeu";
         \\    var bad = false;
 @@ -4911,7 +5124,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         "tmp.zig:9:15: error: expected type 'usize', found 'bool'",
     });
-    cases.add("write to const global variable",
+    ctx.objErrStage1("write to const global variable",
         \\const x : i32 = 99;
         \\fn f() void {
         \\    x = 1;
 @@ -4921,58 +5134,64 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         "tmp.zig:3:9: error: cannot assign to constant",
     });
-    cases.add("missing else clause",
+    ctx.objErrStage1("missing else clause",
         \\fn f(b: bool) void {
         \\    const x : i32 = if (b) h: { break :h 1; };
+        \\    _ = x;
         \\}
         \\fn g(b: bool) void {
         \\    const y = if (b) h: { break :h @as(i32, 1); };
+        \\    _ = y;
         \\}
         \\export fn entry() void { f(true); g(true); }
     , &[_][]const u8{
         "tmp.zig:2:21: error: expected type 'i32', found 'void'",
-        "tmp.zig:5:15: error: incompatible types: 'i32' and 'void'",
+        "tmp.zig:6:15: error: incompatible types: 'i32' and 'void'",
     });
-    cases.add("invalid struct field",
+    ctx.objErrStage1("invalid struct field",
         \\const A = struct { x : i32, };
         \\export fn f() void {
         \\    var a : A = undefined;
         \\    a.foo = 1;
         \\    const y = a.bar;
+        \\    _ = y;
         \\}
         \\export fn g() void {
         \\    var a : A = undefined;
         \\    const y = a.bar;
+        \\    _ = y;
         \\}
     , &[_][]const u8{
         "tmp.zig:4:6: error: no member named 'foo' in struct 'A'",
-        "tmp.zig:9:16: error: no member named 'bar' in struct 'A'",
+        "tmp.zig:10:16: error: no member named 'bar' in struct 'A'",
     });
-    cases.add("redefinition of struct",
+    ctx.objErrStage1("redefinition of struct",
         \\const A = struct { x : i32, };
         \\const A = struct { y : i32, };
     , &[_][]const u8{
-        "tmp.zig:2:1: error: redefinition of 'A'",
+        "tmp.zig:2:1: error: redeclaration of 'A'",
+        "tmp.zig:1:1: note: other declaration here",
     });
-    cases.add("redefinition of enums",
+    ctx.objErrStage1("redefinition of enums",
-        \\const A = enum {};
+        \\const A = enum {x};
-        \\const A = enum {};
+        \\const A = enum {x};
     , &[_][]const u8{
-        "tmp.zig:2:1: error: redefinition of 'A'",
+        "tmp.zig:2:1: error: redeclaration of 'A'",
+        "tmp.zig:1:1: note: other declaration here",
     });
-    cases.add("redefinition of global variables",
+    ctx.objErrStage1("redefinition of global variables",
         \\var a : i32 = 1;
         \\var a : i32 = 2;
     , &[_][]const u8{
-        "tmp.zig:2:1: error: redefinition of 'a'",
+        "tmp.zig:2:1: error: redeclaration of 'a'",
-        "tmp.zig:1:1: note: previous definition is here",
+        "tmp.zig:1:1: note: other declaration here",
     });
-    cases.add("duplicate field in struct value expression",
+    ctx.objErrStage1("duplicate field in struct value expression",
         \\const A = struct {
         \\    x : i32,
         \\    y : i32,
 @@ -4985,12 +5204,13 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         \\        .x = 3,
         \\        .z = 4,
         \\    };
+        \\    _ = a;
         \\}
     , &[_][]const u8{
         "tmp.zig:11:9: error: duplicate field",
     });
-    cases.add("missing field in struct value expression",
+    ctx.objErrStage1("missing field in struct value expression",
         \\const A = struct {
         \\    x : i32,
         \\    y : i32,
 @@ -5003,12 +5223,13 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         \\        .z = 4,
         \\        .y = 2,
         \\    };
+        \\    _ = a;
         \\}
     , &[_][]const u8{
         "tmp.zig:9:17: error: missing field: 'x'",
     });
-    cases.add("invalid field in struct value expression",
+    ctx.objErrStage1("invalid field in struct value expression",
         \\const A = struct {
         \\    x : i32,
         \\    y : i32,
 @@ -5020,12 +5241,13 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         \\        .y = 2,
         \\        .foo = 42,
         \\    };
+        \\    _ = a;
         \\}
     , &[_][]const u8{
         "tmp.zig:10:9: error: no member named 'foo' in struct 'A'",
     });
-    cases.add("invalid break expression",
+    ctx.objErrStage1("invalid break expression",
         \\export fn f() void {
         \\    break;
         \\}
 @@ -5033,7 +5255,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         "tmp.zig:2:5: error: break expression outside loop",
     });
-    cases.add("invalid continue expression",
+    ctx.objErrStage1("invalid continue expression",
         \\export fn f() void {
         \\    continue;
         \\}
 @@ -5041,48 +5263,49 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         "tmp.zig:2:5: error: continue expression outside loop",
     });
-    cases.add("invalid maybe type",
+    ctx.objErrStage1("invalid maybe type",
         \\export fn f() void {
-        \\    if (true) |x| { }
+        \\    if (true) |x| { _ = x; }
         \\}
     , &[_][]const u8{
         "tmp.zig:2:9: error: expected optional type, found 'bool'",
     });
-    cases.add("cast unreachable",
+    ctx.objErrStage1("cast unreachable",
         \\fn f() i32 {
         \\    return @as(i32, return 1);
         \\}
         \\export fn entry() void { _ = f(); }
     , &[_][]const u8{
         "tmp.zig:2:12: error: unreachable code",
+        "tmp.zig:2:21: note: control flow is diverted here",
     });
-    cases.add("invalid builtin fn",
+    ctx.objErrStage1("invalid builtin fn",
         \\fn f() @bogus(foo) {
         \\}
         \\export fn entry() void { _ = f(); }
     , &[_][]const u8{
-        "tmp.zig:1:8: error: invalid builtin function: 'bogus'",
+        "tmp.zig:1:8: error: invalid builtin function: '@bogus'",
     });
-    cases.add("noalias on non pointer param",
+    ctx.objErrStage1("noalias on non pointer param",
-        \\fn f(noalias x: i32) void {}
+        \\fn f(noalias x: i32) void { _ = x; }
         \\export fn entry() void { f(1234); }
     , &[_][]const u8{
         "tmp.zig:1:6: error: noalias on non-pointer parameter",
     });
-    cases.add("struct init syntax for array",
+    ctx.objErrStage1("struct init syntax for array",
         \\const foo = [3]u16{ .x = 1024 };
         \\comptime {
         \\    _ = foo;
         \\}
     , &[_][]const u8{
-        "tmp.zig:1:21: error: type '[3]u16' does not support struct initialization syntax",
+        "tmp.zig:1:13: error: initializing array with struct syntax",
     });
-    cases.add("type variables must be constant",
+    ctx.objErrStage1("type variables must be constant",
         \\var foo = u8;
         \\export fn entry() foo {
         \\    return 1;
 @@ -5091,25 +5314,31 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         "tmp.zig:1:1: error: variable of type 'type' must be constant",
     });
-    cases.add("variables shadowing types",
+    ctx.objErrStage1("parameter shadowing global",
         \\const Foo = struct {};
-        \\const Bar = struct {};
+        \\fn f(Foo: i32) void {}
-        \\
+        \\export fn entry() void {
-        \\fn f(Foo: i32) void {
+        \\    f(1234);
-        \\    var Bar : i32 = undefined;
         \\}
+    , &[_][]const u8{
+        "tmp.zig:2:6: error: local shadows declaration of 'Foo'",
+        "tmp.zig:1:1: note: declared here",
+    });
+    ctx.objErrStage1("local variable shadowing global",
+        \\const Foo = struct {};
+        \\const Bar = struct {};
         \\
         \\export fn entry() void {
-        \\    f(1234);
+        \\    var Bar : i32 = undefined;
+        \\    _ = Bar;
         \\}
     , &[_][]const u8{
-        "tmp.zig:4:6: error: redefinition of 'Foo'",
+        "tmp.zig:5:9: error: local shadows declaration of 'Bar'",
-        "tmp.zig:1:1: note: previous definition is here",
+        "tmp.zig:2:1: note: declared here",
-        "tmp.zig:5:5: error: redefinition of 'Bar'",
-        "tmp.zig:2:1: note: previous definition is here",
     });
-    cases.add("switch expression - missing enumeration prong",
+    ctx.objErrStage1("switch expression - missing enumeration prong",
         \\const Number = enum {
         \\    One,
         \\    Two,
 @@ -5129,7 +5358,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         "tmp.zig:8:5: error: enumeration value 'Number.Four' not handled in switch",
     });
-    cases.add("switch expression - duplicate enumeration prong",
+    ctx.objErrStage1("switch expression - duplicate enumeration prong",
         \\const Number = enum {
         \\    One,
         \\    Two,
 @@ -5149,10 +5378,10 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         \\export fn entry() usize { return @sizeOf(@TypeOf(f)); }
     , &[_][]const u8{
         "tmp.zig:13:15: error: duplicate switch value",
-        "tmp.zig:10:15: note: other value is here",
+        "tmp.zig:10:15: note: other value here",
     });
-    cases.add("switch expression - duplicate enumeration prong when else present",
+    ctx.objErrStage1("switch expression - duplicate enumeration prong when else present",
         \\const Number = enum {
         \\    One,
         \\    Two,
 @@ -5173,10 +5402,10 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         \\export fn entry() usize { return @sizeOf(@TypeOf(f)); }
     , &[_][]const u8{
         "tmp.zig:13:15: error: duplicate switch value",
-        "tmp.zig:10:15: note: other value is here",
+        "tmp.zig:10:15: note: other value here",
     });
-    cases.add("switch expression - multiple else prongs",
+    ctx.objErrStage1("switch expression - multiple else prongs",
         \\fn f(x: u32) void {
         \\    const value: bool = switch (x) {
         \\        1234 => false,
 @@ -5191,7 +5420,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         "tmp.zig:5:9: error: multiple else prongs in switch expression",
     });
-    cases.add("switch expression - non exhaustive integer prongs",
+    ctx.objErrStage1("switch expression - non exhaustive integer prongs",
         \\fn foo(x: u8) void {
         \\    switch (x) {
         \\        0 => {},
 @@ -5202,7 +5431,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         "tmp.zig:2:5: error: switch must handle all possibilities",
     });
-    cases.add("switch expression - duplicate or overlapping integer value",
+    ctx.objErrStage1("switch expression - duplicate or overlapping integer value",
         \\fn foo(x: u8) u8 {
         \\    return switch (x) {
         \\        0 ... 100 => @as(u8, 0),
 @@ -5214,11 +5443,12 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         \\export fn entry() usize { return @sizeOf(@TypeOf(foo)); }
     , &[_][]const u8{
         "tmp.zig:6:9: error: duplicate switch value",
-        "tmp.zig:5:14: note: previous value is here",
+        "tmp.zig:5:14: note: previous value here",
     });
-    cases.add("switch expression - duplicate type",
+    ctx.objErrStage1("switch expression - duplicate type",
         \\fn foo(comptime T: type, x: T) u8 {
+        \\    _ = x;
         \\    return switch (T) {
         \\        u32 => 0,
         \\        u64 => 1,
 @@ -5228,16 +5458,17 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         \\}
         \\export fn entry() usize { return @sizeOf(@TypeOf(foo(u32, 0))); }
     , &[_][]const u8{
-        "tmp.zig:5:9: error: duplicate switch value",
+        "tmp.zig:6:9: error: duplicate switch value",
-        "tmp.zig:3:9: note: previous value is here",
+        "tmp.zig:4:9: note: previous value here",
     });
-    cases.add("switch expression - duplicate type (struct alias)",
+    ctx.objErrStage1("switch expression - duplicate type (struct alias)",
         \\const Test = struct {
         \\    bar: i32,
         \\};
         \\const Test2 = Test;
         \\fn foo(comptime T: type, x: T) u8 {
+        \\    _ = x;
         \\    return switch (T) {
         \\        Test => 0,
         \\        u64 => 1,
 @@ -5247,11 +5478,11 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         \\}
         \\export fn entry() usize { return @sizeOf(@TypeOf(foo(u32, 0))); }
     , &[_][]const u8{
-        "tmp.zig:9:9: error: duplicate switch value",
+        "tmp.zig:10:9: error: duplicate switch value",
-        "tmp.zig:7:9: note: previous value is here",
+        "tmp.zig:8:9: note: previous value here",
     });
-    cases.add("switch expression - switch on pointer type with no else",
+    ctx.objErrStage1("switch expression - switch on pointer type with no else",
         \\fn foo(x: *u8) void {
         \\    switch (x) {
         \\        &y => {},
 @@ -5263,7 +5494,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         "tmp.zig:2:5: error: else prong required when switching on type '*u8'",
     });
-    cases.add("global variable initializer must be constant expression",
+    ctx.objErrStage1("global variable initializer must be constant expression",
         \\extern fn foo() i32;
         \\const x = foo();
         \\export fn entry() i32 { return x; }
 @@ -5271,7 +5502,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         "tmp.zig:2:11: error: unable to evaluate constant expression",
     });
-    cases.add("array concatenation with wrong type",
+    ctx.objErrStage1("array concatenation with wrong type",
         \\const src = "aoeu";
         \\const derp: usize = 1234;
         \\const a = derp ++ "foo";
 @@ -5281,7 +5512,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         "tmp.zig:3:11: error: expected array, found 'usize'",
     });
-    cases.add("non compile time array concatenation",
+    ctx.objErrStage1("non compile time array concatenation",
         \\fn f() []u8 {
         \\    return s ++ "foo";
         \\}
 @@ -5291,7 +5522,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         "tmp.zig:2:12: error: unable to evaluate constant expression",
     });
-    cases.add("@cImport with bogus include",
+    ctx.objErrStage1("@cImport with bogus include",
         \\const c = @cImport(@cInclude("bogus.h"));
         \\export fn entry() usize { return @sizeOf(@TypeOf(c.bogo)); }
     , &[_][]const u8{
 @@ -5299,7 +5530,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         ".h:1:10: note: 'bogus.h' file not found",
     });
-    cases.add("address of number literal",
+    ctx.objErrStage1("address of number literal",
         \\const x = 3;
         \\const y = &x;
         \\fn foo() *const i32 { return y; }
 @@ -5308,14 +5539,14 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         "tmp.zig:3:30: error: expected type '*const i32', found '*const comptime_int'",
     });
-    cases.add("integer overflow error",
+    ctx.objErrStage1("integer overflow error",
         \\const x : u8 = 300;
         \\export fn entry() usize { return @sizeOf(@TypeOf(x)); }
     , &[_][]const u8{
         "tmp.zig:1:16: error: integer value 300 cannot be coerced to type 'u8'",
     });
-    cases.add("invalid shift amount error",
+    ctx.objErrStage1("invalid shift amount error",
         \\const x : u8 = 2;
         \\fn f() u16 {
         \\    return x << 8;
 @@ -5325,7 +5556,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         "tmp.zig:3:17: error: integer value 8 cannot be coerced to type 'u3'",
     });
-    cases.add("missing function call param",
+    ctx.objErrStage1("missing function call param",
         \\const Foo = struct {
         \\    a: i32,
         \\    b: i32,
 @@ -5346,6 +5577,8 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         \\
         \\fn f(foo: *const Foo, index: usize) void {
         \\    const result = members[index]();
+        \\    _ = foo;
+        \\    _ = result;
         \\}
         \\
         \\export fn entry() usize { return @sizeOf(@TypeOf(f)); }
 @@ -5353,21 +5586,21 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         "tmp.zig:20:34: error: expected 1 argument(s), found 0",
     });
-    cases.add("missing function name",
+    ctx.objErrStage1("missing function name",
         \\fn () void {}
         \\export fn entry() usize { return @sizeOf(@TypeOf(f)); }
     , &[_][]const u8{
         "tmp.zig:1:1: error: missing function name",
     });
-    cases.add("missing param name",
+    ctx.objErrStage1("missing param name",
         \\fn f(i32) void {}
         \\export fn entry() usize { return @sizeOf(@TypeOf(f)); }
     , &[_][]const u8{
         "tmp.zig:1:6: error: missing parameter name",
     });
-    cases.add("wrong function type",
+    ctx.objErrStage1("wrong function type",
         \\const fns = [_]fn() void { a, b, c };
         \\fn a() i32 {return 0;}
         \\fn b() i32 {return 1;}
 @@ -5377,7 +5610,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         "tmp.zig:1:28: error: expected type 'fn() void', found 'fn() i32'",
     });
-    cases.add("extern function pointer mismatch",
+    ctx.objErrStage1("extern function pointer mismatch",
         \\const fns = [_](fn(i32)i32) { a, b, c };
         \\pub fn a(x: i32) i32 {return x + 0;}
         \\pub fn b(x: i32) i32 {return x + 1;}
 @@ -5388,15 +5621,16 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         "tmp.zig:1:37: error: expected type 'fn(i32) i32', found 'fn(i32) callconv(.C) i32'",
     });
-    cases.add("colliding invalid top level functions",
+    ctx.objErrStage1("colliding invalid top level functions",
         \\fn func() bogus {}
         \\fn func() bogus {}
         \\export fn entry() usize { return @sizeOf(@TypeOf(func)); }
     , &[_][]const u8{
-        "tmp.zig:2:1: error: redefinition of 'func'",
+        "tmp.zig:2:1: error: redeclaration of 'func'",
+        "tmp.zig:1:1: note: other declaration here",
     });
-    cases.add("non constant expression in array size",
+    ctx.objErrStage1("non constant expression in array size",
         \\const Foo = struct {
         \\    y: [get()]u8,
         \\};
 @@ -5409,7 +5643,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         "tmp.zig:2:12: note: called from here",
     });
-    cases.add("addition with non numbers",
+    ctx.objErrStage1("addition with non numbers",
         \\const Foo = struct {
         \\    field: i32,
         \\};
 @@ -5420,7 +5654,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         "tmp.zig:4:28: error: invalid operands to binary expression: 'Foo' and 'Foo'",
     });
-    cases.add("division by zero",
+    ctx.objErrStage1("division by zero",
         \\const lit_int_x = 1 / 0;
         \\const lit_float_x = 1.0 / 0.0;
         \\const int_x = @as(u32, 1) / @as(u32, 0);
 @@ -5437,16 +5671,15 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         "tmp.zig:4:31: error: division by zero",
     });
-    cases.add("normal string with newline",
+    ctx.objErrStage1("normal string with newline",
         \\const foo = "a
         \\b";
-        \\
-        \\export fn entry() usize { return @sizeOf(@TypeOf(foo)); }
     , &[_][]const u8{
-        "tmp.zig:1:15: error: newline not allowed in string literal",
+        "tmp.zig:1:13: error: expected expression, found 'invalid'",
+        "tmp.zig:1:15: note: invalid byte: '\\n'",
     });
-    cases.add("invalid comparison for function pointers",
+    ctx.objErrStage1("invalid comparison for function pointers",
         \\fn foo() void {}
         \\const invalid = foo > foo;
         \\
 @@ -5455,7 +5688,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         "tmp.zig:2:21: error: operator not allowed for type 'fn() void'",
     });
-    cases.add("generic function instance with non-constant expression",
+    ctx.objErrStage1("generic function instance with non-constant expression",
         \\fn foo(comptime x: i32, y: i32) i32 { return x + y; }
         \\fn test1(a: i32, b: i32) i32 {
         \\    return foo(a, b);
 @@ -5466,7 +5699,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         "tmp.zig:3:16: error: runtime value cannot be passed to comptime arg",
     });
-    cases.add("assign null to non-optional pointer",
+    ctx.objErrStage1("assign null to non-optional pointer",
         \\const a: *u8 = null;
         \\
         \\export fn entry() usize { return @sizeOf(@TypeOf(a)); }
 @@ -5474,26 +5707,28 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         "tmp.zig:1:16: error: expected type '*u8', found '(null)'",
     });
-    cases.add("indexing an array of size zero",
+    ctx.objErrStage1("indexing an array of size zero",
         \\const array = [_]u8{};
         \\export fn foo() void {
         \\    const pointer = &array[0];
+        \\    _ = pointer;
         \\}
     , &[_][]const u8{
         "tmp.zig:3:27: error: accessing a zero length array is not allowed",
     });
-    cases.add("indexing an array of size zero with runtime index",
+    ctx.objErrStage1("indexing an array of size zero with runtime index",
         \\const array = [_]u8{};
         \\export fn foo() void {
         \\    var index: usize = 0;
         \\    const pointer = &array[index];
+        \\    _ = pointer;
         \\}
     , &[_][]const u8{
         "tmp.zig:4:27: error: accessing a zero length array is not allowed",
     });
-    cases.add("compile time division by zero",
+    ctx.objErrStage1("compile time division by zero",
         \\const y = foo(0);
         \\fn foo(x: u32) u32 {
         \\    return 1 / x;
 @@ -5505,7 +5740,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         "tmp.zig:1:14: note: referenced here",
     });
-    cases.add("branch on undefined value",
+    ctx.objErrStage1("branch on undefined value",
         \\const x = if (undefined) true else false;
         \\
         \\export fn entry() usize { return @sizeOf(@TypeOf(x)); }
 @@ -5513,7 +5748,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         "tmp.zig:1:15: error: use of undefined value here causes undefined behavior",
     });
-    cases.add("div on undefined value",
+    ctx.objErrStage1("div on undefined value",
         \\comptime {
         \\    var a: i64 = undefined;
         \\    _ = a / a;
 @@ -5522,7 +5757,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         "tmp.zig:3:9: error: use of undefined value here causes undefined behavior",
     });
-    cases.add("div assign on undefined value",
+    ctx.objErrStage1("div assign on undefined value",
         \\comptime {
         \\    var a: i64 = undefined;
         \\    a /= a;
 @@ -5531,7 +5766,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         "tmp.zig:3:5: error: use of undefined value here causes undefined behavior",
     });
-    cases.add("mod on undefined value",
+    ctx.objErrStage1("mod on undefined value",
         \\comptime {
         \\    var a: i64 = undefined;
         \\    _ = a % a;
 @@ -5540,7 +5775,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         "tmp.zig:3:9: error: use of undefined value here causes undefined behavior",
     });
-    cases.add("mod assign on undefined value",
+    ctx.objErrStage1("mod assign on undefined value",
         \\comptime {
         \\    var a: i64 = undefined;
         \\    a %= a;
 @@ -5549,7 +5784,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         "tmp.zig:3:5: error: use of undefined value here causes undefined behavior",
     });
-    cases.add("add on undefined value",
+    ctx.objErrStage1("add on undefined value",
         \\comptime {
         \\    var a: i64 = undefined;
         \\    _ = a + a;
 @@ -5558,7 +5793,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         "tmp.zig:3:9: error: use of undefined value here causes undefined behavior",
     });
-    cases.add("add assign on undefined value",
+    ctx.objErrStage1("add assign on undefined value",
         \\comptime {
         \\    var a: i64 = undefined;
         \\    a += a;
 @@ -5567,7 +5802,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         "tmp.zig:3:5: error: use of undefined value here causes undefined behavior",
     });
-    cases.add("add wrap on undefined value",
+    ctx.objErrStage1("add wrap on undefined value",
         \\comptime {
         \\    var a: i64 = undefined;
         \\    _ = a +% a;
 @@ -5576,7 +5811,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         "tmp.zig:3:9: error: use of undefined value here causes undefined behavior",
     });
-    cases.add("add wrap assign on undefined value",
+    ctx.objErrStage1("add wrap assign on undefined value",
         \\comptime {
         \\    var a: i64 = undefined;
         \\    a +%= a;
 @@ -5585,7 +5820,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         "tmp.zig:3:5: error: use of undefined value here causes undefined behavior",
     });
-    cases.add("sub on undefined value",
+    ctx.objErrStage1("sub on undefined value",
         \\comptime {
         \\    var a: i64 = undefined;
         \\    _ = a - a;
 @@ -5594,7 +5829,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         "tmp.zig:3:9: error: use of undefined value here causes undefined behavior",
     });
-    cases.add("sub assign on undefined value",
+    ctx.objErrStage1("sub assign on undefined value",
         \\comptime {
         \\    var a: i64 = undefined;
         \\    a -= a;
 @@ -5603,7 +5838,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         "tmp.zig:3:5: error: use of undefined value here causes undefined behavior",
     });
-    cases.add("sub wrap on undefined value",
+    ctx.objErrStage1("sub wrap on undefined value",
         \\comptime {
         \\    var a: i64 = undefined;
         \\    _ = a -% a;
 @@ -5612,7 +5847,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         "tmp.zig:3:9: error: use of undefined value here causes undefined behavior",
     });
-    cases.add("sub wrap assign on undefined value",
+    ctx.objErrStage1("sub wrap assign on undefined value",
         \\comptime {
         \\    var a: i64 = undefined;
         \\    a -%= a;
 @@ -5621,7 +5856,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         "tmp.zig:3:5: error: use of undefined value here causes undefined behavior",
     });
-    cases.add("mult on undefined value",
+    ctx.objErrStage1("mult on undefined value",
         \\comptime {
         \\    var a: i64 = undefined;
         \\    _ = a * a;
 @@ -5630,7 +5865,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         "tmp.zig:3:9: error: use of undefined value here causes undefined behavior",
     });
-    cases.add("mult assign on undefined value",
+    ctx.objErrStage1("mult assign on undefined value",
         \\comptime {
         \\    var a: i64 = undefined;
         \\    a *= a;
 @@ -5639,7 +5874,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         "tmp.zig:3:5: error: use of undefined value here causes undefined behavior",
     });
-    cases.add("mult wrap on undefined value",
+    ctx.objErrStage1("mult wrap on undefined value",
         \\comptime {
         \\    var a: i64 = undefined;
         \\    _ = a *% a;
 @@ -5648,7 +5883,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         "tmp.zig:3:9: error: use of undefined value here causes undefined behavior",
     });
-    cases.add("mult wrap assign on undefined value",
+    ctx.objErrStage1("mult wrap assign on undefined value",
         \\comptime {
         \\    var a: i64 = undefined;
         \\    a *%= a;
 @@ -5657,7 +5892,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         "tmp.zig:3:5: error: use of undefined value here causes undefined behavior",
     });
-    cases.add("shift left on undefined value",
+    ctx.objErrStage1("shift left on undefined value",
         \\comptime {
         \\    var a: i64 = undefined;
         \\    _ = a << 2;
 @@ -5666,7 +5901,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         "tmp.zig:3:9: error: use of undefined value here causes undefined behavior",
     });
-    cases.add("shift left assign on undefined value",
+    ctx.objErrStage1("shift left assign on undefined value",
         \\comptime {
         \\    var a: i64 = undefined;
         \\    a <<= 2;
 @@ -5675,7 +5910,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         "tmp.zig:3:5: error: use of undefined value here causes undefined behavior",
     });
-    cases.add("shift right on undefined value",
+    ctx.objErrStage1("shift right on undefined value",
         \\comptime {
         \\    var a: i64 = undefined;
         \\    _ = a >> 2;
 @@ -5684,7 +5919,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         "tmp.zig:3:9: error: use of undefined value here causes undefined behavior",
     });
-    cases.add("shift left assign on undefined value",
+    ctx.objErrStage1("shift left assign on undefined value",
         \\comptime {
         \\    var a: i64 = undefined;
         \\    a >>= 2;
 @@ -5693,7 +5928,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         "tmp.zig:3:5: error: use of undefined value here causes undefined behavior",
     });
-    cases.add("bin and on undefined value",
+    ctx.objErrStage1("bin and on undefined value",
         \\comptime {
         \\    var a: i64 = undefined;
         \\    _ = a & a;
 @@ -5702,7 +5937,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         "tmp.zig:3:9: error: use of undefined value here causes undefined behavior",
     });
-    cases.add("bin and assign on undefined value",
+    ctx.objErrStage1("bin and assign on undefined value",
         \\comptime {
         \\    var a: i64 = undefined;
         \\    a &= a;
 @@ -5711,7 +5946,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         "tmp.zig:3:5: error: use of undefined value here causes undefined behavior",
     });
-    cases.add("bin or on undefined value",
+    ctx.objErrStage1("bin or on undefined value",
         \\comptime {
         \\    var a: i64 = undefined;
         \\    _ = a | a;
 @@ -5720,7 +5955,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         "tmp.zig:3:9: error: use of undefined value here causes undefined behavior",
     });
-    cases.add("bin or assign on undefined value",
+    ctx.objErrStage1("bin or assign on undefined value",
         \\comptime {
         \\    var a: i64 = undefined;
         \\    a |= a;
 @@ -5729,7 +5964,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         "tmp.zig:3:5: error: use of undefined value here causes undefined behavior",
     });
-    cases.add("bin xor on undefined value",
+    ctx.objErrStage1("bin xor on undefined value",
         \\comptime {
         \\    var a: i64 = undefined;
         \\    _ = a ^ a;
 @@ -5738,7 +5973,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         "tmp.zig:3:9: error: use of undefined value here causes undefined behavior",
     });
-    cases.add("bin xor assign on undefined value",
+    ctx.objErrStage1("bin xor assign on undefined value",
         \\comptime {
         \\    var a: i64 = undefined;
         \\    a ^= a;
 @@ -5747,7 +5982,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         "tmp.zig:3:5: error: use of undefined value here causes undefined behavior",
     });
-    cases.add("comparison operators with undefined value",
+    ctx.objErrStage1("comparison operators with undefined value",
         \\// operator ==
         \\comptime {
         \\    var a: i64 = undefined;
 @@ -5793,7 +6028,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         "tmp.zig:35:11: error: use of undefined value here causes undefined behavior",
     });
-    cases.add("and on undefined value",
+    ctx.objErrStage1("and on undefined value",
         \\comptime {
         \\    var a: bool = undefined;
         \\    _ = a and a;
 @@ -5802,7 +6037,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         "tmp.zig:3:9: error: use of undefined value here causes undefined behavior",
     });
-    cases.add("or on undefined value",
+    ctx.objErrStage1("or on undefined value",
         \\comptime {
         \\    var a: bool = undefined;
         \\    _ = a or a;
 @@ -5811,7 +6046,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         "tmp.zig:3:9: error: use of undefined value here causes undefined behavior",
     });
-    cases.add("negate on undefined value",
+    ctx.objErrStage1("negate on undefined value",
         \\comptime {
         \\    var a: i64 = undefined;
         \\    _ = -a;
 @@ -5820,7 +6055,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         "tmp.zig:3:10: error: use of undefined value here causes undefined behavior",
     });
-    cases.add("negate wrap on undefined value",
+    ctx.objErrStage1("negate wrap on undefined value",
         \\comptime {
         \\    var a: i64 = undefined;
         \\    _ = -%a;
 @@ -5829,7 +6064,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         "tmp.zig:3:11: error: use of undefined value here causes undefined behavior",
     });
-    cases.add("bin not on undefined value",
+    ctx.objErrStage1("bin not on undefined value",
         \\comptime {
         \\    var a: i64 = undefined;
         \\    _ = ~a;
 @@ -5838,7 +6073,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         "tmp.zig:3:10: error: use of undefined value here causes undefined behavior",
     });
-    cases.add("bool not on undefined value",
+    ctx.objErrStage1("bool not on undefined value",
         \\comptime {
         \\    var a: bool = undefined;
         \\    _ = !a;
 @@ -5847,7 +6082,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         "tmp.zig:3:10: error: use of undefined value here causes undefined behavior",
     });
-    cases.add("orelse on undefined value",
+    ctx.objErrStage1("orelse on undefined value",
         \\comptime {
         \\    var a: ?bool = undefined;
         \\    _ = a orelse false;
 @@ -5856,16 +6091,16 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         "tmp.zig:3:11: error: use of undefined value here causes undefined behavior",
     });
-    cases.add("catch on undefined value",
+    ctx.objErrStage1("catch on undefined value",
         \\comptime {
         \\    var a: anyerror!bool = undefined;
-        \\    _ = a catch |err| false;
+        \\    _ = a catch false;
         \\}
     , &[_][]const u8{
         "tmp.zig:3:11: error: use of undefined value here causes undefined behavior",
     });
-    cases.add("deref on undefined value",
+    ctx.objErrStage1("deref on undefined value",
         \\comptime {
         \\    var a: *u8 = undefined;
         \\    _ = a.*;
 @@ -5874,7 +6109,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         "tmp.zig:3:9: error: attempt to dereference undefined value",
     });
-    cases.add("endless loop in function evaluation",
+    ctx.objErrStage1("endless loop in function evaluation",
         \\const seventh_fib_number = fibbonaci(7);
         \\fn fibbonaci(x: i32) i32 {
         \\    return fibbonaci(x - 1) + fibbonaci(x - 2);
 @@ -5887,16 +6122,15 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         "tmp.zig:6:50: note: referenced here",
     });
-    cases.add("@embedFile with bogus file",
+    ctx.objErrStage1("@embedFile with bogus file",
         \\const resource = @embedFile("bogus.txt",);
         \\
         \\export fn entry() usize { return @sizeOf(@TypeOf(resource)); }
     , &[_][]const u8{
         "tmp.zig:1:29: error: unable to find '",
-        "bogus.txt'",
     });
-    cases.add("non-const expression in struct literal outside function",
+    ctx.objErrStage1("non-const expression in struct literal outside function",
         \\const Foo = struct {
         \\    x: i32,
         \\};
 @@ -5908,7 +6142,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         "tmp.zig:4:21: error: unable to evaluate constant expression",
     });
-    cases.add("non-const expression function call with struct return value outside function",
+    ctx.objErrStage1("non-const expression function call with struct return value outside function",
         \\const Foo = struct {
         \\    x: i32,
         \\};
 @@ -5925,7 +6159,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         "tmp.zig:4:17: note: referenced here",
     });
-    cases.add("undeclared identifier error should mark fn as impure",
+    ctx.objErrStage1("undeclared identifier error should mark fn as impure",
         \\export fn foo() void {
         \\    test_a_thing();
         \\}
 @@ -5936,7 +6170,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         "tmp.zig:5:5: error: use of undeclared identifier 'bad_fn_call'",
     });
-    cases.add("illegal comparison of types",
+    ctx.objErrStage1("illegal comparison of types",
         \\fn bad_eql_1(a: []u8, b: []u8) bool {
         \\    return a == b;
         \\}
 @@ -5955,13 +6189,14 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         "tmp.zig:9:16: error: operator not allowed for type 'EnumWithData'",
     });
-    cases.add("non-const switch number literal",
+    ctx.objErrStage1("non-const switch number literal",
         \\export fn foo() void {
         \\    const x = switch (bar()) {
         \\        1, 2 => 1,
         \\        3, 4 => 2,
         \\        else => 3,
         \\    };
+        \\    _ = x;
         \\}
         \\fn bar() i32 {
         \\    return 2;
 @@ -5970,7 +6205,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         "tmp.zig:5:17: error: cannot store runtime value in type 'comptime_int'",
     });
-    cases.add("atomic orderings of cmpxchg - failure stricter than success",
+    ctx.objErrStage1("atomic orderings of cmpxchg - failure stricter than success",
         \\const AtomicOrder = @import("std").builtin.AtomicOrder;
         \\export fn f() void {
         \\    var x: i32 = 1234;
 @@ -5980,7 +6215,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         "tmp.zig:4:81: error: failure atomic ordering must be no stricter than success",
     });
-    cases.add("atomic orderings of cmpxchg - success Monotonic or stricter",
+    ctx.objErrStage1("atomic orderings of cmpxchg - success Monotonic or stricter",
         \\const AtomicOrder = @import("std").builtin.AtomicOrder;
         \\export fn f() void {
         \\    var x: i32 = 1234;
 @@ -5990,7 +6225,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         "tmp.zig:4:58: error: success atomic ordering must be Monotonic or stricter",
     });
-    cases.add("negation overflow in function evaluation",
+    ctx.objErrStage1("negation overflow in function evaluation",
         \\const y = neg(-128);
         \\fn neg(x: i8) i8 {
         \\    return -x;
 @@ -6002,7 +6237,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         "tmp.zig:1:14: note: referenced here",
     });
-    cases.add("add overflow in function evaluation",
+    ctx.objErrStage1("add overflow in function evaluation",
         \\const y = add(65530, 10);
         \\fn add(a: u16, b: u16) u16 {
         \\    return a + b;
 @@ -6014,7 +6249,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         "tmp.zig:1:14: note: referenced here",
     });
-    cases.add("sub overflow in function evaluation",
+    ctx.objErrStage1("sub overflow in function evaluation",
         \\const y = sub(10, 20);
         \\fn sub(a: u16, b: u16) u16 {
         \\    return a - b;
 @@ -6026,7 +6261,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         "tmp.zig:1:14: note: referenced here",
     });
-    cases.add("mul overflow in function evaluation",
+    ctx.objErrStage1("mul overflow in function evaluation",
         \\const y = mul(300, 6000);
         \\fn mul(a: u16, b: u16) u16 {
         \\    return a * b;
 @@ -6038,7 +6273,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         "tmp.zig:1:14: note: referenced here",
     });
-    cases.add("truncate sign mismatch",
+    ctx.objErrStage1("truncate sign mismatch",
         \\export fn entry1() i8 {
         \\    var x: u32 = 10;
         \\    return @truncate(i8, x);
 @@ -6062,7 +6297,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         "tmp.zig:15:26: error: expected unsigned integer type, found 'i32'",
     });
-    cases.add("try in function with non error return type",
+    ctx.objErrStage1("try in function with non error return type",
         \\export fn f() void {
         \\    try something();
         \\}
 @@ -6071,7 +6306,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         "tmp.zig:2:5: error: expected type 'void', found 'anyerror'",
     });
-    cases.add("invalid pointer for var type",
+    ctx.objErrStage1("invalid pointer for var type",
         \\extern fn ext() usize;
         \\var bytes: [ext()]u8 = undefined;
         \\export fn f() void {
 @@ -6083,7 +6318,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         "tmp.zig:2:13: error: unable to evaluate constant expression",
     });
-    cases.add("export function with comptime parameter",
+    ctx.objErrStage1("export function with comptime parameter",
         \\export fn foo(comptime x: i32, y: i32) i32{
         \\    return x + y;
         \\}
 @@ -6091,7 +6326,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         "tmp.zig:1:15: error: comptime parameter not allowed in function with calling convention 'C'",
     });
-    cases.add("extern function with comptime parameter",
+    ctx.objErrStage1("extern function with comptime parameter",
         \\extern fn foo(comptime x: i32, y: i32) i32;
         \\fn f() i32 {
         \\    return foo(1, 2);
 @@ -6101,7 +6336,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         "tmp.zig:1:15: error: comptime parameter not allowed in function with calling convention 'C'",
     });
-    cases.add("non-pure function returns type",
+    ctx.objErrStage1("non-pure function returns type",
         \\var a: u32 = 0;
         \\pub fn List(comptime T: type) type {
         \\    a += 1;
 @@ -6125,7 +6360,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         "tmp.zig:16:19: note: referenced here",
     });
-    cases.add("bogus method call on slice",
+    ctx.objErrStage1("bogus method call on slice",
         \\var self = "aoeu";
         \\fn f(m: []const u8) void {
         \\    m.copy(u8, self[0..], m);
 @@ -6135,9 +6370,9 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         "tmp.zig:3:6: error: no member named 'copy' in '[]const u8'",
     });
-    cases.add("wrong number of arguments for method fn call",
+    ctx.objErrStage1("wrong number of arguments for method fn call",
         \\const Foo = struct {
-        \\    fn method(self: *const Foo, a: i32) void {}
+        \\    fn method(self: *const Foo, a: i32) void {_ = self; _ = a;}
         \\};
         \\fn f(foo: *const Foo) void {
         \\
 @@ -6148,7 +6383,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         "tmp.zig:6:15: error: expected 2 argument(s), found 3",
     });
-    cases.add("assign through constant pointer",
+    ctx.objErrStage1("assign through constant pointer",
         \\export fn f() void {
         \\  var cstr = "Hat";
         \\  cstr[0] = 'W';
 @@ -6157,7 +6392,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         "tmp.zig:3:13: error: cannot assign to constant",
     });
-    cases.add("assign through constant slice",
+    ctx.objErrStage1("assign through constant slice",
         \\export fn f() void {
         \\  var cstr: []const u8 = "Hat";
         \\  cstr[0] = 'W';
 @@ -6166,13 +6401,13 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         "tmp.zig:3:13: error: cannot assign to constant",
     });
-    cases.add("main function with bogus args type",
+    ctx.objErrStage1("main function with bogus args type",
-        \\pub fn main(args: [][]bogus) !void {}
+        \\pub fn main(args: [][]bogus) !void {_ = args;}
     , &[_][]const u8{
         "tmp.zig:1:23: error: use of undeclared identifier 'bogus'",
     });
-    cases.add("misspelled type with pointer only reference",
+    ctx.objErrStage1("misspelled type with pointer only reference",
         \\const JasonHM = u8;
         \\const JasonList = *JsonNode;
         \\
 @@ -6200,6 +6435,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         \\    var jll: JasonList = undefined;
         \\    jll.init(1234);
         \\    var jd = JsonNode {.kind = JsonType.JSONArray , .jobject = JsonOA.JSONArray {jll} };
+        \\    _ = jd;
         \\}
         \\
         \\export fn entry() usize { return @sizeOf(@TypeOf(foo)); }
 @@ -6207,7 +6443,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         "tmp.zig:5:16: error: use of undeclared identifier 'JsonList'",
     });
-    cases.add("method call with first arg type primitive",
+    ctx.objErrStage1("method call with first arg type primitive",
         \\const Foo = struct {
         \\    x: i32,
         \\
 @@ -6227,7 +6463,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         "tmp.zig:14:5: error: expected type 'i32', found 'Foo'",
     });
-    cases.add("method call with first arg type wrong container",
+    ctx.objErrStage1("method call with first arg type wrong container",
         \\pub const List = struct {
         \\    len: usize,
         \\    allocator: *Allocator,
 @@ -6256,7 +6492,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         "tmp.zig:23:5: error: expected type '*Allocator', found '*List'",
     });
-    cases.add("binary not on number literal",
+    ctx.objErrStage1("binary not on number literal",
         \\const TINY_QUANTUM_SHIFT = 4;
         \\const TINY_QUANTUM_SIZE = 1 << TINY_QUANTUM_SHIFT;
         \\var block_aligned_stuff: usize = (4 + TINY_QUANTUM_SIZE) & ~(TINY_QUANTUM_SIZE - 1);
 @@ -6266,8 +6502,15 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         "tmp.zig:3:60: error: unable to perform binary not operation on type 'comptime_int'",
     });
-    cases.addCase(x: {
+    {
-        const tc = cases.create("multiple files with private function error",
+        const case = ctx.obj("multiple files with private function error", .{});
+        case.backend = .stage1;
+        case.addSourceFile("foo.zig",
+            \\fn privateFunction() void { }
+        );
+        case.addError(
             \\const foo = @import("foo.zig",);
             \\
             \\export fn callPrivFunction() void {
 @@ -6277,16 +6520,19 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
             "tmp.zig:4:8: error: 'privateFunction' is private",
             "foo.zig:1:1: note: declared here",
         });
+    }
-        tc.addSourceFile("foo.zig",
+    {
-            \\fn privateFunction() void { }
+        const case = ctx.obj("multiple files with private member instance function (canonical invocation) error", .{});
-        );
+        case.backend = .stage1;
-        break :x tc;
+        case.addSourceFile("foo.zig",
-    });
+            \\pub const Foo = struct {
+            \\    fn privateFunction(self: *Foo) void { _ = self; }
+            \\};
+        );
-    cases.addCase(x: {
+        case.addError(
-        const tc = cases.create("multiple files with private member instance function (canonical invocation) error",
             \\const Foo = @import("foo.zig",).Foo;
             \\
             \\export fn callPrivFunction() void {
 @@ -6297,18 +6543,19 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
             "tmp.zig:5:8: error: 'privateFunction' is private",
             "foo.zig:2:5: note: declared here",
         });
+    }
+    {
+        const case = ctx.obj("multiple files with private member instance function error", .{});
+        case.backend = .stage1;
-        tc.addSourceFile("foo.zig",
+        case.addSourceFile("foo.zig",
             \\pub const Foo = struct {
-            \\    fn privateFunction(self: *Foo) void { }
+            \\    fn privateFunction(self: *Foo) void { _ = self; }
             \\};
         );
-        break :x tc;
+        case.addError(
-    });
-    cases.addCase(x: {
-        const tc = cases.create("multiple files with private member instance function error",
             \\const Foo = @import("foo.zig",).Foo;
             \\
             \\export fn callPrivFunction() void {
 @@ -6319,17 +6566,9 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
             "tmp.zig:5:8: error: 'privateFunction' is private",
             "foo.zig:2:5: note: declared here",
         });
+    }
-        tc.addSourceFile("foo.zig",
+    ctx.objErrStage1("container init with non-type",
-            \\pub const Foo = struct {
-            \\    fn privateFunction(self: *Foo) void { }
-            \\};
-        );
-        break :x tc;
-    });
-    cases.add("container init with non-type",
         \\const zero: i32 = 0;
         \\const a = zero{1};
         \\
 @@ -6338,7 +6577,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         "tmp.zig:2:11: error: expected type 'type', found 'i32'",
     });
-    cases.add("assign to constant field",
+    ctx.objErrStage1("assign to constant field",
         \\const Foo = struct {
         \\    field: i32,
         \\};
 @@ -6350,7 +6589,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         "tmp.zig:6:15: error: cannot assign to constant",
     });
-    cases.add("return from defer expression",
+    ctx.objErrStage1("return from defer expression",
         \\pub fn testTrickyDefer() !void {
         \\    defer canFail() catch {};
         \\
 @@ -6367,32 +6606,33 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         \\
         \\export fn entry() usize { return @sizeOf(@TypeOf(testTrickyDefer)); }
     , &[_][]const u8{
-        "tmp.zig:4:11: error: cannot return from defer expression",
+        "tmp.zig:4:11: error: 'try' not allowed inside defer expression",
     });
-    cases.add("assign too big number to u16",
+    ctx.objErrStage1("assign too big number to u16",
         \\export fn foo() void {
         \\    var vga_mem: u16 = 0xB8000;
+        \\    _ = vga_mem;
         \\}
     , &[_][]const u8{
         "tmp.zig:2:24: error: integer value 753664 cannot be coerced to type 'u16'",
     });
-    cases.add("global variable alignment non power of 2",
+    ctx.objErrStage1("global variable alignment non power of 2",
         \\const some_data: [100]u8 align(3) = undefined;
         \\export fn entry() usize { return @sizeOf(@TypeOf(some_data)); }
     , &[_][]const u8{
         "tmp.zig:1:32: error: alignment value 3 is not a power of 2",
     });
-    cases.add("function alignment non power of 2",
+    ctx.objErrStage1("function alignment non power of 2",
         \\extern fn foo() align(3) void;
         \\export fn entry() void { return foo(); }
     , &[_][]const u8{
         "tmp.zig:1:23: error: alignment value 3 is not a power of 2",
     });
-    cases.add("compile log",
+    ctx.objErrStage1("compile log",
         \\export fn foo() void {
         \\    comptime bar(12, "hi",);
         \\}
 @@ -6407,7 +6647,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         "tmp.zig:7:5: error: found compile log statement",
     });
-    cases.add("casting bit offset pointer to regular pointer",
+    ctx.objErrStage1("casting bit offset pointer to regular pointer",
         \\const BitField = packed struct {
         \\    a: u3,
         \\    b: u3,
 @@ -6427,7 +6667,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         "tmp.zig:8:26: error: expected type '*const u3', found '*align(:3:1) const u3'",
     });
-    cases.add("referring to a struct that is invalid",
+    ctx.objErrStage1("referring to a struct that is invalid",
         \\const UsbDeviceRequest = struct {
         \\    Type: u8,
         \\};
 @@ -6444,7 +6684,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         "tmp.zig:6:20: note: referenced here",
     });
-    cases.add("control flow uses comptime var at runtime",
+    ctx.objErrStage1("control flow uses comptime var at runtime",
         \\export fn foo() void {
         \\    comptime var i = 0;
         \\    while (i < 5) : (i += 1) {
 @@ -6458,7 +6698,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         "tmp.zig:3:24: note: compile-time variable assigned here",
     });
-    cases.add("ignored return value",
+    ctx.objErrStage1("ignored return value",
         \\export fn foo() void {
         \\    bar();
         \\}
 @@ -6467,7 +6707,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         "tmp.zig:2:8: error: expression value is ignored",
     });
-    cases.add("ignored assert-err-ok return value",
+    ctx.objErrStage1("ignored assert-err-ok return value",
         \\export fn foo() void {
         \\    bar() catch unreachable;
         \\}
 @@ -6476,7 +6716,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         "tmp.zig:2:11: error: expression value is ignored",
     });
-    cases.add("ignored statement value",
+    ctx.objErrStage1("ignored statement value",
         \\export fn foo() void {
         \\    1;
         \\}
 @@ -6484,7 +6724,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         "tmp.zig:2:5: error: expression value is ignored",
     });
-    cases.add("ignored comptime statement value",
+    ctx.objErrStage1("ignored comptime statement value",
         \\export fn foo() void {
         \\    comptime {1;}
         \\}
 @@ -6492,7 +6732,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         "tmp.zig:2:15: error: expression value is ignored",
     });
-    cases.add("ignored comptime value",
+    ctx.objErrStage1("ignored comptime value",
         \\export fn foo() void {
         \\    comptime 1;
         \\}
 @@ -6500,7 +6740,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         "tmp.zig:2:5: error: expression value is ignored",
     });
-    cases.add("ignored defered statement value",
+    ctx.objErrStage1("ignored defered statement value",
         \\export fn foo() void {
         \\    defer {1;}
         \\}
 @@ -6508,7 +6748,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         "tmp.zig:2:12: error: expression value is ignored",
     });
-    cases.add("ignored defered function call",
+    ctx.objErrStage1("ignored defered function call",
         \\export fn foo() void {
         \\    defer bar();
         \\}
 @@ -6517,7 +6757,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         "tmp.zig:2:14: error: error is ignored. consider using `try`, `catch`, or `if`",
     });
-    cases.add("dereference an array",
+    ctx.objErrStage1("dereference an array",
         \\var s_buffer: [10]u8 = undefined;
         \\pub fn pass(in: []u8) []u8 {
         \\    var out = &s_buffer;
 @@ -6530,13 +6770,14 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         "tmp.zig:4:10: error: attempt to dereference non-pointer type '[10]u8'",
     });
-    cases.add("pass const ptr to mutable ptr fn",
+    ctx.objErrStage1("pass const ptr to mutable ptr fn",
         \\fn foo() bool {
         \\    const a = @as([]const u8, "a",);
         \\    const b = &a;
         \\    return ptrEql(b, b);
         \\}
         \\fn ptrEql(a: *[]const u8, b: *[]const u8) bool {
+        \\    _ = a; _ = b;
         \\    return true;
         \\}
         \\
 @@ -6545,8 +6786,16 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         "tmp.zig:4:19: error: expected type '*[]const u8', found '*const []const u8'",
     });
-    cases.addCase(x: {
+    {
-        const tc = cases.create("export collision",
+        const case = ctx.obj("export collision", .{});
+        case.backend = .stage1;
+        case.addSourceFile("foo.zig",
+            \\export fn bar() void {}
+            \\pub const baz = 1234;
+        );
+        case.addError(
             \\const foo = @import("foo.zig",);
             \\
             \\export fn bar() usize {
 @@ -6556,18 +6805,11 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
             "foo.zig:1:1: error: exported symbol collision: 'bar'",
             "tmp.zig:3:1: note: other symbol here",
         });
+    }
-        tc.addSourceFile("foo.zig",
+    ctx.objErrStage1("implicit cast from array to mutable slice",
-            \\export fn bar() void {}
-            \\pub const baz = 1234;
-        );
-        break :x tc;
-    });
-    cases.add("implicit cast from array to mutable slice",
         \\var global_array: [10]i32 = undefined;
-        \\fn foo(param: []i32) void {}
+        \\fn foo(param: []i32) void {_ = param;}
         \\export fn entry() void {
         \\    foo(global_array);
         \\}
 @@ -6575,7 +6817,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         "tmp.zig:4:9: error: expected type '[]i32', found '[10]i32'",
     });
-    cases.add("ptrcast to non-pointer",
+    ctx.objErrStage1("ptrcast to non-pointer",
         \\export fn entry(a: *i32) usize {
         \\    return @ptrCast(usize, a);
         \\}
 @@ -6583,7 +6825,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         "tmp.zig:2:21: error: expected pointer, found 'usize'",
     });
-    cases.add("asm at compile time",
+    ctx.objErrStage1("asm at compile time",
         \\comptime {
         \\    doSomeAsm();
         \\}
 @@ -6599,25 +6841,27 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         "tmp.zig:6:5: error: unable to evaluate constant expression",
     });
-    cases.add("invalid member of builtin enum",
+    ctx.objErrStage1("invalid member of builtin enum",
         \\const builtin = @import("std").builtin;
         \\export fn entry() void {
         \\    const foo = builtin.Mode.x86;
+        \\    _ = foo;
         \\}
     , &[_][]const u8{
         "tmp.zig:3:29: error: container 'std.builtin.Mode' has no member called 'x86'",
     });
-    cases.add("int to ptr of 0 bits",
+    ctx.objErrStage1("int to ptr of 0 bits",
         \\export fn foo() void {
         \\    var x: usize = 0x1000;
         \\    var y: *void = @intToPtr(*void, x);
+        \\    _ = y;
         \\}
     , &[_][]const u8{
         "tmp.zig:3:30: error: type '*void' has 0 bits and cannot store information",
     });
-    cases.add("@fieldParentPtr - non struct",
+    ctx.objErrStage1("@fieldParentPtr - non struct",
         \\const Foo = i32;
         \\export fn foo(a: *i32) *Foo {
         \\    return @fieldParentPtr(Foo, "a", a);
 @@ -6626,7 +6870,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         "tmp.zig:3:28: error: expected struct type, found 'i32'",
     });
-    cases.add("@fieldParentPtr - bad field name",
+    ctx.objErrStage1("@fieldParentPtr - bad field name",
         \\const Foo = extern struct {
         \\    derp: i32,
         \\};
 @@ -6637,7 +6881,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         "tmp.zig:5:33: error: struct 'Foo' has no field 'a'",
     });
-    cases.add("@fieldParentPtr - field pointer is not pointer",
+    ctx.objErrStage1("@fieldParentPtr - field pointer is not pointer",
         \\const Foo = extern struct {
         \\    a: i32,
         \\};
 @@ -6648,7 +6892,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         "tmp.zig:5:38: error: expected pointer, found 'i32'",
     });
-    cases.add("@fieldParentPtr - comptime field ptr not based on struct",
+    ctx.objErrStage1("@fieldParentPtr - comptime field ptr not based on struct",
         \\const Foo = struct {
         \\    a: i32,
         \\    b: i32,
 @@ -6658,12 +6902,13 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         \\comptime {
         \\    const field_ptr = @intToPtr(*i32, 0x1234);
         \\    const another_foo_ptr = @fieldParentPtr(Foo, "b", field_ptr);
+        \\    _ = another_foo_ptr;
         \\}
     , &[_][]const u8{
         "tmp.zig:9:55: error: pointer value not based on parent struct",
     });
-    cases.add("@fieldParentPtr - comptime wrong field index",
+    ctx.objErrStage1("@fieldParentPtr - comptime wrong field index",
         \\const Foo = struct {
         \\    a: i32,
         \\    b: i32,
 @@ -6672,12 +6917,13 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         \\
         \\comptime {
         \\    const another_foo_ptr = @fieldParentPtr(Foo, "b", &foo.a);
+        \\    _ = another_foo_ptr;
         \\}
     , &[_][]const u8{
         "tmp.zig:8:29: error: field 'b' has index 1 but pointer value is index 0 of struct 'Foo'",
     });
-    cases.add("@offsetOf - non struct",
+    ctx.objErrStage1("@offsetOf - non struct",
         \\const Foo = i32;
         \\export fn foo() usize {
         \\    return @offsetOf(Foo, "a",);
 @@ -6686,7 +6932,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         "tmp.zig:3:22: error: expected struct type, found 'i32'",
     });
-    cases.add("@offsetOf - bad field name",
+    ctx.objErrStage1("@offsetOf - bad field name",
         \\const Foo = struct {
         \\    derp: i32,
         \\};
 @@ -6697,20 +6943,20 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         "tmp.zig:5:27: error: struct 'Foo' has no field 'a'",
     });
-    cases.addExe("missing main fn in executable",
+    ctx.exeErrStage1("missing main fn in executable",
         \\
     , &[_][]const u8{
         "error: root source file has no member called 'main'",
     });
-    cases.addExe("private main fn",
+    ctx.exeErrStage1("private main fn",
         \\fn main() void {}
     , &[_][]const u8{
         "error: 'main' is private",
         "tmp.zig:1:1: note: declared here",
     });
-    cases.add("setting a section on a local variable",
+    ctx.objErrStage1("setting a section on a local variable",
         \\export fn entry() i32 {
         \\    var foo: i32 linksection(".text2") = 1234;
         \\    return foo;
 @@ -6719,7 +6965,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         "tmp.zig:2:30: error: cannot set section of local variable 'foo'",
     });
-    cases.add("inner struct member shadowing outer struct member",
+    ctx.objErrStage1("inner struct member shadowing outer struct member",
         \\fn A() type {
         \\    return struct {
         \\        b: B(),
 @@ -6741,10 +6987,10 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         \\}
     , &[_][]const u8{
         "tmp.zig:9:17: error: redefinition of 'Self'",
-        "tmp.zig:5:9: note: previous definition is here",
+        "tmp.zig:5:9: note: previous definition here",
     });
-    cases.add("while expected bool, got optional",
+    ctx.objErrStage1("while expected bool, got optional",
         \\export fn foo() void {
         \\    while (bar()) {}
         \\}
 @@ -6753,7 +6999,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         "tmp.zig:2:15: error: expected type 'bool', found '?i32'",
     });
-    cases.add("while expected bool, got error union",
+    ctx.objErrStage1("while expected bool, got error union",
         \\export fn foo() void {
         \\    while (bar()) {}
         \\}
 @@ -6762,36 +7008,36 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         "tmp.zig:2:15: error: expected type 'bool', found 'anyerror!i32'",
     });
-    cases.add("while expected optional, got bool",
+    ctx.objErrStage1("while expected optional, got bool",
         \\export fn foo() void {
-        \\    while (bar()) |x| {}
+        \\    while (bar()) |x| {_ = x;}
         \\}
         \\fn bar() bool { return true; }
     , &[_][]const u8{
         "tmp.zig:2:15: error: expected optional type, found 'bool'",
     });
-    cases.add("while expected optional, got error union",
+    ctx.objErrStage1("while expected optional, got error union",
         \\export fn foo() void {
-        \\    while (bar()) |x| {}
+        \\    while (bar()) |x| {_ = x;}
         \\}
         \\fn bar() anyerror!i32 { return 1; }
     , &[_][]const u8{
         "tmp.zig:2:15: error: expected optional type, found 'anyerror!i32'",
     });
-    cases.add("while expected error union, got bool",
+    ctx.objErrStage1("while expected error union, got bool",
         \\export fn foo() void {
-        \\    while (bar()) |x| {} else |err| {}
+        \\    while (bar()) |x| {_ = x;} else |err| {_ = err;}
         \\}
         \\fn bar() bool { return true; }
     , &[_][]const u8{
         "tmp.zig:2:15: error: expected error union type, found 'bool'",
     });
-    cases.add("while expected error union, got optional",
+    ctx.objErrStage1("while expected error union, got optional",
         \\export fn foo() void {
-        \\    while (bar()) |x| {} else |err| {}
+        \\    while (bar()) |x| {_ = x;} else |err| {_ = err;}
         \\}
         \\fn bar() ?i32 { return 1; }
     , &[_][]const u8{
 @@ -6799,7 +7045,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
     });
     // TODO test this in stage2, but we won't even try in stage1
-    //cases.add("inline fn calls itself indirectly",
+    //ctx.objErrStage1("inline fn calls itself indirectly",
     //    \\export fn foo() void {
     //    \\    bar();
     //    \\}
 @@ -6816,7 +7062,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
     //    "tmp.zig:4:1: error: unable to inline function",
     //});
-    //cases.add("save reference to inline function",
+    //ctx.objErrStage1("save reference to inline function",
     //    \\export fn foo() void {
     //    \\    quux(@ptrToInt(bar));
     //    \\}
 @@ -6826,7 +7072,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
     //    "tmp.zig:4:1: error: unable to inline function",
     //});
-    cases.add("signed integer division",
+    ctx.objErrStage1("signed integer division",
         \\export fn foo(a: i32, b: i32) i32 {
         \\    return a / b;
         \\}
 @@ -6834,7 +7080,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         "tmp.zig:2:14: error: division with 'i32' and 'i32': signed integers must use @divTrunc, @divFloor, or @divExact",
     });
-    cases.add("signed integer remainder division",
+    ctx.objErrStage1("signed integer remainder division",
         \\export fn foo(a: i32, b: i32) i32 {
         \\    return a % b;
         \\}
 @@ -6842,27 +7088,29 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         "tmp.zig:2:14: error: remainder division with 'i32' and 'i32': signed integers and floats must use @rem or @mod",
     });
-    cases.add("compile-time division by zero",
+    ctx.objErrStage1("compile-time division by zero",
         \\comptime {
         \\    const a: i32 = 1;
         \\    const b: i32 = 0;
         \\    const c = a / b;
+        \\    _ = c;
         \\}
     , &[_][]const u8{
         "tmp.zig:4:17: error: division by zero",
     });
-    cases.add("compile-time remainder division by zero",
+    ctx.objErrStage1("compile-time remainder division by zero",
         \\comptime {
         \\    const a: i32 = 1;
         \\    const b: i32 = 0;
         \\    const c = a % b;
+        \\    _ = c;
         \\}
     , &[_][]const u8{
         "tmp.zig:4:17: error: division by zero",
     });
-    cases.add("@setRuntimeSafety twice for same scope",
+    ctx.objErrStage1("@setRuntimeSafety twice for same scope",
         \\export fn foo() void {
         \\    @setRuntimeSafety(false);
         \\    @setRuntimeSafety(false);
 @@ -6872,7 +7120,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         "tmp.zig:2:5: note: first set here",
     });
-    cases.add("@setFloatMode twice for same scope",
+    ctx.objErrStage1("@setFloatMode twice for same scope",
         \\export fn foo() void {
         \\    @setFloatMode(@import("std").builtin.FloatMode.Optimized);
         \\    @setFloatMode(@import("std").builtin.FloatMode.Optimized);
 @@ -6882,15 +7130,16 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         "tmp.zig:2:5: note: first set here",
     });
-    cases.add("array access of type",
+    ctx.objErrStage1("array access of type",
         \\export fn foo() void {
         \\    var b: u8[40] = undefined;
+        \\    _ = b;
         \\}
     , &[_][]const u8{
         "tmp.zig:2:14: error: array access of non-array type 'type'",
     });
-    cases.add("cannot break out of defer expression",
+    ctx.objErrStage1("cannot break out of defer expression",
         \\export fn foo() void {
         \\    while (true) {
         \\        defer {
 @@ -6902,7 +7151,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         "tmp.zig:4:13: error: cannot break out of defer expression",
     });
-    cases.add("cannot continue out of defer expression",
+    ctx.objErrStage1("cannot continue out of defer expression",
         \\export fn foo() void {
         \\    while (true) {
         \\        defer {
 @@ -6914,11 +7163,11 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         "tmp.zig:4:13: error: cannot continue out of defer expression",
     });
-    cases.add("calling a generic function only known at runtime",
+    ctx.objErrStage1("calling a generic function only known at runtime",
         \\var foos = [_]fn(anytype) void { foo1, foo2 };
         \\
-        \\fn foo1(arg: anytype) void {}
+        \\fn foo1(arg: anytype) void {_ = arg;}
-        \\fn foo2(arg: anytype) void {}
+        \\fn foo2(arg: anytype) void {_ = arg;}
         \\
         \\pub fn main() !void {
         \\    foos[0](true);
 @@ -6927,7 +7176,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         "tmp.zig:7:9: error: calling a generic function requires compile-time known function value",
     });
-    cases.add("@compileError shows traceback of references that caused it",
+    ctx.objErrStage1("@compileError shows traceback of references that caused it",
         \\const foo = @compileError("aoeu",);
         \\
         \\const bar = baz + foo;
 @@ -6942,23 +7191,25 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         "tmp.zig:7:12: note: referenced here",
     });
-    cases.add("float literal too large error",
+    ctx.objErrStage1("float literal too large error",
         \\comptime {
         \\    const a = 0x1.0p18495;
+        \\    _ = a;
         \\}
     , &[_][]const u8{
         "tmp.zig:2:15: error: float literal out of range of any type",
     });
-    cases.add("float literal too small error (denormal)",
+    ctx.objErrStage1("float literal too small error (denormal)",
         \\comptime {
         \\    const a = 0x1.0p-19000;
+        \\    _ = a;
         \\}
     , &[_][]const u8{
         "tmp.zig:2:15: error: float literal out of range of any type",
     });
-    cases.add("explicit cast float literal to integer when there is a fraction component",
+    ctx.objErrStage1("explicit cast float literal to integer when there is a fraction component",
         \\export fn entry() i32 {
         \\    return @as(i32, 12.34);
         \\}
 @@ -6966,7 +7217,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         "tmp.zig:2:21: error: fractional component prevents float value 12.340000 from being casted to type 'i32'",
     });
-    cases.add("non pointer given to @ptrToInt",
+    ctx.objErrStage1("non pointer given to @ptrToInt",
         \\export fn entry(x: i32) usize {
         \\    return @ptrToInt(x);
         \\}
 @@ -6974,23 +7225,25 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         "tmp.zig:2:22: error: expected pointer, found 'i32'",
     });
-    cases.add("@shlExact shifts out 1 bits",
+    ctx.objErrStage1("@shlExact shifts out 1 bits",
         \\comptime {
         \\    const x = @shlExact(@as(u8, 0b01010101), 2);
+        \\    _ = x;
         \\}
     , &[_][]const u8{
         "tmp.zig:2:15: error: operation caused overflow",
     });
-    cases.add("@shrExact shifts out 1 bits",
+    ctx.objErrStage1("@shrExact shifts out 1 bits",
         \\comptime {
         \\    const x = @shrExact(@as(u8, 0b10101010), 2);
+        \\    _ = x;
         \\}
     , &[_][]const u8{
         "tmp.zig:2:15: error: exact shift shifted out 1 bits",
     });
-    cases.add("shifting without int type or comptime known",
+    ctx.objErrStage1("shifting without int type or comptime known",
         \\export fn entry(x: u8) u8 {
         \\    return 0x11 << x;
         \\}
 @@ -6998,7 +7251,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         "tmp.zig:2:17: error: LHS of shift must be a fixed-width integer type, or RHS must be compile-time known",
     });
-    cases.add("shifting RHS is log2 of LHS int bit width",
+    ctx.objErrStage1("shifting RHS is log2 of LHS int bit width",
         \\export fn entry(x: u8, y: u8) u8 {
         \\    return x << y;
         \\}
 @@ -7006,16 +7259,17 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         "tmp.zig:2:17: error: expected type 'u3', found 'u8'",
     });
-    cases.add("globally shadowing a primitive type",
+    ctx.objErrStage1("globally shadowing a primitive type",
         \\const u16 = u8;
         \\export fn entry() void {
         \\    const a: u16 = 300;
+        \\    _ = a;
         \\}
     , &[_][]const u8{
         "tmp.zig:1:1: error: declaration shadows primitive type 'u16'",
     });
-    cases.add("implicitly increasing pointer alignment",
+    ctx.objErrStage1("implicitly increasing pointer alignment",
         \\const Foo = packed struct {
         \\    a: u8,
         \\    b: u32,
 @@ -7033,7 +7287,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         "tmp.zig:8:13: error: expected type '*u32', found '*align(1) u32'",
     });
-    cases.add("implicitly increasing slice alignment",
+    ctx.objErrStage1("implicitly increasing slice alignment",
         \\const Foo = packed struct {
         \\    a: u8,
         \\    b: u32,
 @@ -7054,7 +7308,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         "tmp.zig:9:26: note: '*[1]u32' has alignment 4",
     });
-    cases.add("increase pointer alignment in @ptrCast",
+    ctx.objErrStage1("increase pointer alignment in @ptrCast",
         \\export fn entry() u32 {
         \\    var bytes: [4]u8 = [_]u8{0x01, 0x02, 0x03, 0x04};
         \\    const ptr = @ptrCast(*u32, &bytes[0]);
 @@ -7066,7 +7320,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         "tmp.zig:3:26: note: '*u32' has alignment 4",
     });
-    cases.add("@alignCast expects pointer or slice",
+    ctx.objErrStage1("@alignCast expects pointer or slice",
         \\export fn entry() void {
         \\    @alignCast(4, @as(u32, 3));
         \\}
 @@ -7074,7 +7328,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         "tmp.zig:2:19: error: expected pointer or slice, found 'u32'",
     });
-    cases.add("passing an under-aligned function pointer",
+    ctx.objErrStage1("passing an under-aligned function pointer",
         \\export fn entry() void {
         \\    testImplicitlyDecreaseFnAlign(alignedSmall, 1234);
         \\}
 @@ -7086,7 +7340,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         "tmp.zig:2:35: error: expected type 'fn() align(8) i32', found 'fn() align(4) i32'",
     });
-    cases.add("passing a not-aligned-enough pointer to cmpxchg",
+    ctx.objErrStage1("passing a not-aligned-enough pointer to cmpxchg",
         \\const AtomicOrder = @import("std").builtin.AtomicOrder;
         \\export fn entry() bool {
         \\    var x: i32 align(1) = 1234;
 @@ -7097,15 +7351,16 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         "tmp.zig:4:32: error: expected type '*i32', found '*align(1) i32'",
     });
-    cases.add("wrong size to an array literal",
+    ctx.objErrStage1("wrong size to an array literal",
         \\comptime {
         \\    const array = [2]u8{1, 2, 3};
+        \\    _ = array;
         \\}
     , &[_][]const u8{
         "tmp.zig:2:31: error: index 2 outside array of size 2",
     });
-    cases.add("wrong pointer coerced to pointer to opaque {}",
+    ctx.objErrStage1("wrong pointer coerced to pointer to opaque {}",
         \\const Derp = opaque {};
         \\extern fn bar(d: *Derp) void;
         \\export fn foo() void {
 @@ -7116,53 +7371,66 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         "tmp.zig:5:9: error: expected type '*Derp', found '*c_void'",
     });
-    cases.add("non-const variables of things that require const variables",
+    ctx.objErrStage1("non-const variables of things that require const variables",
         \\export fn entry1() void {
         \\   var m2 = &2;
+        \\   _ = m2;
         \\}
         \\export fn entry2() void {
         \\   var a = undefined;
+        \\   _ = a;
         \\}
         \\export fn entry3() void {
         \\   var b = 1;
+        \\   _ = b;
         \\}
         \\export fn entry4() void {
         \\   var c = 1.0;
+        \\   _ = c;
         \\}
         \\export fn entry5() void {
         \\   var d = null;
+        \\   _ = d;
         \\}
         \\export fn entry6(opaque_: *Opaque) void {
         \\   var e = opaque_.*;
+        \\   _ = e;
         \\}
         \\export fn entry7() void {
         \\   var f = i32;
+        \\   _ = f;
         \\}
         \\export fn entry8() void {
         \\   var h = (Foo {}).bar;
-        \\}
+        \\   _ = h;
-        \\export fn entry9() void {
-        \\   var z: noreturn = return;
         \\}
         \\const Opaque = opaque {};
         \\const Foo = struct {
-        \\    fn bar(self: *const Foo) void {}
+        \\    fn bar(self: *const Foo) void {_ = self;}
         \\};
     , &[_][]const u8{
         "tmp.zig:2:4: error: variable of type '*const comptime_int' must be const or comptime",
-        "tmp.zig:5:4: error: variable of type '(undefined)' must be const or comptime",
+        "tmp.zig:6:4: error: variable of type '(undefined)' must be const or comptime",
-        "tmp.zig:8:4: error: variable of type 'comptime_int' must be const or comptime",
+        "tmp.zig:10:4: error: variable of type 'comptime_int' must be const or comptime",
-        "tmp.zig:8:4: note: to modify this variable at runtime, it must be given an explicit fixed-size number type",
+        "tmp.zig:10:4: note: to modify this variable at runtime, it must be given an explicit fixed-size number type",
-        "tmp.zig:11:4: error: variable of type 'comptime_float' must be const or comptime",
+        "tmp.zig:14:4: error: variable of type 'comptime_float' must be const or comptime",
-        "tmp.zig:11:4: note: to modify this variable at runtime, it must be given an explicit fixed-size number type",
+        "tmp.zig:14:4: note: to modify this variable at runtime, it must be given an explicit fixed-size number type",
-        "tmp.zig:14:4: error: variable of type '(null)' must be const or comptime",
+        "tmp.zig:18:4: error: variable of type '(null)' must be const or comptime",
-        "tmp.zig:17:4: error: variable of type 'Opaque' not allowed",
+        "tmp.zig:22:4: error: variable of type 'Opaque' not allowed",
-        "tmp.zig:20:4: error: variable of type 'type' must be const or comptime",
+        "tmp.zig:26:4: error: variable of type 'type' must be const or comptime",
-        "tmp.zig:23:4: error: variable of type '(bound fn(*const Foo) void)' must be const or comptime",
+        "tmp.zig:30:4: error: variable of type '(bound fn(*const Foo) void)' must be const or comptime",
-        "tmp.zig:26:22: error: unreachable code",
+    });
+    ctx.objErrStage1("variable with type 'noreturn'",
+        \\export fn entry9() void {
+        \\    var z: noreturn = return;
+        \\}
+    , &[_][]const u8{
+        "tmp.zig:2:5: error: unreachable code",
+        "tmp.zig:2:23: note: control flow is diverted here",
     });
-    cases.add("wrong types given to atomic order args in cmpxchg",
+    ctx.objErrStage1("wrong types given to atomic order args in cmpxchg",
         \\export fn entry() void {
         \\    var x: i32 = 1234;
         \\    while (!@cmpxchgWeak(i32, &x, 1234, 5678, @as(u32, 1234), @as(u32, 1234))) {}
 @@ -7171,7 +7439,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         "tmp.zig:3:47: error: expected type 'std.builtin.AtomicOrder', found 'u32'",
     });
-    cases.add("wrong types given to @export",
+    ctx.objErrStage1("wrong types given to @export",
         \\fn entry() callconv(.C) void { }
         \\comptime {
         \\    @export(entry, .{.name = "entry", .linkage = @as(u32, 1234) });
 @@ -7180,7 +7448,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         "tmp.zig:3:59: error: expected type 'std.builtin.GlobalLinkage', found 'comptime_int'",
     });
-    cases.add("struct with invalid field",
+    ctx.objErrStage1("struct with invalid field",
         \\const std = @import("std",);
         \\const Allocator = std.mem.Allocator;
         \\const ArrayList = std.ArrayList;
 @@ -7203,12 +7471,13 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         \\        .text = MdText.init(&std.testing.allocator),
         \\        .weight = HeaderWeight.H1,
         \\    };
+        \\    _ = a;
         \\}
     , &[_][]const u8{
         "tmp.zig:14:17: error: use of undeclared identifier 'HeaderValue'",
     });
-    cases.add("@setAlignStack outside function",
+    ctx.objErrStage1("@setAlignStack outside function",
         \\comptime {
         \\    @setAlignStack(16);
         \\}
 @@ -7216,7 +7485,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         "tmp.zig:2:5: error: @setAlignStack outside function",
     });
-    cases.add("@setAlignStack in naked function",
+    ctx.objErrStage1("@setAlignStack in naked function",
         \\export fn entry() callconv(.Naked) void {
         \\    @setAlignStack(16);
         \\}
 @@ -7224,7 +7493,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         "tmp.zig:2:5: error: @setAlignStack in naked function",
     });
-    cases.add("@setAlignStack in inline function",
+    ctx.objErrStage1("@setAlignStack in inline function",
         \\export fn entry() void {
         \\    foo();
         \\}
 @@ -7235,7 +7504,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         "tmp.zig:5:5: error: @setAlignStack in inline function",
     });
-    cases.add("@setAlignStack set twice",
+    ctx.objErrStage1("@setAlignStack set twice",
         \\export fn entry() void {
         \\    @setAlignStack(16);
         \\    @setAlignStack(16);
 @@ -7245,7 +7514,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         "tmp.zig:2:5: note: first set here",
     });
-    cases.add("@setAlignStack too big",
+    ctx.objErrStage1("@setAlignStack too big",
         \\export fn entry() void {
         \\    @setAlignStack(511 + 1);
         \\}
 @@ -7253,7 +7522,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         "tmp.zig:2:5: error: attempt to @setAlignStack(512); maximum is 256",
     });
-    cases.add("storing runtime value in compile time variable then using it",
+    ctx.objErrStage1("storing runtime value in compile time variable then using it",
         \\const Mode = @import("std").builtin.Mode;
         \\
         \\fn Free(comptime filename: []const u8) TestCase {
 @@ -7290,24 +7559,27 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         \\    };
         \\
         \\    for ([_]Mode { Mode.Debug, Mode.ReleaseSafe, Mode.ReleaseFast }) |mode| {
+        \\        _ = mode;
         \\        inline for (tests) |test_case| {
         \\            const foo = test_case.filename ++ ".zig";
+        \\            _ = foo;
         \\        }
         \\    }
         \\}
     , &[_][]const u8{
-        "tmp.zig:37:29: error: cannot store runtime value in compile time variable",
+        "tmp.zig:38:29: error: cannot store runtime value in compile time variable",
     });
-    cases.add("invalid legacy unicode escape",
+    ctx.objErrStage1("invalid legacy unicode escape",
         \\export fn entry() void {
         \\    const a = '\U1234';
         \\}
     , &[_][]const u8{
-        "tmp.zig:2:17: error: invalid character: 'U'",
+        "tmp.zig:2:15: error: expected expression, found 'invalid'",
+        "tmp.zig:2:18: note: invalid byte: '1'",
     });
-    cases.add("invalid empty unicode escape",
+    ctx.objErrStage1("invalid empty unicode escape",
         \\export fn entry() void {
         \\    const a = '\u{}';
         \\}
 @@ -7315,21 +7587,21 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         "tmp.zig:2:19: error: empty unicode escape sequence",
     });
-    cases.add("non-printable invalid character", "\xff\xfe" ++
+    ctx.objErrStage1("non-printable invalid character", "\xff\xfe" ++
-        \\fn test() bool {\r
+        "fn foo() bool {\r\n" ++
-        \\    true\r
+        "    return true;\r\n" ++
-        \\}
+        "}\r\n", &[_][]const u8{
-    , &[_][]const u8{
+        "tmp.zig:1:1: error: expected test, comptime, var decl, or container field, found 'invalid'",
-        "tmp.zig:1:1: error: invalid character: '\\xff'",
+        "tmp.zig:1:1: note: invalid byte: '\\xff'",
     });
-    cases.add("non-printable invalid character with escape alternative", "fn test() bool {\n" ++
+    ctx.objErrStage1("non-printable invalid character with escape alternative", "fn foo() bool {\n" ++
-        "\ttrue\n" ++
+        "\treturn true;\n" ++
         "}\n", &[_][]const u8{
         "tmp.zig:2:1: error: invalid character: '\\t'",
     });
-    cases.add("calling var args extern function, passing array instead of pointer",
+    ctx.objErrStage1("calling var args extern function, passing array instead of pointer",
         \\export fn entry() void {
         \\    foo("hello".*,);
         \\}
 @@ -7338,7 +7610,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         "tmp.zig:2:16: error: expected type '*const u8', found '[5:0]u8'",
     });
-    cases.add("constant inside comptime function has compile error",
+    ctx.objErrStage1("constant inside comptime function has compile error",
         \\const ContextAllocator = MemoryPool(usize);
         \\
         \\pub fn MemoryPool(comptime T: type) type {
 @@ -7353,12 +7625,12 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         \\    var allocator: ContextAllocator = undefined;
         \\}
     , &[_][]const u8{
-        "tmp.zig:4:25: error: aoeu",
+        "tmp.zig:4:5: error: unreachable code",
-        "tmp.zig:1:36: note: referenced here",
+        "tmp.zig:4:25: note: control flow is diverted here",
-        "tmp.zig:12:20: note: referenced here",
+        "tmp.zig:12:9: error: unused local variable",
     });
-    cases.add("specify enum tag type that is too small",
+    ctx.objErrStage1("specify enum tag type that is too small",
         \\const Small = enum (u2) {
         \\    One,
         \\    Two,
 @@ -7369,12 +7641,13 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         \\
         \\export fn entry() void {
         \\    var x = Small.One;
+        \\    _ = x;
         \\}
     , &[_][]const u8{
         "tmp.zig:6:5: error: enumeration value 4 too large for type 'u2'",
     });
-    cases.add("specify non-integer enum tag type",
+    ctx.objErrStage1("specify non-integer enum tag type",
         \\const Small = enum (f32) {
         \\    One,
         \\    Two,
 @@ -7383,12 +7656,13 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         \\
         \\export fn entry() void {
         \\    var x = Small.One;
+        \\    _ = x;
         \\}
     , &[_][]const u8{
         "tmp.zig:1:21: error: expected integer, found 'f32'",
     });
-    cases.add("implicitly casting enum to tag type",
+    ctx.objErrStage1("implicitly casting enum to tag type",
         \\const Small = enum(u2) {
         \\    One,
         \\    Two,
 @@ -7398,12 +7672,13 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         \\
         \\export fn entry() void {
         \\    var x: u2 = Small.Two;
+        \\    _ = x;
         \\}
     , &[_][]const u8{
         "tmp.zig:9:22: error: expected type 'u2', found 'Small'",
     });
-    cases.add("explicitly casting non tag type to enum",
+    ctx.objErrStage1("explicitly casting non tag type to enum",
         \\const Small = enum(u2) {
         \\    One,
         \\    Two,
 @@ -7414,42 +7689,38 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         \\export fn entry() void {
         \\    var y = @as(u3, 3);
         \\    var x = @intToEnum(Small, y);
+        \\    _ = x;
         \\}
     , &[_][]const u8{
         "tmp.zig:10:31: error: expected type 'u2', found 'u3'",
     });
-    cases.add("union fields with value assignments",
+    ctx.objErrStage1("union fields with value assignments",
         \\const MultipleChoice = union {
         \\    A: i32 = 20,
         \\};
         \\export fn entry() void {
         \\    var x: MultipleChoice = undefined;
+        \\    _ = x;
         \\}
     , &[_][]const u8{
-        "tmp.zig:2:14: error: untagged union field assignment",
+        "tmp.zig:1:24: error: explicitly valued tagged union missing integer tag type",
-        "tmp.zig:1:24: note: consider 'union(enum)' here",
+        "tmp.zig:2:14: note: tag value specified here",
     });
-    cases.add("enum with 0 fields",
+    ctx.objErrStage1("enum with 0 fields",
         \\const Foo = enum {};
-        \\export fn entry() usize {
-        \\    return @sizeOf(Foo);
-        \\}
     , &[_][]const u8{
-        "tmp.zig:1:13: error: enums must have 1 or more fields",
+        "tmp.zig:1:13: error: enum declarations must have at least one tag",
     });
-    cases.add("union with 0 fields",
+    ctx.objErrStage1("union with 0 fields",
         \\const Foo = union {};
-        \\export fn entry() usize {
-        \\    return @sizeOf(Foo);
-        \\}
     , &[_][]const u8{
-        "tmp.zig:1:13: error: unions must have 1 or more fields",
+        "tmp.zig:1:13: error: union declarations must have at least one tag",
     });
-    cases.add("enum value already taken",
+    ctx.objErrStage1("enum value already taken",
         \\const MultipleChoice = enum(u32) {
         \\    A = 20,
         \\    B = 40,
 @@ -7459,13 +7730,14 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         \\};
         \\export fn entry() void {
         \\    var x = MultipleChoice.C;
+        \\    _ = x;
         \\}
     , &[_][]const u8{
         "tmp.zig:6:5: error: enum tag value 60 already taken",
         "tmp.zig:4:5: note: other occurrence here",
     });
-    cases.add("union with specified enum omits field",
+    ctx.objErrStage1("union with specified enum omits field",
         \\const Letter = enum {
         \\    A,
         \\    B,
 @@ -7483,29 +7755,31 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         "tmp.zig:4:5: note: declared here",
     });
-    cases.add("non-integer tag type to automatic union enum",
+    ctx.objErrStage1("non-integer tag type to automatic union enum",
         \\const Foo = union(enum(f32)) {
         \\    A: i32,
         \\};
         \\export fn entry() void {
         \\    const x = @typeInfo(Foo).Union.tag_type.?;
+        \\    _ = x;
         \\}
     , &[_][]const u8{
         "tmp.zig:1:24: error: expected integer tag type, found 'f32'",
     });
-    cases.add("non-enum tag type passed to union",
+    ctx.objErrStage1("non-enum tag type passed to union",
         \\const Foo = union(u32) {
         \\    A: i32,
         \\};
         \\export fn entry() void {
         \\    const x = @typeInfo(Foo).Union.tag_type.?;
+        \\    _ = x;
         \\}
     , &[_][]const u8{
         "tmp.zig:1:19: error: expected enum tag type, found 'u32'",
     });
-    cases.add("union auto-enum value already taken",
+    ctx.objErrStage1("union auto-enum value already taken",
         \\const MultipleChoice = union(enum(u32)) {
         \\    A = 20,
         \\    B = 40,
 @@ -7515,13 +7789,14 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         \\};
         \\export fn entry() void {
         \\    var x = MultipleChoice { .C = {} };
+        \\    _ = x;
         \\}
     , &[_][]const u8{
         "tmp.zig:6:9: error: enum tag value 60 already taken",
         "tmp.zig:4:9: note: other occurrence here",
     });
-    cases.add("union enum field does not match enum",
+    ctx.objErrStage1("union enum field does not match enum",
         \\const Letter = enum {
         \\    A,
         \\    B,
 @@ -7535,49 +7810,49 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         \\};
         \\export fn entry() void {
         \\    var a = Payload {.A = 1234};
+        \\    _ = a;
         \\}
     , &[_][]const u8{
         "tmp.zig:10:5: error: enum field not found: 'D'",
         "tmp.zig:1:16: note: enum declared here",
     });
-    cases.add("field type supplied in an enum",
+    ctx.objErrStage1("field type supplied in an enum",
         \\const Letter = enum {
         \\    A: void,
         \\    B,
         \\    C,
         \\};
-        \\export fn entry() void {
-        \\    var b = Letter.B;
-        \\}
     , &[_][]const u8{
-        "tmp.zig:2:8: error: structs and unions, not enums, support field types",
+        "tmp.zig:2:8: error: enum fields do not have types",
-        "tmp.zig:1:16: note: consider 'union(enum)' here",
+        "tmp.zig:1:16: note: consider 'union(enum)' here to make it a tagged union",
     });
-    cases.add("struct field missing type",
+    ctx.objErrStage1("struct field missing type",
         \\const Letter = struct {
         \\    A,
         \\};
         \\export fn entry() void {
         \\    var a = Letter { .A = {} };
+        \\    _ = a;
         \\}
     , &[_][]const u8{
         "tmp.zig:2:5: error: struct field missing type",
     });
-    cases.add("extern union field missing type",
+    ctx.objErrStage1("extern union field missing type",
         \\const Letter = extern union {
         \\    A,
         \\};
         \\export fn entry() void {
         \\    var a = Letter { .A = {} };
+        \\    _ = a;
         \\}
     , &[_][]const u8{
         "tmp.zig:2:5: error: union field missing type",
     });
-    cases.add("extern union given enum tag type",
+    ctx.objErrStage1("extern union given enum tag type",
         \\const Letter = enum {
         \\    A,
         \\    B,
 @@ -7590,12 +7865,13 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         \\};
         \\export fn entry() void {
         \\    var a = Payload { .A = 1234 };
+        \\    _ = a;
         \\}
     , &[_][]const u8{
         "tmp.zig:6:30: error: extern union does not support enum tag type",
     });
-    cases.add("packed union given enum tag type",
+    ctx.objErrStage1("packed union given enum tag type",
         \\const Letter = enum {
         \\    A,
         \\    B,
 @@ -7608,12 +7884,13 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         \\};
         \\export fn entry() void {
         \\    var a = Payload { .A = 1234 };
+        \\    _ = a;
         \\}
     , &[_][]const u8{
         "tmp.zig:6:30: error: packed union does not support enum tag type",
     });
-    cases.add("packed union with automatic layout field",
+    ctx.objErrStage1("packed union with automatic layout field",
         \\const Foo = struct {
         \\    a: u32,
         \\    b: f32,
 @@ -7624,12 +7901,13 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         \\};
         \\export fn entry() void {
         \\    var a = Payload { .B = true };
+        \\    _ = a;
         \\}
     , &[_][]const u8{
         "tmp.zig:6:5: error: non-packed, non-extern struct 'Foo' not allowed in packed union; no guaranteed in-memory representation",
     });
-    cases.add("switch on union with no attached enum",
+    ctx.objErrStage1("switch on union with no attached enum",
         \\const Payload = union {
         \\    A: i32,
         \\    B: f64,
 @@ -7650,20 +7928,21 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         "tmp.zig:1:17: note: consider 'union(enum)' here",
     });
-    cases.add("enum in field count range but not matching tag",
+    ctx.objErrStage1("enum in field count range but not matching tag",
         \\const Foo = enum(u32) {
         \\    A = 10,
         \\    B = 11,
         \\};
         \\export fn entry() void {
         \\    var x = @intToEnum(Foo, 0);
+        \\    _ = x;
         \\}
     , &[_][]const u8{
         "tmp.zig:6:13: error: enum 'Foo' has no tag matching integer value 0",
         "tmp.zig:1:13: note: 'Foo' declared here",
     });
-    cases.add("comptime cast enum to union but field has payload",
+    ctx.objErrStage1("comptime cast enum to union but field has payload",
         \\const Letter = enum { A, B, C };
         \\const Value = union(Letter) {
         \\    A: i32,
 @@ -7672,13 +7951,14 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         \\};
         \\export fn entry() void {
         \\    var x: Value = Letter.A;
+        \\    _ = x;
         \\}
     , &[_][]const u8{
         "tmp.zig:8:26: error: cast to union 'Value' must initialize 'i32' field 'A'",
         "tmp.zig:3:5: note: field 'A' declared here",
     });
-    cases.add("runtime cast to union which has non-void fields",
+    ctx.objErrStage1("runtime cast to union which has non-void fields",
         \\const Letter = enum { A, B, C };
         \\const Value = union(Letter) {
         \\    A: i32,
 @@ -7690,35 +7970,38 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         \\}
         \\fn foo(l: Letter) void {
         \\    var x: Value = l;
+        \\    _ = x;
         \\}
     , &[_][]const u8{
         "tmp.zig:11:20: error: runtime cast to union 'Value' which has non-void fields",
         "tmp.zig:3:5: note: field 'A' has type 'i32'",
     });
-    cases.add("taking byte offset of void field in struct",
+    ctx.objErrStage1("taking byte offset of void field in struct",
         \\const Empty = struct {
         \\    val: void,
         \\};
         \\export fn foo() void {
         \\    const fieldOffset = @offsetOf(Empty, "val",);
+        \\    _ = fieldOffset;
         \\}
     , &[_][]const u8{
         "tmp.zig:5:42: error: zero-bit field 'val' in struct 'Empty' has no offset",
     });
-    cases.add("taking bit offset of void field in struct",
+    ctx.objErrStage1("taking bit offset of void field in struct",
         \\const Empty = struct {
         \\    val: void,
         \\};
         \\export fn foo() void {
         \\    const fieldOffset = @bitOffsetOf(Empty, "val",);
+        \\    _ = fieldOffset;
         \\}
     , &[_][]const u8{
         "tmp.zig:5:45: error: zero-bit field 'val' in struct 'Empty' has no offset",
     });
-    cases.add("invalid union field access in comptime",
+    ctx.objErrStage1("invalid union field access in comptime",
         \\const Foo = union {
         \\    Bar: u8,
         \\    Baz: void,
 @@ -7726,12 +8009,13 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         \\comptime {
         \\    var foo = Foo {.Baz = {}};
         \\    const bar_val = foo.Bar;
+        \\    _ = bar_val;
         \\}
     , &[_][]const u8{
         "tmp.zig:7:24: error: accessing union field 'Bar' while field 'Baz' is set",
     });
-    cases.add("unsupported modifier at start of asm output constraint",
+    ctx.objErrStage1("unsupported modifier at start of asm output constraint",
         \\export fn foo() void {
         \\    var bar: u32 = 3;
         \\    asm volatile ("" : [baz]"+r"(bar) : : "");
 @@ -7740,7 +8024,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         "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",
     });
-    cases.add("comptime_int in asm input",
+    ctx.objErrStage1("comptime_int in asm input",
         \\export fn foo() void {
         \\    asm volatile ("" : : [bar]"r"(3) : "");
         \\}
 @@ -7748,7 +8032,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         "tmp.zig:2:35: error: expected sized integer or sized float, found comptime_int",
     });
-    cases.add("comptime_float in asm input",
+    ctx.objErrStage1("comptime_float in asm input",
         \\export fn foo() void {
         \\    asm volatile ("" : : [bar]"r"(3.17) : "");
         \\}
 @@ -7756,7 +8040,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         "tmp.zig:2:35: error: expected sized integer or sized float, found comptime_float",
     });
-    cases.add("runtime assignment to comptime struct type",
+    ctx.objErrStage1("runtime assignment to comptime struct type",
         \\const Foo = struct {
         \\    Bar: u8,
         \\    Baz: type,
 @@ -7764,12 +8048,13 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         \\export fn f() void {
         \\    var x: u8 = 0;
         \\    const foo = Foo { .Bar = x, .Baz = u8 };
+        \\    _ = foo;
         \\}
     , &[_][]const u8{
         "tmp.zig:7:23: error: unable to evaluate constant expression",
     });
-    cases.add("runtime assignment to comptime union type",
+    ctx.objErrStage1("runtime assignment to comptime union type",
         \\const Foo = union {
         \\    Bar: u8,
         \\    Baz: type,
 @@ -7777,16 +8062,18 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         \\export fn f() void {
         \\    var x: u8 = 0;
         \\    const foo = Foo { .Bar = x };
+        \\    _ = foo;
         \\}
     , &[_][]const u8{
         "tmp.zig:7:23: error: unable to evaluate constant expression",
     });
-    cases.addTest("@shuffle with selected index past first vector length",
+    ctx.testErrStage1("@shuffle with selected index past first vector length",
         \\export fn entry() void {
         \\    const v: @import("std").meta.Vector(4, u32) = [4]u32{ 10, 11, 12, 13 };
         \\    const x: @import("std").meta.Vector(4, u32) = [4]u32{ 14, 15, 16, 17 };
         \\    var z = @shuffle(u32, v, x, [8]i32{ 0, 1, 2, 3, 7, 6, 5, 4 });
+        \\    _ = z;
         \\}
     , &[_][]const u8{
         "tmp.zig:4:39: error: mask index '4' has out-of-bounds selection",
 @@ -7794,27 +8081,29 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         "tmp.zig:4:30: note: selections from the second vector are specified with negative numbers",
     });
-    cases.addTest("nested vectors",
+    ctx.testErrStage1("nested vectors",
         \\export fn entry() void {
         \\    const V1 = @import("std").meta.Vector(4, u8);
         \\    const V2 = @Type(@import("std").builtin.TypeInfo{ .Vector = .{ .len = 4, .child = V1 } });
         \\    var v: V2 = undefined;
+        \\    _ = v;
         \\}
     , &[_][]const u8{
         "tmp.zig:3:53: error: vector element type must be integer, float, bool, or pointer; '@Vector(4, u8)' is invalid",
         "tmp.zig:3:16: note: referenced here",
     });
-    cases.addTest("bad @splat type",
+    ctx.testErrStage1("bad @splat type",
         \\export fn entry() void {
         \\    const c = 4;
         \\    var v = @splat(4, c);
+        \\    _ = v;
         \\}
     , &[_][]const u8{
         "tmp.zig:3:23: error: vector element type must be integer, float, bool, or pointer; 'comptime_int' is invalid",
     });
-    cases.add("compileLog of tagged enum doesn't crash the compiler",
+    ctx.objErrStage1("compileLog of tagged enum doesn't crash the compiler",
         \\const Bar = union(enum(u32)) {
         \\    X: i32 = 1
         \\};
 @@ -7830,28 +8119,30 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         "tmp.zig:6:5: error: found compile log statement",
     });
-    cases.add("attempted implicit cast from *const T to *[1]T",
+    ctx.objErrStage1("attempted implicit cast from *const T to *[1]T",
         \\export fn entry(byte: u8) void {
         \\    const w: i32 = 1234;
         \\    var x: *const i32 = &w;
         \\    var y: *[1]i32 = x;
         \\    y[0] += 1;
+        \\    _ = byte;
         \\}
     , &[_][]const u8{
         "tmp.zig:4:22: error: expected type '*[1]i32', found '*const i32'",
         "tmp.zig:4:22: note: cast discards const qualifier",
     });
-    cases.add("attempted implicit cast from *const T to []T",
+    ctx.objErrStage1("attempted implicit cast from *const T to []T",
         \\export fn entry() void {
         \\    const u: u32 = 42;
         \\    const x: []u32 = &u;
+        \\    _ = x;
         \\}
     , &[_][]const u8{
         "tmp.zig:3:23: error: expected type '[]u32', found '*const u32'",
     });
-    cases.add("for loop body expression ignored",
+    ctx.objErrStage1("for loop body expression ignored",
         \\fn returns() usize {
         \\    return 2;
         \\}
 @@ -7861,21 +8152,23 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         \\export fn f2() void {
         \\    var x: anyerror!i32 = error.Bad;
         \\    for ("hello") |_| returns() else unreachable;
+        \\    _ = x;
         \\}
     , &[_][]const u8{
         "tmp.zig:5:30: error: expression value is ignored",
         "tmp.zig:9:30: error: expression value is ignored",
     });
-    cases.add("aligned variable of zero-bit type",
+    ctx.objErrStage1("aligned variable of zero-bit type",
         \\export fn f() void {
         \\    var s: struct {} align(4) = undefined;
+        \\    _ = s;
         \\}
     , &[_][]const u8{
         "tmp.zig:2:5: error: variable 's' of zero-bit type 'struct:2:12' has no in-memory representation, it cannot be aligned",
     });
-    cases.add("function returning opaque type",
+    ctx.objErrStage1("function returning opaque type",
         \\const FooType = opaque {};
         \\export fn bar() !FooType {
         \\    return error.InvalidValue;
 @@ -7893,7 +8186,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         "tmp.zig:8:18: error: Undefined return type '(undefined)' not allowed",
     });
-    cases.add("generic function returning opaque type",
+    ctx.objErrStage1("generic function returning opaque type",
         \\const FooType = opaque {};
         \\fn generic(comptime T: type) !T {
         \\    return undefined;
 @@ -7917,81 +8210,89 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         "tmp.zig:2:1: note: function declared here",
     });
-    cases.add("function parameter is opaque",
+    ctx.objErrStage1("function parameter is opaque",
         \\const FooType = opaque {};
         \\export fn entry1() void {
         \\    const someFuncPtr: fn (FooType) void = undefined;
+        \\    _ = someFuncPtr;
         \\}
         \\
         \\export fn entry2() void {
         \\    const someFuncPtr: fn (@TypeOf(null)) void = undefined;
+        \\    _ = someFuncPtr;
         \\}
         \\
-        \\fn foo(p: FooType) void {}
+        \\fn foo(p: FooType) void {_ = p;}
         \\export fn entry3() void {
         \\    _ = foo;
         \\}
         \\
-        \\fn bar(p: @TypeOf(null)) void {}
+        \\fn bar(p: @TypeOf(null)) void {_ = p;}
         \\export fn entry4() void {
         \\    _ = bar;
         \\}
     , &[_][]const u8{
         "tmp.zig:3:28: error: parameter of opaque type 'FooType' not allowed",
-        "tmp.zig:7:28: error: parameter of type '(null)' not allowed",
+        "tmp.zig:8:28: error: parameter of type '(null)' not allowed",
-        "tmp.zig:10:11: error: parameter of opaque type 'FooType' not allowed",
+        "tmp.zig:12:11: error: parameter of opaque type 'FooType' not allowed",
-        "tmp.zig:15:11: error: parameter of type '(null)' not allowed",
+        "tmp.zig:17:11: error: parameter of type '(null)' not allowed",
     });
-    cases.add( // fixed bug #2032
+    ctx.objErrStage1( // fixed bug #2032
         "compile diagnostic string for top level decl type",
         \\export fn entry() void {
         \\    var foo: u32 = @This(){};
+        \\    _ = foo;
         \\}
     , &[_][]const u8{
         "tmp.zig:2:27: error: type 'u32' does not support array initialization",
     });
-    cases.add("issue #2687: coerce from undefined array pointer to slice",
+    ctx.objErrStage1("issue #2687: coerce from undefined array pointer to slice",
         \\export fn foo1() void {
         \\    const a: *[1]u8 = undefined;
         \\    var b: []u8 = a;
+        \\    _ = b;
         \\}
         \\export fn foo2() void {
         \\    comptime {
         \\        var a: *[1]u8 = undefined;
         \\        var b: []u8 = a;
+        \\        _ = b;
         \\    }
         \\}
         \\export fn foo3() void {
         \\    comptime {
         \\        const a: *[1]u8 = undefined;
         \\        var b: []u8 = a;
+        \\        _ = b;
         \\    }
         \\}
     , &[_][]const u8{
         "tmp.zig:3:19: error: use of undefined value here causes undefined behavior",
-        "tmp.zig:8:23: error: use of undefined value here causes undefined behavior",
+        "tmp.zig:9:23: error: use of undefined value here causes undefined behavior",
-        "tmp.zig:14:23: error: use of undefined value here causes undefined behavior",
+        "tmp.zig:16:23: error: use of undefined value here causes undefined behavior",
     });
-    cases.add("issue #3818: bitcast from parray/slice to u16",
+    ctx.objErrStage1("issue #3818: bitcast from parray/slice to u16",
         \\export fn foo1() void {
         \\    var bytes = [_]u8{1, 2};
         \\    const word: u16 = @bitCast(u16, bytes[0..]);
+        \\    _ = word;
         \\}
         \\export fn foo2() void {
         \\    var bytes: []const u8 = &[_]u8{1, 2};
         \\    const word: u16 = @bitCast(u16, bytes);
+        \\    _ = word;
         \\}
     , &[_][]const u8{
         "tmp.zig:3:42: error: unable to @bitCast from pointer type '*[2]u8'",
-        "tmp.zig:7:32: error: destination type 'u16' has size 2 but source type '[]const u8' has size 16",
+        "tmp.zig:8:32: error: destination type 'u16' has size 2 but source type '[]const u8' has size 16",
-        "tmp.zig:7:37: note: referenced here",
+        "tmp.zig:8:37: note: referenced here",
     });
     // issue #7810
-    cases.add("comptime slice-len increment beyond bounds",
+    ctx.objErrStage1("comptime slice-len increment beyond bounds",
         \\export fn foo_slice_len_increment_beyond_bounds() void {
         \\    comptime {
         \\        var buf_storage: [8]u8 = undefined;
 @@ -8004,11 +8305,12 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         ":6:12: error: out of bounds slice",
     });
-    cases.add("comptime slice-sentinel is out of bounds (unterminated)",
+    ctx.objErrStage1("comptime slice-sentinel is out of bounds (unterminated)",
         \\export fn foo_array() void {
         \\    comptime {
         \\        var target = [_]u8{ 'a', 'b', 'c', 'd' } ++ [_]u8{undefined} ** 10;
         \\        const slice = target[0..14 :0];
+        \\        _ = slice;
         \\    }
         \\}
         \\export fn foo_ptr_array() void {
 @@ -8016,6 +8318,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         \\        var buf = [_]u8{ 'a', 'b', 'c', 'd' } ++ [_]u8{undefined} ** 10;
         \\        var target = &buf;
         \\        const slice = target[0..14 :0];
+        \\        _ = slice;
         \\    }
         \\}
         \\export fn foo_vector_ConstPtrSpecialBaseArray() void {
 @@ -8023,6 +8326,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         \\        var buf = [_]u8{ 'a', 'b', 'c', 'd' } ++ [_]u8{undefined} ** 10;
         \\        var target: [*]u8 = &buf;
         \\        const slice = target[0..14 :0];
+        \\        _ = slice;
         \\    }
         \\}
         \\export fn foo_vector_ConstPtrSpecialRef() void {
 @@ -8030,6 +8334,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         \\        var buf = [_]u8{ 'a', 'b', 'c', 'd' } ++ [_]u8{undefined} ** 10;
         \\        var target: [*]u8 = @ptrCast([*]u8, &buf);
         \\        const slice = target[0..14 :0];
+        \\        _ = slice;
         \\    }
         \\}
         \\export fn foo_cvector_ConstPtrSpecialBaseArray() void {
 @@ -8037,6 +8342,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         \\        var buf = [_]u8{ 'a', 'b', 'c', 'd' } ++ [_]u8{undefined} ** 10;
         \\        var target: [*c]u8 = &buf;
         \\        const slice = target[0..14 :0];
+        \\        _ = slice;
         \\    }
         \\}
         \\export fn foo_cvector_ConstPtrSpecialRef() void {
 @@ -8044,6 +8350,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         \\        var buf = [_]u8{ 'a', 'b', 'c', 'd' } ++ [_]u8{undefined} ** 10;
         \\        var target: [*c]u8 = @ptrCast([*c]u8, &buf);
         \\        const slice = target[0..14 :0];
+        \\        _ = slice;
         \\    }
         \\}
         \\export fn foo_slice() void {
 @@ -8051,23 +8358,25 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         \\        var buf = [_]u8{ 'a', 'b', 'c', 'd' } ++ [_]u8{undefined} ** 10;
         \\        var target: []u8 = &buf;
         \\        const slice = target[0..14 :0];
+        \\        _ = slice;
         \\    }
         \\}
     , &[_][]const u8{
         ":4:29: error: slice-sentinel is out of bounds",
-        ":11:29: error: slice-sentinel is out of bounds",
+        ":12:29: error: slice-sentinel is out of bounds",
-        ":18:29: error: slice-sentinel is out of bounds",
+        ":20:29: error: slice-sentinel is out of bounds",
-        ":25:29: error: slice-sentinel is out of bounds",
+        ":28:29: error: slice-sentinel is out of bounds",
-        ":32:29: error: slice-sentinel is out of bounds",
+        ":36:29: error: slice-sentinel is out of bounds",
-        ":39:29: error: slice-sentinel is out of bounds",
+        ":44:29: error: slice-sentinel is out of bounds",
-        ":46:29: error: slice-sentinel is out of bounds",
+        ":52:29: error: slice-sentinel is out of bounds",
     });
-    cases.add("comptime slice-sentinel is out of bounds (terminated)",
+    ctx.objErrStage1("comptime slice-sentinel is out of bounds (terminated)",
         \\export fn foo_array() void {
         \\    comptime {
         \\        var target = [_:0]u8{ 'a', 'b', 'c', 'd' } ++ [_]u8{undefined} ** 10;
         \\        const slice = target[0..15 :1];
+        \\        _ = slice;
         \\    }
         \\}
         \\export fn foo_ptr_array() void {
 @@ -8075,6 +8384,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         \\        var buf = [_:0]u8{ 'a', 'b', 'c', 'd' } ++ [_]u8{undefined} ** 10;
         \\        var target = &buf;
         \\        const slice = target[0..15 :0];
+        \\        _ = slice;
         \\    }
         \\}
         \\export fn foo_vector_ConstPtrSpecialBaseArray() void {
 @@ -8082,6 +8392,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         \\        var buf = [_:0]u8{ 'a', 'b', 'c', 'd' } ++ [_]u8{undefined} ** 10;
         \\        var target: [*]u8 = &buf;
         \\        const slice = target[0..15 :0];
+        \\        _ = slice;
         \\    }
         \\}
         \\export fn foo_vector_ConstPtrSpecialRef() void {
 @@ -8089,6 +8400,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         \\        var buf = [_:0]u8{ 'a', 'b', 'c', 'd' } ++ [_]u8{undefined} ** 10;
         \\        var target: [*]u8 = @ptrCast([*]u8, &buf);
         \\        const slice = target[0..15 :0];
+        \\        _ = slice;
         \\    }
         \\}
         \\export fn foo_cvector_ConstPtrSpecialBaseArray() void {
 @@ -8096,6 +8408,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         \\        var buf = [_:0]u8{ 'a', 'b', 'c', 'd' } ++ [_]u8{undefined} ** 10;
         \\        var target: [*c]u8 = &buf;
         \\        const slice = target[0..15 :0];
+        \\        _ = slice;
         \\    }
         \\}
         \\export fn foo_cvector_ConstPtrSpecialRef() void {
 @@ -8103,6 +8416,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         \\        var buf = [_:0]u8{ 'a', 'b', 'c', 'd' } ++ [_]u8{undefined} ** 10;
         \\        var target: [*c]u8 = @ptrCast([*c]u8, &buf);
         \\        const slice = target[0..15 :0];
+        \\        _ = slice;
         \\    }
         \\}
         \\export fn foo_slice() void {
 @@ -8110,23 +8424,25 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         \\        var buf = [_:0]u8{ 'a', 'b', 'c', 'd' } ++ [_]u8{undefined} ** 10;
         \\        var target: []u8 = &buf;
         \\        const slice = target[0..15 :0];
+        \\        _ = slice;
         \\    }
         \\}
     , &[_][]const u8{
         ":4:29: error: out of bounds slice",
-        ":11:29: error: out of bounds slice",
+        ":12:29: error: out of bounds slice",
-        ":18:29: error: out of bounds slice",
+        ":20:29: error: out of bounds slice",
-        ":25:29: error: out of bounds slice",
+        ":28:29: error: out of bounds slice",
-        ":32:29: error: out of bounds slice",
+        ":36:29: error: out of bounds slice",
-        ":39:29: error: out of bounds slice",
+        ":44:29: error: out of bounds slice",
-        ":46:29: error: out of bounds slice",
+        ":52:29: error: out of bounds slice",
     });
-    cases.add("comptime slice-sentinel does not match memory at target index (unterminated)",
+    ctx.objErrStage1("comptime slice-sentinel does not match memory at target index (unterminated)",
         \\export fn foo_array() void {
         \\    comptime {
         \\        var target = [_]u8{ 'a', 'b', 'c', 'd' } ++ [_]u8{undefined} ** 10;
         \\        const slice = target[0..3 :0];
+        \\        _ = slice;
         \\    }
         \\}
         \\export fn foo_ptr_array() void {
 @@ -8134,6 +8450,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         \\        var buf = [_]u8{ 'a', 'b', 'c', 'd' } ++ [_]u8{undefined} ** 10;
         \\        var target = &buf;
         \\        const slice = target[0..3 :0];
+        \\        _ = slice;
         \\    }
         \\}
         \\export fn foo_vector_ConstPtrSpecialBaseArray() void {
 @@ -8141,6 +8458,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         \\        var buf = [_]u8{ 'a', 'b', 'c', 'd' } ++ [_]u8{undefined} ** 10;
         \\        var target: [*]u8 = &buf;
         \\        const slice = target[0..3 :0];
+        \\        _ = slice;
         \\    }
         \\}
         \\export fn foo_vector_ConstPtrSpecialRef() void {
 @@ -8148,6 +8466,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         \\        var buf = [_]u8{ 'a', 'b', 'c', 'd' } ++ [_]u8{undefined} ** 10;
         \\        var target: [*]u8 = @ptrCast([*]u8, &buf);
         \\        const slice = target[0..3 :0];
+        \\        _ = slice;
         \\    }
         \\}
         \\export fn foo_cvector_ConstPtrSpecialBaseArray() void {
 @@ -8155,6 +8474,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         \\        var buf = [_]u8{ 'a', 'b', 'c', 'd' } ++ [_]u8{undefined} ** 10;
         \\        var target: [*c]u8 = &buf;
         \\        const slice = target[0..3 :0];
+        \\        _ = slice;
         \\    }
         \\}
         \\export fn foo_cvector_ConstPtrSpecialRef() void {
 @@ -8162,6 +8482,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         \\        var buf = [_]u8{ 'a', 'b', 'c', 'd' } ++ [_]u8{undefined} ** 10;
         \\        var target: [*c]u8 = @ptrCast([*c]u8, &buf);
         \\        const slice = target[0..3 :0];
+        \\        _ = slice;
         \\    }
         \\}
         \\export fn foo_slice() void {
 @@ -8169,23 +8490,25 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         \\        var buf = [_]u8{ 'a', 'b', 'c', 'd' } ++ [_]u8{undefined} ** 10;
         \\        var target: []u8 = &buf;
         \\        const slice = target[0..3 :0];
+        \\        _ = slice;
         \\    }
         \\}
     , &[_][]const u8{
         ":4:29: error: slice-sentinel does not match memory at target index",
-        ":11:29: error: slice-sentinel does not match memory at target index",
+        ":12:29: error: slice-sentinel does not match memory at target index",
-        ":18:29: error: slice-sentinel does not match memory at target index",
+        ":20:29: error: slice-sentinel does not match memory at target index",
-        ":25:29: error: slice-sentinel does not match memory at target index",
+        ":28:29: error: slice-sentinel does not match memory at target index",
-        ":32:29: error: slice-sentinel does not match memory at target index",
+        ":36:29: error: slice-sentinel does not match memory at target index",
-        ":39:29: error: slice-sentinel does not match memory at target index",
+        ":44:29: error: slice-sentinel does not match memory at target index",
-        ":46:29: error: slice-sentinel does not match memory at target index",
+        ":52:29: error: slice-sentinel does not match memory at target index",
     });
-    cases.add("comptime slice-sentinel does not match memory at target index (terminated)",
+    ctx.objErrStage1("comptime slice-sentinel does not match memory at target index (terminated)",
         \\export fn foo_array() void {
         \\    comptime {
         \\        var target = [_:0]u8{ 'a', 'b', 'c', 'd' } ++ [_]u8{undefined} ** 10;
         \\        const slice = target[0..3 :0];
+        \\        _ = slice;
         \\    }
         \\}
         \\export fn foo_ptr_array() void {
 @@ -8193,6 +8516,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         \\        var buf = [_:0]u8{ 'a', 'b', 'c', 'd' } ++ [_]u8{undefined} ** 10;
         \\        var target = &buf;
         \\        const slice = target[0..3 :0];
+        \\        _ = slice;
         \\    }
         \\}
         \\export fn foo_vector_ConstPtrSpecialBaseArray() void {
 @@ -8200,6 +8524,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         \\        var buf = [_:0]u8{ 'a', 'b', 'c', 'd' } ++ [_]u8{undefined} ** 10;
         \\        var target: [*]u8 = &buf;
         \\        const slice = target[0..3 :0];
+        \\        _ = slice;
         \\    }
         \\}
         \\export fn foo_vector_ConstPtrSpecialRef() void {
 @@ -8207,6 +8532,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         \\        var buf = [_:0]u8{ 'a', 'b', 'c', 'd' } ++ [_]u8{undefined} ** 10;
         \\        var target: [*]u8 = @ptrCast([*]u8, &buf);
         \\        const slice = target[0..3 :0];
+        \\        _ = slice;
         \\    }
         \\}
         \\export fn foo_cvector_ConstPtrSpecialBaseArray() void {
 @@ -8214,6 +8540,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         \\        var buf = [_:0]u8{ 'a', 'b', 'c', 'd' } ++ [_]u8{undefined} ** 10;
         \\        var target: [*c]u8 = &buf;
         \\        const slice = target[0..3 :0];
+        \\        _ = slice;
         \\    }
         \\}
         \\export fn foo_cvector_ConstPtrSpecialRef() void {
 @@ -8221,6 +8548,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         \\        var buf = [_:0]u8{ 'a', 'b', 'c', 'd' } ++ [_]u8{undefined} ** 10;
         \\        var target: [*c]u8 = @ptrCast([*c]u8, &buf);
         \\        const slice = target[0..3 :0];
+        \\        _ = slice;
         \\    }
         \\}
         \\export fn foo_slice() void {
 @@ -8228,23 +8556,25 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         \\        var buf = [_:0]u8{ 'a', 'b', 'c', 'd' } ++ [_]u8{undefined} ** 10;
         \\        var target: []u8 = &buf;
         \\        const slice = target[0..3 :0];
+        \\        _ = slice;
         \\    }
         \\}
     , &[_][]const u8{
         ":4:29: error: slice-sentinel does not match memory at target index",
-        ":11:29: error: slice-sentinel does not match memory at target index",
+        ":12:29: error: slice-sentinel does not match memory at target index",
-        ":18:29: error: slice-sentinel does not match memory at target index",
+        ":20:29: error: slice-sentinel does not match memory at target index",
-        ":25:29: error: slice-sentinel does not match memory at target index",
+        ":28:29: error: slice-sentinel does not match memory at target index",
-        ":32:29: error: slice-sentinel does not match memory at target index",
+        ":36:29: error: slice-sentinel does not match memory at target index",
-        ":39:29: error: slice-sentinel does not match memory at target index",
+        ":44:29: error: slice-sentinel does not match memory at target index",
-        ":46:29: error: slice-sentinel does not match memory at target index",
+        ":52:29: error: slice-sentinel does not match memory at target index",
     });
-    cases.add("comptime slice-sentinel does not match target-sentinel",
+    ctx.objErrStage1("comptime slice-sentinel does not match target-sentinel",
         \\export fn foo_array() void {
         \\    comptime {
         \\        var target = [_:0]u8{ 'a', 'b', 'c', 'd' } ++ [_]u8{undefined} ** 10;
         \\        const slice = target[0..14 :255];
+        \\        _ = slice;
         \\    }
         \\}
         \\export fn foo_ptr_array() void {
 @@ -8252,6 +8582,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         \\        var buf = [_:0]u8{ 'a', 'b', 'c', 'd' } ++ [_]u8{undefined} ** 10;
         \\        var target = &buf;
         \\        const slice = target[0..14 :255];
+        \\        _ = slice;
         \\    }
         \\}
         \\export fn foo_vector_ConstPtrSpecialBaseArray() void {
 @@ -8259,6 +8590,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         \\        var buf = [_:0]u8{ 'a', 'b', 'c', 'd' } ++ [_]u8{undefined} ** 10;
         \\        var target: [*]u8 = &buf;
         \\        const slice = target[0..14 :255];
+        \\        _ = slice;
         \\    }
         \\}
         \\export fn foo_vector_ConstPtrSpecialRef() void {
 @@ -8266,6 +8598,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         \\        var buf = [_:0]u8{ 'a', 'b', 'c', 'd' } ++ [_]u8{undefined} ** 10;
         \\        var target: [*]u8 = @ptrCast([*]u8, &buf);
         \\        const slice = target[0..14 :255];
+        \\        _ = slice;
         \\    }
         \\}
         \\export fn foo_cvector_ConstPtrSpecialBaseArray() void {
 @@ -8273,6 +8606,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         \\        var buf = [_:0]u8{ 'a', 'b', 'c', 'd' } ++ [_]u8{undefined} ** 10;
         \\        var target: [*c]u8 = &buf;
         \\        const slice = target[0..14 :255];
+        \\        _ = slice;
         \\    }
         \\}
         \\export fn foo_cvector_ConstPtrSpecialRef() void {
 @@ -8280,6 +8614,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         \\        var buf = [_:0]u8{ 'a', 'b', 'c', 'd' } ++ [_]u8{undefined} ** 10;
         \\        var target: [*c]u8 = @ptrCast([*c]u8, &buf);
         \\        const slice = target[0..14 :255];
+        \\        _ = slice;
         \\    }
         \\}
         \\export fn foo_slice() void {
 @@ -8287,19 +8622,20 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         \\        var buf = [_:0]u8{ 'a', 'b', 'c', 'd' } ++ [_]u8{undefined} ** 10;
         \\        var target: []u8 = &buf;
         \\        const slice = target[0..14 :255];
+        \\        _ = slice;
         \\    }
         \\}
     , &[_][]const u8{
         ":4:29: error: slice-sentinel does not match target-sentinel",
-        ":11:29: error: slice-sentinel does not match target-sentinel",
+        ":12:29: error: slice-sentinel does not match target-sentinel",
-        ":18:29: error: slice-sentinel does not match target-sentinel",
+        ":20:29: error: slice-sentinel does not match target-sentinel",
-        ":25:29: error: slice-sentinel does not match target-sentinel",
+        ":28:29: error: slice-sentinel does not match target-sentinel",
-        ":32:29: error: slice-sentinel does not match target-sentinel",
+        ":36:29: error: slice-sentinel does not match target-sentinel",
-        ":39:29: error: slice-sentinel does not match target-sentinel",
+        ":44:29: error: slice-sentinel does not match target-sentinel",
-        ":46:29: error: slice-sentinel does not match target-sentinel",
+        ":52:29: error: slice-sentinel does not match target-sentinel",
     });
-    cases.add("issue #4207: coerce from non-terminated-slice to terminated-pointer",
+    ctx.objErrStage1("issue #4207: coerce from non-terminated-slice to terminated-pointer",
         \\export fn foo() [*:0]const u8 {
         \\    var buffer: [64]u8 = undefined;
         \\    return buffer[0..];
 @@ -8309,8 +8645,8 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         ":3:18: note: destination pointer requires a terminating '0' sentinel",
     });
-    cases.add("issue #5221: invalid struct init type referenced by @typeInfo and passed into function",
+    ctx.objErrStage1("issue #5221: invalid struct init type referenced by @typeInfo and passed into function",
-        \\fn ignore(comptime param: anytype) void {}
+        \\fn ignore(comptime param: anytype) void {_ = param;}
         \\
         \\export fn foo() void {
         \\    const MyStruct = struct {
 @@ -8323,7 +8659,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         ":5:28: error: expected type '[]u8', found '*const [3:0]u8'",
     });
-    cases.add("integer underflow error",
+    ctx.objErrStage1("integer underflow error",
         \\export fn entry() void {
         \\    _ = @intToPtr(*c_void, ~@as(usize, @import("std").math.maxInt(usize)) - 1);
         \\}
 @@ -8331,23 +8667,24 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         ":2:75: error: operation caused overflow",
     });
-    cases.addCase(x: {
+    {
-        var tc = cases.create("align(N) expr function pointers is a compile error",
+        const case = ctx.obj("align(N) expr function pointers is a compile error", .{
+            .cpu_arch = .wasm32,
+            .os_tag = .freestanding,
+            .abi = .none,
+        });
+        case.backend = .stage1;
+        case.addError(
             \\export fn foo() align(1) void {
             \\    return;
             \\}
         , &[_][]const u8{
             "tmp.zig:1:23: error: align(N) expr is not allowed on function prototypes in wasm32/wasm64",
         });
-        tc.target = std.zig.CrossTarget{
+    }
-            .cpu_arch = .wasm32,
-            .os_tag = .freestanding,
-            .abi = .none,
-        };
-        break :x tc;
-    });
-    cases.add("compare optional to non-optional with invalid types",
+    ctx.objErrStage1("compare optional to non-optional with invalid types",
         \\export fn inconsistentChildType() void {
         \\    var x: ?i32 = undefined;
         \\    const y: comptime_int = 10;
 @@ -8381,16 +8718,17 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         ":22:12: note: operator not supported for type '[3]i32'",
     });
-    cases.add("slice cannot have its bytes reinterpreted",
+    ctx.objErrStage1("slice cannot have its bytes reinterpreted",
         \\export fn foo() void {
         \\    const bytes = [1]u8{ 0xfa } ** 16;
         \\    var value = @ptrCast(*const []const u8, &bytes).*;
+        \\    _ = value;
         \\}
     , &[_][]const u8{
         ":3:52: error: slice '[]const u8' cannot have its bytes reinterpreted",
     });
-    cases.add("wasmMemorySize is a compile error in non-Wasm targets",
+    ctx.objErrStage1("wasmMemorySize is a compile error in non-Wasm targets",
         \\export fn foo() void {
         \\    _ = @wasmMemorySize(0);
         \\    return;
 @@ -8399,7 +8737,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         "tmp.zig:2:9: error: @wasmMemorySize is a wasm32 feature only",
     });
-    cases.add("wasmMemoryGrow is a compile error in non-Wasm targets",
+    ctx.objErrStage1("wasmMemoryGrow is a compile error in non-Wasm targets",
         \\export fn foo() void {
         \\    _ = @wasmMemoryGrow(0, 1);
         \\    return;
 @@ -8407,7 +8745,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
     , &[_][]const u8{
         "tmp.zig:2:9: error: @wasmMemoryGrow is a wasm32 feature only",
     });
-    cases.add("Issue #5586: Make unary minus for unsigned types a compile error",
+    ctx.objErrStage1("Issue #5586: Make unary minus for unsigned types a compile error",
         \\export fn f1(x: u32) u32 {
         \\    const y = -%x;
         \\    return -y;
 @@ -8422,7 +8760,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         "tmp.zig:8:12: error: negation of type 'u32'",
     });
-    cases.add("Issue #5618: coercion of ?*c_void to *c_void must fail.",
+    ctx.objErrStage1("Issue #5618: coercion of ?*c_void to *c_void must fail.",
         \\export fn foo() void {
         \\    var u: ?*c_void = null;
         \\    var v: *c_void = undefined;
 @@ -8432,15 +8770,17 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         "tmp.zig:4:9: error: expected type '*c_void', found '?*c_void'",
     });
-    cases.add("Issue #6823: don't allow .* to be followed by **",
+    ctx.objErrStage1("Issue #6823: don't allow .* to be followed by **",
         \\fn foo() void {
         \\    var sequence = "repeat".*** 10;
+        \\    _ = sequence;
         \\}
     , &[_][]const u8{
-        "tmp.zig:2:30: error: `.*` cannot be followed by `*`. Are you missing a space?",
+        // Ideally this would be column 30 but it's not very important.
+        "tmp.zig:2:28: error: '.*' cannot be followed by '*'. Are you missing a space?",
     });
-    cases.add("Issue #9165: windows tcp server compilation error",
+    ctx.objErrStage1("Issue #9165: windows tcp server compilation error",
         \\const std = @import("std");
         \\pub const io_mode = .evented;
         \\pub fn main() !void {

test/stage2/cbe.zig+7-6

...	@@ -525,7 +525,7 @@ pub fn addCases(ctx: *TestContext) !void {	...	@@ -525,7 +525,7 @@ pub fn addCases(ctx: *TestContext) !void {
525	\\}	525	\\}
526	, &.{	526	, &.{
527	":3:21: error: missing struct field: x",	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	case.addError(	530	case.addError(
531	\\const Point = struct { x: i32, y: i32 };	531	\\const Point = struct { x: i32, y: i32 };
...	@@ -538,7 +538,7 @@ pub fn addCases(ctx: *TestContext) !void {	...	@@ -538,7 +538,7 @@ pub fn addCases(ctx: *TestContext) !void {
538	\\ return p.y - p.x - p.x;	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	":1:15: note: struct declared here",	542	":1:15: note: struct declared here",
543	});	543	});
544	case.addCompareOutput(	544	case.addCompareOutput(
...	@@ -591,6 +591,7 @@ pub fn addCases(ctx: *TestContext) !void {	...	@@ -591,6 +591,7 @@ pub fn addCases(ctx: *TestContext) !void {
591	, &.{	591	, &.{
592	":3:5: error: enum fields cannot be marked comptime",	592	":3:5: error: enum fields cannot be marked comptime",
593	":8:8: error: enum fields do not have types",	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	// @enumToInt, @intToEnum, enum literal coercion, field access syntax, comparison, switch	597	// @enumToInt, @intToEnum, enum literal coercion, field access syntax, comparison, switch
...	@@ -716,7 +717,7 @@ pub fn addCases(ctx: *TestContext) !void {	...	@@ -716,7 +717,7 @@ pub fn addCases(ctx: *TestContext) !void {
716	\\ _ = @intToEnum(E, 3);	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	":1:11: note: enum declared here",	721	":1:11: note: enum declared here",
721	});	722	});
722		723
...	@@ -732,7 +733,7 @@ pub fn addCases(ctx: *TestContext) !void {	...	@@ -732,7 +733,7 @@ pub fn addCases(ctx: *TestContext) !void {
732	, &.{	733	, &.{
733	":4:5: error: switch must handle all possibilities",	734	":4:5: error: switch must handle all possibilities",
734	":4:5: note: unhandled enumeration value: 'b'",	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	case.addError(	739	case.addError(
...	@@ -787,7 +788,7 @@ pub fn addCases(ctx: *TestContext) !void {	...	@@ -787,7 +788,7 @@ pub fn addCases(ctx: *TestContext) !void {
787	\\ _ = E.d;	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	":1:11: note: enum declared here",	792	":1:11: note: enum declared here",
792	});	793	});
793		794
...	@@ -798,7 +799,7 @@ pub fn addCases(ctx: *TestContext) !void {	...	@@ -798,7 +799,7 @@ pub fn addCases(ctx: *TestContext) !void {
798	\\ _ = x;	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	":1:11: note: enum declared here",	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,7 +14,7 @@ pub fn addCases(ctx: *TestContext) !void {
14	{	14	{
15	var case = ctx.exe("hello world with updates", target);	15	var case = ctx.exe("hello world with updates", target);
16	case.addError("", &[_][]const u8{	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	// Incorrect return type	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,7 +16,6 @@ const LibExeObjStep = build.LibExeObjStep;
16	const compare_output = @import("compare_output.zig");	16	const compare_output = @import("compare_output.zig");
17	const standalone = @import("standalone.zig");	17	const standalone = @import("standalone.zig");
18	const stack_traces = @import("stack_traces.zig");	18	const stack_traces = @import("stack_traces.zig");
19	const compile_errors = @import("compile_errors.zig");
20	const assemble_and_link = @import("assemble_and_link.zig");	19	const assemble_and_link = @import("assemble_and_link.zig");
21	const runtime_safety = @import("runtime_safety.zig");	20	const runtime_safety = @import("runtime_safety.zig");
22	const translate_c = @import("translate_c.zig");	21	const translate_c = @import("translate_c.zig");
...	@@ -384,21 +383,6 @@ pub fn addRuntimeSafetyTests(b: *build.Builder, test_filter: ?[]const u8, modes:	...	@@ -384,21 +383,6 @@ pub fn addRuntimeSafetyTests(b: *build.Builder, test_filter: ?[]const u8, modes:
384	return cases.step;	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	pub fn addStandaloneTests(b: build.Builder, test_filter: ?[]const u8, modes: []const Mode, skip_non_native: bool, target: std.zig.CrossTarget) build.Step {	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	const cases = b.allocator.create(StandaloneContext) catch unreachable;	387	const cases = b.allocator.create(StandaloneContext) catch unreachable;
404	cases.* = StandaloneContext{	388	cases.* = StandaloneContext{
...	@@ -840,304 +824,6 @@ pub const StackTracesContext = struct {	...	@@ -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	pub const StandaloneContext = struct {	827	pub const StandaloneContext = struct {
1142	b: *build.Builder,	828	b: *build.Builder,
1143	step: *build.Step,	829	step: *build.Step,
...	@@ -1312,13 +998,6 @@ pub const GenHContext = struct {	...	@@ -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	pub fn create(	1001	pub fn create(
1323	self: *GenHContext,	1002	self: *GenHContext,
1324	filename: []const u8,	1003	filename: []const u8,

...	@@ -5194,7 +5194,7 @@ const maxInt = std.math.maxInt;	...	@@ -5194,7 +5194,7 @@ const maxInt = std.math.maxInt;
5194		5194
5195	var fixed_buffer_mem: [100 * 1024]u8 = undefined;	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	const stderr = io.getStdErr().writer();	5198	const stderr = io.getStdErr().writer();
5199		5199
5200	var tree = try std.zig.parse(allocator, source);	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,7 +5222,7 @@ fn testParse(source: []const u8, allocator: mem.Allocator, anything_changed: b
5222	anything_changed.* = !mem.eql(u8, formatted, source);	5222	anything_changed.* = !mem.eql(u8, formatted, source);
5223	return formatted;	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	const needed_alloc_count = x: {	5226	const needed_alloc_count = x: {
5227	// Try it once with unlimited memory, make sure it works	5227	// Try it once with unlimited memory, make sure it works
5228	var fixed_allocator = std.heap.FixedBufferAllocator.init(fixed_buffer_mem[0..]);	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,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	return testTransform(source, source);	5272	return testTransform(source, source);
5273	}	5273	}
5274		5274
5275	const Error = std.zig.ast.Error.Tag;	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	var tree = try std.zig.parse(std.testing.allocator, source);	5278	var tree = try std.zig.parse(std.testing.allocator, source);
5279	defer tree.deinit(std.testing.allocator);	5279	defer tree.deinit(std.testing.allocator);
5280		5280

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

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

...	@@ -5407,16 +5407,6 @@ static void ir_finish_bb(IrAnalyze *ira) {	...	@@ -5407,16 +5407,6 @@ static void ir_finish_bb(IrAnalyze *ira) {
5407	ira->new_irb.current_basic_block->debug_id);	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	ir_start_next_bb(ira);	5410	ir_start_next_bb(ira);
5421	}	5411	}
5422		5412
...	@@ -11107,7 +11097,7 @@ static IrInstGen ir_analyze_instruction_export(IrAnalyze ira, IrInstSrcExport	...	@@ -11107,7 +11097,7 @@ static IrInstGen ir_analyze_instruction_export(IrAnalyze ira, IrInstSrcExport
11107	AstNode *other_export_node = entry->value->source_node;	11097	AstNode *other_export_node = entry->value->source_node;
11108	ErrorMsg *msg = ir_add_error(ira, &instruction->base.base,	11098	ErrorMsg *msg = ir_add_error(ira, &instruction->base.base,
11109	buf_sprintf("exported symbol collision: '%s'", buf_ptr(symbol_name)));	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	return ira->codegen->invalid_inst_gen;	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,7 +11403,7 @@ static IrInstGen ir_analyze_instruction_extern(IrAnalyze ira, IrInstSrcExtern
11413	AstNode *other_extern_node = entry->value->source_node;	11403	AstNode *other_extern_node = entry->value->source_node;
11414	ErrorMsg *msg = ir_add_error(ira, &instruction->base.base,	11404	ErrorMsg *msg = ir_add_error(ira, &instruction->base.base,
11415	buf_sprintf("extern symbol collision: '%s'", buf_ptr(symbol_name)));	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	return ira->codegen->invalid_inst_gen;	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,7 +15924,7 @@ static IrInstGen ir_analyze_instruction_pop_count(IrAnalyze ira, IrInstSrcPopC
15934	return ir_build_pop_count_gen(ira, &instruction->base.base, return_type, op);	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	if (type_is_invalid(value->value->type))	15928	if (type_is_invalid(value->value->type))
15939	return ira->codegen->invalid_inst_gen;	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,7 +15933,7 @@ static IrInstGen ir_analyze_union_tag(IrAnalyze ira, IrInst* source_instr, IrI
15943	buf_sprintf("expected enum or union type, found '%s'", buf_ptr(&value->value->type->name)));	15933	buf_sprintf("expected enum or union type, found '%s'", buf_ptr(&value->value->type->name)));
15944	return ira->codegen->invalid_inst_gen;	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	ErrorMsg *msg = ir_add_error(ira, source_instr, buf_sprintf("union has no associated enum"));	15937	ErrorMsg *msg = ir_add_error(ira, source_instr, buf_sprintf("union has no associated enum"));
15948	if (value->value->type->data.unionation.decl_node != nullptr) {	15938	if (value->value->type->data.unionation.decl_node != nullptr) {
15949	add_error_note(ira->codegen, msg, value->value->type->data.unionation.decl_node,	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,7 +16896,7 @@ static IrInstGen ir_analyze_instruction_enum_tag_name(IrAnalyze ira, IrInstSrc
16906	}	16896	}
16907		16897
16908	if (target_type->id == ZigTypeIdUnion) {	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	if (type_is_invalid(target->value->type))	16900	if (type_is_invalid(target->value->type))
16911	return ira->codegen->invalid_inst_gen;	16901	return ira->codegen->invalid_inst_gen;
16912	target_type = target->value->type;	16902	target_type = target->value->type;
...	@@ -21742,7 +21732,7 @@ static IrInstGen ir_analyze_instruction_check_switch_prongs(IrAnalyze ira,	...	@@ -21742,7 +21732,7 @@ static IrInstGen ir_analyze_instruction_check_switch_prongs(IrAnalyze ira,
21742	ErrorMsg *msg = ir_add_error(ira, &start_value->base,	21732	ErrorMsg *msg = ir_add_error(ira, &start_value->base,
21743	buf_sprintf("duplicate switch value: '%s.%s'", buf_ptr(&switch_type->name),	21733	buf_sprintf("duplicate switch value: '%s.%s'", buf_ptr(&switch_type->name),
21744	buf_ptr(enum_field->name)));	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	bigint_incr(&field_index);	21737	bigint_incr(&field_index);
21748	}	21738	}
...	@@ -21828,7 +21818,7 @@ static IrInstGen ir_analyze_instruction_check_switch_prongs(IrAnalyze ira,	...	@@ -21828,7 +21818,7 @@ static IrInstGen ir_analyze_instruction_check_switch_prongs(IrAnalyze ira,
21828	Buf *err_name = &ira->codegen->errors_by_index.at(start_index)->name;	21818	Buf *err_name = &ira->codegen->errors_by_index.at(start_index)->name;
21829	ErrorMsg *msg = ir_add_error(ira, &start_value->base,	21819	ErrorMsg *msg = ir_add_error(ira, &start_value->base,
21830	buf_sprintf("duplicate switch value: '%s.%s'", buf_ptr(&switch_type->name), buf_ptr(err_name)));	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	field_prev_uses[start_index] = start_value->base.source_node;	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,7 +21880,7 @@ static IrInstGen ir_analyze_instruction_check_switch_prongs(IrAnalyze ira,
21890	start_value->base.source_node);	21880	start_value->base.source_node);
21891	if (prev_node != nullptr) {	21881	if (prev_node != nullptr) {
21892	ErrorMsg *msg = ir_add_error(ira, &start_value->base, buf_sprintf("duplicate switch value"));	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	return ira->codegen->invalid_inst_gen;	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,7 +21965,7 @@ static IrInstGen ir_analyze_instruction_check_switch_prongs(IrAnalyze ira,
21975	auto entry = prevs.put_unique(const_expr_val->data.x_type, value);	21965	auto entry = prevs.put_unique(const_expr_val->data.x_type, value);
21976	if(entry != nullptr) {	21966	if(entry != nullptr) {
21977	ErrorMsg *msg = ir_add_error(ira, &value->base, buf_sprintf("duplicate switch value"));	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	prevs.deinit();	21969	prevs.deinit();
21980	return ira->codegen->invalid_inst_gen;	21970	return ira->codegen->invalid_inst_gen;
21981	}	21971	}

...	@@ -55,7 +55,17 @@ static ErrorMsg exec_add_error_node(CodeGen codegen, Stage1Zir *exec, AstNode	...	@@ -55,7 +55,17 @@ static ErrorMsg exec_add_error_node(CodeGen codegen, Stage1Zir *exec, AstNode
55		55
56		56
57	static bool instr_is_unreachable(IrInstSrc *instruction) {	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	void destroy_instruction_src(IrInstSrc *inst) {	71	void destroy_instruction_src(IrInstSrc *inst) {
...	@@ -947,7 +957,6 @@ static IrInstSrc ir_build_cond_br(Stage1AstGen ag, Scope scope, AstNode sour	...	@@ -947,7 +957,6 @@ static IrInstSrc ir_build_cond_br(Stage1AstGen ag, Scope scope, AstNode sour
947	Stage1ZirBasicBlock then_block, Stage1ZirBasicBlock else_block, IrInstSrc *is_comptime)	957	Stage1ZirBasicBlock then_block, Stage1ZirBasicBlock else_block, IrInstSrc *is_comptime)
948	{	958	{
949	IrInstSrcCondBr *inst = ir_build_instruction<IrInstSrcCondBr>(ag, scope, source_node);	959	IrInstSrcCondBr *inst = ir_build_instruction<IrInstSrcCondBr>(ag, scope, source_node);
950	inst->base.is_noreturn = true;
951	inst->condition = condition;	960	inst->condition = condition;
952	inst->then_block = then_block;	961	inst->then_block = then_block;
953	inst->else_block = else_block;	962	inst->else_block = else_block;
...	@@ -963,7 +972,6 @@ static IrInstSrc ir_build_cond_br(Stage1AstGen ag, Scope scope, AstNode sour	...	@@ -963,7 +972,6 @@ static IrInstSrc ir_build_cond_br(Stage1AstGen ag, Scope scope, AstNode sour
963		972
964	static IrInstSrc ir_build_return_src(Stage1AstGen ag, Scope scope, AstNode source_node, IrInstSrc *operand) {	973	static IrInstSrc ir_build_return_src(Stage1AstGen ag, Scope scope, AstNode source_node, IrInstSrc *operand) {
965	IrInstSrcReturn *inst = ir_build_instruction<IrInstSrcReturn>(ag, scope, source_node);	974	IrInstSrcReturn *inst = ir_build_instruction<IrInstSrcReturn>(ag, scope, source_node);
966	inst->base.is_noreturn = true;
967	inst->operand = operand;	975	inst->operand = operand;
968		976
969	if (operand != nullptr) ir_ref_instruction(operand, ag->current_basic_block);	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,7 +1311,6 @@ static IrInstSrc ir_build_br(Stage1AstGen ag, Scope scope, AstNode source_no
1303	Stage1ZirBasicBlock dest_block, IrInstSrc is_comptime)	1311	Stage1ZirBasicBlock dest_block, IrInstSrc is_comptime)
1304	{	1312	{
1305	IrInstSrcBr *inst = ir_build_instruction<IrInstSrcBr>(ag, scope, source_node);	1313	IrInstSrcBr *inst = ir_build_instruction<IrInstSrcBr>(ag, scope, source_node);
1306	inst->base.is_noreturn = true;
1307	inst->dest_block = dest_block;	1314	inst->dest_block = dest_block;