diff --git a/ci/zinc/linux_test.sh b/ci/zinc/linux_test.sh
index ec999a483a062e3c741fc57a0c8ed537d1ba59c2..180589cc8ef8bd8fb8c038ba70d12ee8e8e33025 100755
--- a/ci/zinc/linux_test.sh
+++ b/ci/zinc/linux_test.sh
@@ -45,7 +45,7 @@ cd $WORKSPACE
 
 # Look for non-conforming code formatting.
 # Formatting errors can be fixed by running `zig fmt` on the files printed here.
-$ZIG fmt --check . --exclude test/compile_errors/ --exclude test/incremental/
+$ZIG fmt --check . --exclude test/cases/
 
 # Build stage2 standalone so that we can test stage2 against stage2 compiler-rt.
 $ZIG             build -p stage2 -Dstatic-llvm -Dtarget=native-native-musl --search-prefix "$DEPS_LOCAL"
diff --git a/src/test.zig b/src/test.zig
index bdc02ff2e0e693eee7272f3d22ca06c36241e42b..c5dda0757f96c5f375a3590d0755ed45ca8d30ae 100644
--- a/src/test.zig
+++ b/src/test.zig
@@ -36,26 +36,13 @@ test {
 
     {
         const dir_path = try std.fs.path.join(arena, &.{
-            std.fs.path.dirname(@src().file).?, "..", "test", "compile_errors",
+            std.fs.path.dirname(@src().file).?, "..", "test", "cases",
         });
 
         var dir = try std.fs.cwd().openDir(dir_path, .{ .iterate = true });
         defer dir.close();
 
-        // TODO make this incremental once the bug is solved that it triggers
-        // See: https://github.com/ziglang/zig/issues/11344
-        ctx.addTestCasesFromDir(dir, .independent);
-    }
-
-    {
-        const dir_path = try std.fs.path.join(arena, &.{
-            std.fs.path.dirname(@src().file).?, "..", "test", "incremental",
-        });
-
-        var dir = try std.fs.cwd().openDir(dir_path, .{ .iterate = true });
-        defer dir.close();
-
-        ctx.addTestCasesFromDir(dir, .incremental);
+        ctx.addTestCasesFromDir(dir);
     }
 
     try @import("test_cases").addCases(&ctx);
@@ -395,6 +382,134 @@ const TestManifest = struct {
     }
 };
 
+const TestStrategy = enum {
+    /// Execute tests as independent compilations, unless they are explicitly
+    /// incremental ("foo.0.zig", "foo.1.zig", etc.)
+    independent,
+    /// Execute all tests as incremental updates to a single compilation. Explicitly
+    /// incremental tests ("foo.0.zig", "foo.1.zig", etc.) still execute in order
+    incremental,
+};
+
+/// Iterates a set of filenames extracting batches that are either incremental
+/// ("foo.0.zig", "foo.1.zig", etc.) or independent ("foo.zig", "bar.zig", etc.).
+/// Assumes filenames are sorted.
+const TestIterator = struct {
+    start: usize = 0,
+    end: usize = 0,
+    filenames: []const []const u8,
+
+    const Error = error{InvalidIncrementalTestIndex};
+
+    fn next(it: *TestIterator) Error!?[]const []const u8 {
+        try it.nextInner();
+        if (it.start == it.end) return null;
+        return it.filenames[it.start..it.end];
+    }
+
+    fn nextInner(it: *TestIterator) Error!void {
+        it.start = it.end;
+        if (it.end == it.filenames.len) return;
+        if (it.end + 1 == it.filenames.len) {
+            it.end += 1;
+            return;
+        }
+
+        const remaining = it.filenames[it.end..];
+        var i: usize = 0;
+        while (i < remaining.len - 1) : (i += 1) {
+            // First, check if this file is part of an incremental update sequence
+            // Split filename into "<base_name>.<index>.<file_ext>"
+            const prev_parts = getTestFileNameParts(remaining[i]);
+            const new_parts = getTestFileNameParts(remaining[i + 1]);
+
+            // If base_name and file_ext match, these files are in the same test sequence
+            // and the new one should be the incremented version of the previous test
+            if (std.mem.eql(u8, prev_parts.base_name, new_parts.base_name) and
+                std.mem.eql(u8, prev_parts.file_ext, new_parts.file_ext))
+            {
+                // This is "foo.X.zig" followed by "foo.Y.zig". Make sure that X = Y + 1
+                if (prev_parts.test_index == null)
+                    return error.InvalidIncrementalTestIndex;
+                if (new_parts.test_index == null)
+                    return error.InvalidIncrementalTestIndex;
+                if (new_parts.test_index.? != prev_parts.test_index.? + 1)
+                    return error.InvalidIncrementalTestIndex;
+            } else {
+                // This is not the same test sequence, so the new file must be the first file
+                // in a new sequence ("*.0.zig") or an independent test file ("*.zig")
+                if (new_parts.test_index != null and new_parts.test_index.? != 0)
+                    return error.InvalidIncrementalTestIndex;
+
+                it.end += i + 1;
+                break;
+            }
+        } else {
+            it.end += remaining.len;
+        }
+    }
+};
+
+/// For a filename in the format "<filename>.X.<ext>" or "<filename>.<ext>", returns
+/// "<filename>", "<ext>" and X parsed as a decimal number. If X is not present, or
+/// cannot be parsed as a decimal number, it is treated as part of <filename>
+fn getTestFileNameParts(name: []const u8) struct {
+    base_name: []const u8,
+    file_ext: []const u8,
+    test_index: ?usize,
+} {
+    const file_ext = std.fs.path.extension(name);
+    const trimmed = name[0 .. name.len - file_ext.len]; // Trim off ".<ext>"
+    const maybe_index = std.fs.path.extension(trimmed); // Extract ".X"
+
+    // Attempt to parse index
+    const index: ?usize = if (maybe_index.len > 0)
+        std.fmt.parseInt(usize, maybe_index[1..], 10) catch null
+    else
+        null;
+
+    // Adjust "<filename>" extent based on parsing success
+    const base_name_end = trimmed.len - if (index != null) maybe_index.len else 0;
+    return .{
+        .base_name = name[0..base_name_end],
+        .file_ext = if (file_ext.len > 0) file_ext[1..] else file_ext,
+        .test_index = index,
+    };
+}
+
+/// Sort test filenames in-place, so that incremental test cases ("foo.0.zig",
+/// "foo.1.zig", etc.) are contiguous and appear in numerical order.
+fn sortTestFilenames(
+    filenames: [][]const u8,
+) void {
+    const Context = struct {
+        pub fn lessThan(_: @This(), a: []const u8, b: []const u8) bool {
+            const a_parts = getTestFileNameParts(a);
+            const b_parts = getTestFileNameParts(b);
+
+            // Sort "<base_name>.X.<file_ext>" based on "<base_name>" and "<file_ext>" first
+            return switch (std.mem.order(u8, a_parts.base_name, b_parts.base_name)) {
+                .lt => true,
+                .gt => false,
+                .eq => switch (std.mem.order(u8, a_parts.file_ext, b_parts.file_ext)) {
+                    .lt => true,
+                    .gt => false,
+                    .eq => b: { // a and b differ only in their ".X" part
+
+                        // Sort "<base_name>.<file_ext>" before any "<base_name>.X.<file_ext>"
+                        if (a_parts.test_index == null) break :b true;
+                        if (b_parts.test_index == null) break :b false;
+
+                        // Make sure that incremental tests appear in linear order
+                        return a_parts.test_index.? < b_parts.test_index.?;
+                    },
+                },
+            };
+        }
+    };
+    std.sort.sort([]const u8, filenames, Context{}, Context.lessThan);
+}
+
 pub const TestContext = struct {
     arena: Allocator,
     cases: std.ArrayList(Case),
@@ -895,100 +1010,29 @@ pub const TestContext = struct {
         case.compiles(fixed_src);
     }
 
-    const Strategy = enum {
-        /// Execute tests as independent compilations, unless they are explicitly
-        /// incremental ("foo.0.zig", "foo.1.zig", etc.)
-        independent,
-        /// Execute all tests as incremental updates to a single compilation. Explicitly
-        /// incremental tests ("foo.0.zig", "foo.1.zig", etc.) still execute in order
-        incremental,
-    };
-
-    /// Adds a test for each file in the provided directory, using the selected strategy.
+    /// Adds a test for each file in the provided directory.
+    /// Testing strategy (TestStrategy) is inferred automatically from filenames.
     /// Recurses nested directories.
     ///
     /// Each file should include a test manifest as a contiguous block of comments at
     /// the end of the file. The first line should be the test type, followed by a set of
     /// key-value config values, followed by a blank line, then the expected output.
-    pub fn addTestCasesFromDir(ctx: *TestContext, dir: std.fs.Dir, strategy: Strategy) void {
+    pub fn addTestCasesFromDir(ctx: *TestContext, dir: std.fs.Dir) void {
         var current_file: []const u8 = "none";
-        ctx.addTestCasesFromDirInner(dir, strategy, &current_file) catch |err| {
+        ctx.addTestCasesFromDirInner(dir, &current_file) catch |err| {
             std.debug.panic("test harness failed to process file '{s}': {s}\n", .{
                 current_file, @errorName(err),
             });
         };
     }
 
-    /// For a filename in the format "<filename>.X.<ext>" or "<filename>.<ext>", returns
-    /// "<filename>", "<ext>" and X parsed as a decimal number. If X is not present, or
-    /// cannot be parsed as a decimal number, it is treated as part of <filename>
-    fn getTestFileNameParts(name: []const u8) struct {
-        base_name: []const u8,
-        file_ext: []const u8,
-        test_index: ?usize,
-    } {
-        const file_ext = std.fs.path.extension(name);
-        const trimmed = name[0 .. name.len - file_ext.len]; // Trim off ".<ext>"
-        const maybe_index = std.fs.path.extension(trimmed); // Extract ".X"
-
-        // Attempt to parse index
-        const index: ?usize = if (maybe_index.len > 0)
-            std.fmt.parseInt(usize, maybe_index[1..], 10) catch null
-        else
-            null;
-
-        // Adjust "<filename>" extent based on parsing success
-        const base_name_end = trimmed.len - if (index != null) maybe_index.len else 0;
-        return .{
-            .base_name = name[0..base_name_end],
-            .file_ext = if (file_ext.len > 0) file_ext[1..] else file_ext,
-            .test_index = index,
-        };
-    }
-
-    /// Sort test filenames in-place, so that incremental test cases ("foo.0.zig",
-    /// "foo.1.zig", etc.) are contiguous and appear in numerical order.
-    fn sortTestFilenames(
-        filenames: [][]const u8,
-    ) void {
-        const Context = struct {
-            pub fn lessThan(_: @This(), a: []const u8, b: []const u8) bool {
-                const a_parts = getTestFileNameParts(a);
-                const b_parts = getTestFileNameParts(b);
-
-                // Sort "<base_name>.X.<file_ext>" based on "<base_name>" and "<file_ext>" first
-                return switch (std.mem.order(u8, a_parts.base_name, b_parts.base_name)) {
-                    .lt => true,
-                    .gt => false,
-                    .eq => switch (std.mem.order(u8, a_parts.file_ext, b_parts.file_ext)) {
-                        .lt => true,
-                        .gt => false,
-                        .eq => b: { // a and b differ only in their ".X" part
-
-                            // Sort "<base_name>.<file_ext>" before any "<base_name>.X.<file_ext>"
-                            if (a_parts.test_index == null) break :b true;
-                            if (b_parts.test_index == null) break :b false;
-
-                            // Make sure that incremental tests appear in linear order
-                            return a_parts.test_index.? < b_parts.test_index.?;
-                        },
-                    },
-                };
-            }
-        };
-        std.sort.sort([]const u8, filenames, Context{}, Context.lessThan);
-    }
-
     fn addTestCasesFromDirInner(
         ctx: *TestContext,
         dir: std.fs.Dir,
-        strategy: Strategy,
         /// This is kept up to date with the currently being processed file so
         /// that if any errors occur the caller knows it happened during this file.
         current_file: *[]const u8,
     ) !void {
-        var cases = std.ArrayList(usize).init(ctx.arena);
-
         var it = try dir.walk(ctx.arena);
         var filenames = std.ArrayList([]const u8).init(ctx.arena);
 
@@ -1006,104 +1050,87 @@ pub const TestContext = struct {
         // Sort filenames, so that incremental tests are contiguous and in-order
         sortTestFilenames(filenames.items);
 
-        var prev_filename: []const u8 = "";
-        for (filenames.items) |filename| {
-            current_file.* = filename;
-
-            // First, check if this file is part of an incremental update sequence
-            // Split filename into "<base_name>.<index>.<file_ext>"
-            const prev_parts = getTestFileNameParts(prev_filename);
-            const new_parts = getTestFileNameParts(filename);
-
-            // If base_name and file_ext match, these files are in the same test sequence
-            // and the new one should be the incremented version of the previous test
-            if (std.mem.eql(u8, prev_parts.base_name, new_parts.base_name) and
-                std.mem.eql(u8, prev_parts.file_ext, new_parts.file_ext))
-            {
-                // This is "foo.X.zig" followed by "foo.Y.zig". Make sure that X = Y + 1
-                if (prev_parts.test_index == null) return error.InvalidIncrementalTestIndex;
-                if (new_parts.test_index == null) return error.InvalidIncrementalTestIndex;
-                if (new_parts.test_index.? != prev_parts.test_index.? + 1) return error.InvalidIncrementalTestIndex;
-            } else {
-                // This is not the same test sequence, so the new file must be the first file
-                // in a new sequence ("*.0.zig") or an independent test file ("*.zig")
-                if (new_parts.test_index != null and new_parts.test_index.? != 0) return error.InvalidIncrementalTestIndex;
-                cases.clearRetainingCapacity();
-            }
-            prev_filename = filename;
-
-            const max_file_size = 10 * 1024 * 1024;
-            const src = try dir.readFileAllocOptions(ctx.arena, filename, max_file_size, null, 1, 0);
-
-            // Parse the manifest
-            var manifest = try TestManifest.parse(ctx.arena, src);
-
-            if (cases.items.len == 0) {
-                const backends = try manifest.getConfigForKeyAlloc(ctx.arena, "backend", Backend);
-                const targets = try manifest.getConfigForKeyAlloc(ctx.arena, "target", CrossTarget);
-                const is_test = manifest.getConfigForKeyAssertSingle("is_test", bool);
-                const output_mode = manifest.getConfigForKeyAssertSingle("output_mode", std.builtin.OutputMode);
-
-                const name_prefix = blk: {
-                    const ext_index = std.mem.lastIndexOfScalar(u8, current_file.*, '.') orelse
-                        return error.InvalidFilename;
-                    const index = std.mem.lastIndexOfScalar(u8, current_file.*[0..ext_index], '.') orelse ext_index;
-                    break :blk current_file.*[0..index];
-                };
-
-                // Cross-product to get all possible test combinations
-                for (backends) |backend| {
-                    if (backend == .stage1 and skip_stage1) continue;
-
-                    for (targets) |target| {
-                        const name = try std.fmt.allocPrint(ctx.arena, "{s} ({s}, {s})", .{
-                            name_prefix,
-                            @tagName(backend),
-                            try target.zigTriple(ctx.arena),
-                        });
-                        const next = ctx.cases.items.len;
-                        try ctx.cases.append(.{
-                            .name = name,
-                            .target = target,
-                            .backend = backend,
-                            .updates = std.ArrayList(TestContext.Update).init(ctx.cases.allocator),
-                            .is_test = is_test,
-                            .output_mode = output_mode,
-                            .link_libc = backend == .llvm,
-                            .files = std.ArrayList(TestContext.File).init(ctx.cases.allocator),
-                        });
-                        try cases.append(next);
+        var test_it = TestIterator{ .filenames = filenames.items };
+        while (try test_it.next()) |batch| {
+            const strategy: TestStrategy = if (batch.len > 1) .incremental else .independent;
+            var cases = std.ArrayList(usize).init(ctx.arena);
+
+            for (batch) |filename| {
+                current_file.* = filename;
+
+                const max_file_size = 10 * 1024 * 1024;
+                const src = try dir.readFileAllocOptions(ctx.arena, filename, max_file_size, null, 1, 0);
+
+                // Parse the manifest
+                var manifest = try TestManifest.parse(ctx.arena, src);
+
+                if (cases.items.len == 0) {
+                    const backends = try manifest.getConfigForKeyAlloc(ctx.arena, "backend", Backend);
+                    const targets = try manifest.getConfigForKeyAlloc(ctx.arena, "target", CrossTarget);
+                    const is_test = manifest.getConfigForKeyAssertSingle("is_test", bool);
+                    const output_mode = manifest.getConfigForKeyAssertSingle("output_mode", std.builtin.OutputMode);
+
+                    const name_prefix = blk: {
+                        const ext_index = std.mem.lastIndexOfScalar(u8, current_file.*, '.') orelse
+                            return error.InvalidFilename;
+                        const index = std.mem.lastIndexOfScalar(u8, current_file.*[0..ext_index], '.') orelse ext_index;
+                        break :blk current_file.*[0..index];
+                    };
+
+                    // Cross-product to get all possible test combinations
+                    for (backends) |backend| {
+                        if (backend == .stage1 and skip_stage1) continue;
+
+                        for (targets) |target| {
+                            const name = try std.fmt.allocPrint(ctx.arena, "{s} ({s}, {s})", .{
+                                name_prefix,
+                                @tagName(backend),
+                                try target.zigTriple(ctx.arena),
+                            });
+                            const next = ctx.cases.items.len;
+                            try ctx.cases.append(.{
+                                .name = name,
+                                .target = target,
+                                .backend = backend,
+                                .updates = std.ArrayList(TestContext.Update).init(ctx.cases.allocator),
+                                .is_test = is_test,
+                                .output_mode = output_mode,
+                                .link_libc = backend == .llvm,
+                                .files = std.ArrayList(TestContext.File).init(ctx.cases.allocator),
+                            });
+                            try cases.append(next);
+                        }
                     }
                 }
-            }
 
-            for (cases.items) |case_index| {
-                const case = &ctx.cases.items[case_index];
-                switch (manifest.@"type") {
-                    .@"error" => {
-                        const errors = try manifest.trailingAlloc(ctx.arena);
-                        switch (strategy) {
-                            .independent => {
-                                case.addError(src, errors);
-                            },
-                            .incremental => {
-                                case.addErrorNamed("update", src, errors);
-                            },
-                        }
-                    },
-                    .run => {
-                        var output = std.ArrayList(u8).init(ctx.arena);
-                        var trailing_it = manifest.trailing();
-                        while (trailing_it.next()) |line| {
-                            try output.appendSlice(line);
-                            try output.append('\n');
-                        }
-                        if (output.items.len > 0) {
-                            try output.resize(output.items.len - 1);
-                        }
-                        case.addCompareOutput(src, output.toOwnedSlice());
-                    },
-                    .cli => @panic("TODO cli tests"),
+                for (cases.items) |case_index| {
+                    const case = &ctx.cases.items[case_index];
+                    switch (manifest.@"type") {
+                        .@"error" => {
+                            const errors = try manifest.trailingAlloc(ctx.arena);
+                            switch (strategy) {
+                                .independent => {
+                                    case.addError(src, errors);
+                                },
+                                .incremental => {
+                                    case.addErrorNamed("update", src, errors);
+                                },
+                            }
+                        },
+                        .run => {
+                            var output = std.ArrayList(u8).init(ctx.arena);
+                            var trailing_it = manifest.trailing();
+                            while (trailing_it.next()) |line| {
+                                try output.appendSlice(line);
+                                try output.append('\n');
+                            }
+                            if (output.items.len > 0) {
+                                try output.resize(output.items.len - 1);
+                            }
+                            case.addCompareOutput(src, output.toOwnedSlice());
+                        },
+                        .cli => @panic("TODO cli tests"),
+                    }
                 }
             }
         }
diff --git a/test/cases/aarch64-linux/conditional_branches.0.zig b/test/cases/aarch64-linux/conditional_branches.0.zig
new file mode 100644
index 0000000000000000000000000000000000000000..28435b9d4a86940fb08eaf65bc8243a2488d4429
--- /dev/null
+++ b/test/cases/aarch64-linux/conditional_branches.0.zig
@@ -0,0 +1,26 @@
+pub fn main() void {
+    foo(123);
+}
+
+fn foo(x: u64) void {
+    if (x > 42) {
+        print();
+    }
+}
+
+fn print() void {
+    asm volatile ("svc #0"
+        :
+        : [number] "{x8}" (64),
+          [arg1] "{x0}" (1),
+          [arg2] "{x1}" (@ptrToInt("Hello, World!\n")),
+          [arg3] "{x2}" ("Hello, World!\n".len),
+        : "memory", "cc"
+    );
+}
+
+// run
+// target=aarch64-linux
+//
+// Hello, World!
+//
diff --git a/test/cases/aarch64-linux/conditional_branches.1.zig b/test/cases/aarch64-linux/conditional_branches.1.zig
new file mode 100644
index 0000000000000000000000000000000000000000..e03758fcb7c99317c812e8ef06921fe5c43d4f19
--- /dev/null
+++ b/test/cases/aarch64-linux/conditional_branches.1.zig
@@ -0,0 +1,25 @@
+pub fn main() void {
+    foo(true);
+}
+
+fn foo(x: bool) void {
+    if (x) {
+        print();
+    }
+}
+
+fn print() void {
+    asm volatile ("svc #0"
+        :
+        : [number] "{x8}" (64),
+          [arg1] "{x0}" (1),
+          [arg2] "{x1}" (@ptrToInt("Hello, World!\n")),
+          [arg3] "{x2}" ("Hello, World!\n".len),
+        : "memory", "cc"
+    );
+}
+
+// run
+//
+// Hello, World!
+//
diff --git a/test/cases/aarch64-linux/hello_world_with_updates.0.zig b/test/cases/aarch64-linux/hello_world_with_updates.0.zig
new file mode 100644
index 0000000000000000000000000000000000000000..7a87d74dc3063b0d16f4f12fa678a4d3e7e13953
--- /dev/null
+++ b/test/cases/aarch64-linux/hello_world_with_updates.0.zig
@@ -0,0 +1,31 @@
+pub export fn _start() noreturn {
+    print();
+    exit(0);
+}
+
+fn print() void {
+    asm volatile ("svc #0"
+        :
+        : [number] "{x8}" (64),
+          [arg1] "{x0}" (1),
+          [arg2] "{x1}" (@ptrToInt("Hello, World!\n")),
+          [arg3] "{x2}" ("Hello, World!\n".len),
+        : "memory", "cc"
+    );
+}
+
+fn exit(ret: usize) noreturn {
+    asm volatile ("svc #0"
+        :
+        : [number] "{x8}" (93),
+          [arg1] "{x0}" (ret),
+        : "memory", "cc"
+    );
+    unreachable;
+}
+
+// run
+// target=aarch64-linux
+//
+// Hello, World!
+//
diff --git a/test/cases/aarch64-linux/hello_world_with_updates.1.zig b/test/cases/aarch64-linux/hello_world_with_updates.1.zig
new file mode 100644
index 0000000000000000000000000000000000000000..a5ca0d9926f62da4dcefb2ff2b30c902acbf1a38
--- /dev/null
+++ b/test/cases/aarch64-linux/hello_world_with_updates.1.zig
@@ -0,0 +1,36 @@
+pub export fn _start() noreturn {
+    print();
+    print();
+    print();
+    print();
+    exit(0);
+}
+
+fn print() void {
+    asm volatile ("svc #0"
+        :
+        : [number] "{x8}" (64),
+          [arg1] "{x0}" (1),
+          [arg2] "{x1}" (@ptrToInt("Hello, World!\n")),
+          [arg3] "{x2}" ("Hello, World!\n".len),
+        : "memory", "cc"
+    );
+}
+
+fn exit(ret: usize) noreturn {
+    asm volatile ("svc #0"
+        :
+        : [number] "{x8}" (93),
+          [arg1] "{x0}" (ret),
+        : "memory", "cc"
+    );
+    unreachable;
+}
+
+// run
+//
+// Hello, World!
+// Hello, World!
+// Hello, World!
+// Hello, World!
+//
diff --git a/test/cases/aarch64-linux/hello_world_with_updates.2.zig b/test/cases/aarch64-linux/hello_world_with_updates.2.zig
new file mode 100644
index 0000000000000000000000000000000000000000..71f0f160bc6ba35df619c1875671515f7240ccf7
--- /dev/null
+++ b/test/cases/aarch64-linux/hello_world_with_updates.2.zig
@@ -0,0 +1,21 @@
+pub fn main() void {
+    print();
+    print();
+}
+
+fn print() void {
+    asm volatile ("svc #0"
+        :
+        : [number] "{x8}" (64),
+          [arg1] "{x0}" (1),
+          [arg2] "{x1}" (@ptrToInt("Hello, World!\n")),
+          [arg3] "{x2}" ("Hello, World!\n".len),
+        : "memory", "cc"
+    );
+}
+
+// run
+//
+// Hello, World!
+// Hello, World!
+//
diff --git a/test/cases/aarch64-macos/hello_world_with_updates.0.zig b/test/cases/aarch64-macos/hello_world_with_updates.0.zig
new file mode 100644
index 0000000000000000000000000000000000000000..300baac1a45566c33a5e0aa3573cdad39db51a0b
--- /dev/null
+++ b/test/cases/aarch64-macos/hello_world_with_updates.0.zig
@@ -0,0 +1,5 @@
+// error
+// output_mode=Exe
+// target=aarch64-macos
+//
+// :107:9: error: struct 'tmp.tmp' has no member named 'main'
diff --git a/test/cases/aarch64-macos/hello_world_with_updates.1.zig b/test/cases/aarch64-macos/hello_world_with_updates.1.zig
new file mode 100644
index 0000000000000000000000000000000000000000..909fc9ccfbcb343f761414446c0ec4d52e98aeef
--- /dev/null
+++ b/test/cases/aarch64-macos/hello_world_with_updates.1.zig
@@ -0,0 +1,5 @@
+pub export fn main() noreturn {}
+
+// error
+//
+// :1:32: error: expected noreturn, found void
diff --git a/test/cases/aarch64-macos/hello_world_with_updates.2.zig b/test/cases/aarch64-macos/hello_world_with_updates.2.zig
new file mode 100644
index 0000000000000000000000000000000000000000..fb8cb39eddf859f843ce61b068c0f6f8f9feb387
--- /dev/null
+++ b/test/cases/aarch64-macos/hello_world_with_updates.2.zig
@@ -0,0 +1,19 @@
+extern "c" fn write(usize, usize, usize) usize;
+extern "c" fn exit(usize) noreturn;
+
+pub export fn main() noreturn {
+    print();
+
+    exit(0);
+}
+
+fn print() void {
+    const msg = @ptrToInt("Hello, World!\n");
+    const len = 14;
+    _ = write(1, msg, len);
+}
+
+// run
+//
+// Hello, World!
+//
diff --git a/test/cases/aarch64-macos/hello_world_with_updates.3.zig b/test/cases/aarch64-macos/hello_world_with_updates.3.zig
new file mode 100644
index 0000000000000000000000000000000000000000..f6e233886b0a7d616f92dd11ffb4232191c997de
--- /dev/null
+++ b/test/cases/aarch64-macos/hello_world_with_updates.3.zig
@@ -0,0 +1,16 @@
+extern "c" fn write(usize, usize, usize) usize;
+
+pub fn main() void {
+    print();
+}
+
+fn print() void {
+    const msg = @ptrToInt("Hello, World!\n");
+    const len = 14;
+    _ = write(1, msg, len);
+}
+
+// run
+//
+// Hello, World!
+//
diff --git a/test/cases/aarch64-macos/hello_world_with_updates.4.zig b/test/cases/aarch64-macos/hello_world_with_updates.4.zig
new file mode 100644
index 0000000000000000000000000000000000000000..f89cef73543ce1f3e51a4e0152c0a8c367edf537
--- /dev/null
+++ b/test/cases/aarch64-macos/hello_world_with_updates.4.zig
@@ -0,0 +1,22 @@
+extern "c" fn write(usize, usize, usize) usize;
+
+pub fn main() void {
+    print();
+    print();
+    print();
+    print();
+}
+
+fn print() void {
+    const msg = @ptrToInt("Hello, World!\n");
+    const len = 14;
+    _ = write(1, msg, len);
+}
+
+// run
+//
+// Hello, World!
+// Hello, World!
+// Hello, World!
+// Hello, World!
+//
diff --git a/test/cases/aarch64-macos/hello_world_with_updates.5.zig b/test/cases/aarch64-macos/hello_world_with_updates.5.zig
new file mode 100644
index 0000000000000000000000000000000000000000..0d7f97578afe1274d1c8e3d356ce702992edca61
--- /dev/null
+++ b/test/cases/aarch64-macos/hello_world_with_updates.5.zig
@@ -0,0 +1,16 @@
+extern "c" fn write(usize, usize, usize) usize;
+
+pub fn main() void {
+    print();
+}
+
+fn print() void {
+    const msg = @ptrToInt("What is up? This is a longer message that will force the data to be relocated in virtual address space.\n");
+    const len = 104;
+    _ = write(1, msg, len);
+}
+
+// run
+//
+// What is up? This is a longer message that will force the data to be relocated in virtual address space.
+//
diff --git a/test/cases/aarch64-macos/hello_world_with_updates.6.zig b/test/cases/aarch64-macos/hello_world_with_updates.6.zig
new file mode 100644
index 0000000000000000000000000000000000000000..3ce2cb717639d663c2679dcdef2a4583c3c3f8ec
--- /dev/null
+++ b/test/cases/aarch64-macos/hello_world_with_updates.6.zig
@@ -0,0 +1,18 @@
+extern "c" fn write(usize, usize, usize) usize;
+
+pub fn main() void {
+    print();
+    print();
+}
+
+fn print() void {
+    const msg = @ptrToInt("What is up? This is a longer message that will force the data to be relocated in virtual address space.\n");
+    const len = 104;
+    _ = write(1, msg, len);
+}
+
+// run
+//
+// What is up? This is a longer message that will force the data to be relocated in virtual address space.
+// What is up? This is a longer message that will force the data to be relocated in virtual address space.
+//
diff --git a/test/cases/adding_numbers_at_runtime_and_comptime.0.zig b/test/cases/adding_numbers_at_runtime_and_comptime.0.zig
new file mode 100644
index 0000000000000000000000000000000000000000..e8c219681348a2456792cffea64853f01c5ab81e
--- /dev/null
+++ b/test/cases/adding_numbers_at_runtime_and_comptime.0.zig
@@ -0,0 +1,10 @@
+pub fn main() void {
+    add(3, 4);
+}
+
+fn add(a: u32, b: u32) void {
+    if (a + b != 7) unreachable;
+}
+
+// run
+//
diff --git a/test/cases/adding_numbers_at_runtime_and_comptime.1.zig b/test/cases/adding_numbers_at_runtime_and_comptime.1.zig
new file mode 100644
index 0000000000000000000000000000000000000000..d90dc6884d6960c96c1192d673662f275739d9ce
--- /dev/null
+++ b/test/cases/adding_numbers_at_runtime_and_comptime.1.zig
@@ -0,0 +1,12 @@
+pub fn main() void {
+    if (x - 7 != 0) unreachable;
+}
+
+fn add(a: u32, b: u32) u32 {
+    return a + b;
+}
+
+const x = add(3, 4);
+
+// run
+//
diff --git a/test/cases/adding_numbers_at_runtime_and_comptime.2.zig b/test/cases/adding_numbers_at_runtime_and_comptime.2.zig
new file mode 100644
index 0000000000000000000000000000000000000000..6643d811fc7edd946d27adac4302439093fb2603
--- /dev/null
+++ b/test/cases/adding_numbers_at_runtime_and_comptime.2.zig
@@ -0,0 +1,12 @@
+pub fn main() void {
+    var x: usize = 3;
+    const y = add(1, 2, x);
+    if (y - 6 != 0) unreachable;
+}
+
+inline fn add(a: usize, b: usize, c: usize) usize {
+    return a + b + c;
+}
+
+// run
+//
diff --git a/test/cases/ambiguous_reference.zig b/test/cases/ambiguous_reference.zig
new file mode 100644
index 0000000000000000000000000000000000000000..66144a5645902aea913226486abd12657434367d
--- /dev/null
+++ b/test/cases/ambiguous_reference.zig
@@ -0,0 +1,13 @@
+const T = struct {
+    const T = struct {
+        fn f() void {
+            _ = T;
+        }
+    };
+};
+
+// error
+//
+// :4:17: error: ambiguous reference
+// :2:5: note: declared here
+// :1:1: note: also declared here
diff --git a/test/cases/arm-linux/arithmetic_operations.0.zig b/test/cases/arm-linux/arithmetic_operations.0.zig
new file mode 100644
index 0000000000000000000000000000000000000000..51a2dbd700ff528ea70db8cac4f4a3faf0605b1a
--- /dev/null
+++ b/test/cases/arm-linux/arithmetic_operations.0.zig
@@ -0,0 +1,21 @@
+pub fn main() void {
+    print(2, 4);
+    print(1, 7);
+}
+
+fn print(a: u32, b: u32) void {
+    asm volatile ("svc #0"
+        :
+        : [number] "{r7}" (4),
+          [arg3] "{r2}" (a + b),
+          [arg1] "{r0}" (1),
+          [arg2] "{r1}" (@ptrToInt("123456789")),
+        : "memory"
+    );
+    return;
+}
+
+// run
+// target=arm-linux
+//
+// 12345612345678
diff --git a/test/cases/arm-linux/arithmetic_operations.1.zig b/test/cases/arm-linux/arithmetic_operations.1.zig
new file mode 100644
index 0000000000000000000000000000000000000000..1e3793ed38f2cf4e554de59233f13fbcccc542c7
--- /dev/null
+++ b/test/cases/arm-linux/arithmetic_operations.1.zig
@@ -0,0 +1,20 @@
+pub fn main() void {
+    print(10, 5);
+    print(4, 3);
+}
+
+fn print(a: u32, b: u32) void {
+    asm volatile ("svc #0"
+        :
+        : [number] "{r7}" (4),
+          [arg3] "{r2}" (a - b),
+          [arg1] "{r0}" (1),
+          [arg2] "{r1}" (@ptrToInt("123456789")),
+        : "memory"
+    );
+    return;
+}
+
+// run
+//
+// 123451
diff --git a/test/cases/arm-linux/arithmetic_operations.2.zig b/test/cases/arm-linux/arithmetic_operations.2.zig
new file mode 100644
index 0000000000000000000000000000000000000000..6b81e62198b665f8d3928069425df20bc79812bb
--- /dev/null
+++ b/test/cases/arm-linux/arithmetic_operations.2.zig
@@ -0,0 +1,20 @@
+pub fn main() void {
+    print(8, 9);
+    print(3, 7);
+}
+
+fn print(a: u32, b: u32) void {
+    asm volatile ("svc #0"
+        :
+        : [number] "{r7}" (4),
+          [arg3] "{r2}" (a & b),
+          [arg1] "{r0}" (1),
+          [arg2] "{r1}" (@ptrToInt("123456789")),
+        : "memory"
+    );
+    return;
+}
+
+// run
+//
+// 12345678123
diff --git a/test/cases/arm-linux/arithmetic_operations.3.zig b/test/cases/arm-linux/arithmetic_operations.3.zig
new file mode 100644
index 0000000000000000000000000000000000000000..23089127f53aa331ed08030caa524b9627fdba2e
--- /dev/null
+++ b/test/cases/arm-linux/arithmetic_operations.3.zig
@@ -0,0 +1,20 @@
+pub fn main() void {
+    print(4, 2);
+    print(3, 7);
+}
+
+fn print(a: u32, b: u32) void {
+    asm volatile ("svc #0"
+        :
+        : [number] "{r7}" (4),
+          [arg3] "{r2}" (a | b),
+          [arg1] "{r0}" (1),
+          [arg2] "{r1}" (@ptrToInt("123456789")),
+        : "memory"
+    );
+    return;
+}
+
+// run
+//
+// 1234561234567
diff --git a/test/cases/arm-linux/arithmetic_operations.4.zig b/test/cases/arm-linux/arithmetic_operations.4.zig
new file mode 100644
index 0000000000000000000000000000000000000000..ce5133c4653da4568d1bdae16edf56fa418e4fb1
--- /dev/null
+++ b/test/cases/arm-linux/arithmetic_operations.4.zig
@@ -0,0 +1,20 @@
+pub fn main() void {
+    print(42, 42);
+    print(3, 5);
+}
+
+fn print(a: u32, b: u32) void {
+    asm volatile ("svc #0"
+        :
+        : [number] "{r7}" (4),
+          [arg3] "{r2}" (a ^ b),
+          [arg1] "{r0}" (1),
+          [arg2] "{r1}" (@ptrToInt("123456789")),
+        : "memory"
+    );
+    return;
+}
+
+// run
+//
+// 123456
diff --git a/test/cases/arm-linux/arithmetic_operations.5.zig b/test/cases/arm-linux/arithmetic_operations.5.zig
new file mode 100644
index 0000000000000000000000000000000000000000..b1c18ca7da2ffed288f42f414fc64b42e6e552be
--- /dev/null
+++ b/test/cases/arm-linux/arithmetic_operations.5.zig
@@ -0,0 +1,15 @@
+pub fn main() void {
+    var x: u32 = 1;
+    assert(x << 1 == 2);
+
+    x <<= 1;
+    assert(x << 2 == 8);
+    assert(x << 3 == 16);
+}
+
+pub fn assert(ok: bool) void {
+    if (!ok) unreachable; // assertion failure
+}
+
+// run
+//
diff --git a/test/cases/arm-linux/arithmetic_operations.6.zig b/test/cases/arm-linux/arithmetic_operations.6.zig
new file mode 100644
index 0000000000000000000000000000000000000000..e03731173c613aa1f3aaf5b9dd114e076eac6e7c
--- /dev/null
+++ b/test/cases/arm-linux/arithmetic_operations.6.zig
@@ -0,0 +1,21 @@
+pub fn main() void {
+    var a: u32 = 1024;
+    assert(a >> 1 == 512);
+
+    a >>= 1;
+    assert(a >> 2 == 128);
+    assert(a >> 3 == 64);
+    assert(a >> 4 == 32);
+    assert(a >> 5 == 16);
+    assert(a >> 6 == 8);
+    assert(a >> 7 == 4);
+    assert(a >> 8 == 2);
+    assert(a >> 9 == 1);
+}
+
+pub fn assert(ok: bool) void {
+    if (!ok) unreachable; // assertion failure
+}
+
+// run
+//
diff --git a/test/cases/arm-linux/errors.0.zig b/test/cases/arm-linux/errors.0.zig
new file mode 100644
index 0000000000000000000000000000000000000000..3e20d1d9737652b33f030e6f4b51abe819e222ec
--- /dev/null
+++ b/test/cases/arm-linux/errors.0.zig
@@ -0,0 +1,21 @@
+pub fn main() void {
+    foo() catch print();
+}
+
+fn foo() anyerror!void {}
+
+fn print() void {
+    asm volatile ("svc #0"
+        :
+        : [number] "{r7}" (4),
+          [arg1] "{r0}" (1),
+          [arg2] "{r1}" (@ptrToInt("Hello, World!\n")),
+          [arg3] "{r2}" ("Hello, World!\n".len),
+        : "memory"
+    );
+    return;
+}
+
+// run
+// target=arm-linux
+//
diff --git a/test/cases/arm-linux/errors.1.zig b/test/cases/arm-linux/errors.1.zig
new file mode 100644
index 0000000000000000000000000000000000000000..43fbb12675581ef874e92d08f360ee68263e0e4f
--- /dev/null
+++ b/test/cases/arm-linux/errors.1.zig
@@ -0,0 +1,24 @@
+pub fn main() void {
+    foo() catch print();
+}
+
+fn foo() anyerror!void {
+    return error.Test;
+}
+
+fn print() void {
+    asm volatile ("svc #0"
+        :
+        : [number] "{r7}" (4),
+          [arg1] "{r0}" (1),
+          [arg2] "{r1}" (@ptrToInt("Hello, World!\n")),
+          [arg3] "{r2}" ("Hello, World!\n".len),
+        : "memory"
+    );
+    return;
+}
+
+// run
+//
+// Hello, World!
+//
diff --git a/test/cases/arm-linux/errors.2.zig b/test/cases/arm-linux/errors.2.zig
new file mode 100644
index 0000000000000000000000000000000000000000..a1b9aef97dc4396e8e89bf1394592f260cce3743
--- /dev/null
+++ b/test/cases/arm-linux/errors.2.zig
@@ -0,0 +1,27 @@
+pub fn main() void {
+    foo() catch |err| {
+        assert(err == error.Foo);
+        assert(err != error.Bar);
+        assert(err != error.Baz);
+    };
+    bar() catch |err| {
+        assert(err != error.Foo);
+        assert(err == error.Bar);
+        assert(err != error.Baz);
+    };
+}
+
+fn assert(ok: bool) void {
+    if (!ok) unreachable;
+}
+
+fn foo() anyerror!void {
+    return error.Foo;
+}
+
+fn bar() anyerror!void {
+    return error.Bar;
+}
+
+// run
+//
diff --git a/test/cases/arm-linux/errors.3.zig b/test/cases/arm-linux/errors.3.zig
new file mode 100644
index 0000000000000000000000000000000000000000..390696fcfcb261ea6c8383d13c0bec8c9e85c445
--- /dev/null
+++ b/test/cases/arm-linux/errors.3.zig
@@ -0,0 +1,12 @@
+pub fn main() void {
+    foo() catch unreachable;
+}
+
+fn foo() anyerror!void {
+    try bar();
+}
+
+fn bar() anyerror!void {}
+
+// run
+//
diff --git a/test/cases/arm-linux/function_pointers.zig b/test/cases/arm-linux/function_pointers.zig
new file mode 100644
index 0000000000000000000000000000000000000000..0ef5df6745d804633632e894b586811e0636216d
--- /dev/null
+++ b/test/cases/arm-linux/function_pointers.zig
@@ -0,0 +1,44 @@
+const PrintFn = *const fn () void;
+
+pub fn main() void {
+    var printFn: PrintFn = stopSayingThat;
+    var i: u32 = 0;
+    while (i < 4) : (i += 1) printFn();
+
+    printFn = moveEveryZig;
+    printFn();
+}
+
+fn stopSayingThat() void {
+    asm volatile ("svc #0"
+        :
+        : [number] "{r7}" (4),
+          [arg1] "{r0}" (1),
+          [arg2] "{r1}" (@ptrToInt("Hello, my name is Inigo Montoya; you killed my father, prepare to die.\n")),
+          [arg3] "{r2}" ("Hello, my name is Inigo Montoya; you killed my father, prepare to die.\n".len),
+        : "memory"
+    );
+    return;
+}
+
+fn moveEveryZig() void {
+    asm volatile ("svc #0"
+        :
+        : [number] "{r7}" (4),
+          [arg1] "{r0}" (1),
+          [arg2] "{r1}" (@ptrToInt("All your codebase are belong to us\n")),
+          [arg3] "{r2}" ("All your codebase are belong to us\n".len),
+        : "memory"
+    );
+    return;
+}
+
+// run
+// target=arm-linux
+//
+// Hello, my name is Inigo Montoya; you killed my father, prepare to die.
+// Hello, my name is Inigo Montoya; you killed my father, prepare to die.
+// Hello, my name is Inigo Montoya; you killed my father, prepare to die.
+// Hello, my name is Inigo Montoya; you killed my father, prepare to die.
+// All your codebase are belong to us
+//
diff --git a/test/cases/arm-linux/hello_world_with_updates.0.zig b/test/cases/arm-linux/hello_world_with_updates.0.zig
new file mode 100644
index 0000000000000000000000000000000000000000..4ffdc2ae0f6d372aa809c590737536d468cabae1
--- /dev/null
+++ b/test/cases/arm-linux/hello_world_with_updates.0.zig
@@ -0,0 +1,32 @@
+pub export fn _start() noreturn {
+    print();
+    exit();
+}
+
+fn print() void {
+    asm volatile ("svc #0"
+        :
+        : [number] "{r7}" (4),
+          [arg1] "{r0}" (1),
+          [arg2] "{r1}" (@ptrToInt("Hello, World!\n")),
+          [arg3] "{r2}" (14),
+        : "memory"
+    );
+    return;
+}
+
+fn exit() noreturn {
+    asm volatile ("svc #0"
+        :
+        : [number] "{r7}" (1),
+          [arg1] "{r0}" (0),
+        : "memory"
+    );
+    unreachable;
+}
+
+// run
+// target=arm-linux
+//
+// Hello, World!
+//
diff --git a/test/cases/arm-linux/hello_world_with_updates.1.zig b/test/cases/arm-linux/hello_world_with_updates.1.zig
new file mode 100644
index 0000000000000000000000000000000000000000..8372d757ad8e448ab76cb5a2608e25307ffab904
--- /dev/null
+++ b/test/cases/arm-linux/hello_world_with_updates.1.zig
@@ -0,0 +1,37 @@
+pub export fn _start() noreturn {
+    print();
+    print();
+    print();
+    print();
+    exit();
+}
+
+fn print() void {
+    asm volatile ("svc #0"
+        :
+        : [number] "{r7}" (4),
+          [arg1] "{r0}" (1),
+          [arg2] "{r1}" (@ptrToInt("Hello, World!\n")),
+          [arg3] "{r2}" (14),
+        : "memory"
+    );
+    return;
+}
+
+fn exit() noreturn {
+    asm volatile ("svc #0"
+        :
+        : [number] "{r7}" (1),
+          [arg1] "{r0}" (0),
+        : "memory"
+    );
+    unreachable;
+}
+
+// run
+//
+// Hello, World!
+// Hello, World!
+// Hello, World!
+// Hello, World!
+//
diff --git a/test/cases/arm-linux/hello_world_with_updates.2.zig b/test/cases/arm-linux/hello_world_with_updates.2.zig
new file mode 100644
index 0000000000000000000000000000000000000000..0b97bf2360149f324a7314208e43cb31b74a39ee
--- /dev/null
+++ b/test/cases/arm-linux/hello_world_with_updates.2.zig
@@ -0,0 +1,22 @@
+pub fn main() void {
+    print();
+    print();
+}
+
+fn print() void {
+    asm volatile ("svc #0"
+        :
+        : [number] "{r7}" (4),
+          [arg1] "{r0}" (1),
+          [arg2] "{r1}" (@ptrToInt("Hello, World!\n")),
+          [arg3] "{r2}" (14),
+        : "memory"
+    );
+    return;
+}
+
+// run
+//
+// Hello, World!
+// Hello, World!
+//
diff --git a/test/cases/arm-linux/parameters_and_return_values.0.zig b/test/cases/arm-linux/parameters_and_return_values.0.zig
new file mode 100644
index 0000000000000000000000000000000000000000..6a306d802c2ad01609c73cc79cf6c81d9c6b7b07
--- /dev/null
+++ b/test/cases/arm-linux/parameters_and_return_values.0.zig
@@ -0,0 +1,28 @@
+pub fn main() void {
+    print(id(14));
+}
+
+fn id(x: u32) u32 {
+    return x;
+}
+
+// TODO: The parameters to the asm statement in print() had to
+// be in a specific order because otherwise the write to r0
+// would overwrite the len parameter which resides in r0
+fn print(len: u32) void {
+    asm volatile ("svc #0"
+        :
+        : [number] "{r7}" (4),
+          [arg3] "{r2}" (len),
+          [arg1] "{r0}" (1),
+          [arg2] "{r1}" (@ptrToInt("Hello, World!\n")),
+        : "memory"
+    );
+    return;
+}
+
+// run
+// target=arm-linux
+//
+// Hello, World!
+//
diff --git a/test/cases/arm-linux/parameters_and_return_values.1.zig b/test/cases/arm-linux/parameters_and_return_values.1.zig
new file mode 100644
index 0000000000000000000000000000000000000000..f2bc35d22ec6a7ac0b203bf257d10805815dc931
--- /dev/null
+++ b/test/cases/arm-linux/parameters_and_return_values.1.zig
@@ -0,0 +1,14 @@
+pub fn main() void {
+    assert(add(1, 2, 3, 4, 5, 6) == 21);
+}
+
+fn add(a: u32, b: u32, c: u32, d: u32, e: u32, f: u32) u32 {
+    return a + b + c + d + e + f;
+}
+
+pub fn assert(ok: bool) void {
+    if (!ok) unreachable; // assertion failure
+}
+
+// run
+//
diff --git a/test/cases/arm-linux/print_u32s.zig b/test/cases/arm-linux/print_u32s.zig
new file mode 100644
index 0000000000000000000000000000000000000000..92fad75ddf0a1f75e5d3c0ac6d04052166771cde
--- /dev/null
+++ b/test/cases/arm-linux/print_u32s.zig
@@ -0,0 +1,40 @@
+pub fn main() void {
+    printNumberHex(0x00000000);
+    printNumberHex(0xaaaaaaaa);
+    printNumberHex(0xdeadbeef);
+    printNumberHex(0x31415926);
+}
+
+fn printNumberHex(x: u32) void {
+    var i: u5 = 28;
+    while (true) : (i -= 4) {
+        const digit = (x >> i) & 0xf;
+        asm volatile ("svc #0"
+            :
+            : [number] "{r7}" (4),
+              [arg1] "{r0}" (1),
+              [arg2] "{r1}" (@ptrToInt("0123456789abcdef") + digit),
+              [arg3] "{r2}" (1),
+            : "memory"
+        );
+
+        if (i == 0) break;
+    }
+    asm volatile ("svc #0"
+        :
+        : [number] "{r7}" (4),
+          [arg1] "{r0}" (1),
+          [arg2] "{r1}" (@ptrToInt("\n")),
+          [arg3] "{r2}" (1),
+        : "memory"
+    );
+}
+
+// run
+// target=arm-linux
+//
+// 00000000
+// aaaaaaaa
+// deadbeef
+// 31415926
+//
diff --git a/test/cases/arm-linux/spilling_registers.0.zig b/test/cases/arm-linux/spilling_registers.0.zig
new file mode 100644
index 0000000000000000000000000000000000000000..ac74e071ad70f03a2d90f76c8d9cd9ca66f76095
--- /dev/null
+++ b/test/cases/arm-linux/spilling_registers.0.zig
@@ -0,0 +1,38 @@
+pub fn main() void {
+    assert(add(3, 4) == 791);
+}
+
+fn add(a: u32, b: u32) u32 {
+    const x: u32 = blk: {
+        const c = a + b; // 7
+        const d = a + c; // 10
+        const e = d + b; // 14
+        const f = d + e; // 24
+        const g = e + f; // 38
+        const h = f + g; // 62
+        const i = g + h; // 100
+        const j = i + d; // 110
+        const k = i + j; // 210
+        const l = k + c; // 217
+        const m = l + d; // 227
+        const n = m + e; // 241
+        const o = n + f; // 265
+        const p = o + g; // 303
+        const q = p + h; // 365
+        const r = q + i; // 465
+        const s = r + j; // 575
+        const t = s + k; // 785
+        break :blk t;
+    };
+    const y = x + a; // 788
+    const z = y + a; // 791
+    return z;
+}
+
+fn assert(ok: bool) void {
+    if (!ok) unreachable;
+}
+
+// run
+// target=arm-linux
+//
diff --git a/test/cases/arm-linux/spilling_registers.1.zig b/test/cases/arm-linux/spilling_registers.1.zig
new file mode 100644
index 0000000000000000000000000000000000000000..f401a5d7b7d1f29a9dc628315cff7e5b4e85d21c
--- /dev/null
+++ b/test/cases/arm-linux/spilling_registers.1.zig
@@ -0,0 +1,37 @@
+pub fn main() void {
+    assert(addMul(3, 4) == 357747496);
+}
+
+fn addMul(a: u32, b: u32) u32 {
+    const x: u32 = blk: {
+        const c = a + b; // 7
+        const d = a + c; // 10
+        const e = d + b; // 14
+        const f = d + e; // 24
+        const g = e + f; // 38
+        const h = f + g; // 62
+        const i = g + h; // 100
+        const j = i + d; // 110
+        const k = i + j; // 210
+        const l = k + c; // 217
+        const m = l * d; // 2170
+        const n = m + e; // 2184
+        const o = n * f; // 52416
+        const p = o + g; // 52454
+        const q = p * h; // 3252148
+        const r = q + i; // 3252248
+        const s = r * j; // 357747280
+        const t = s + k; // 357747490
+        break :blk t;
+    };
+    const y = x + a; // 357747493
+    const z = y + a; // 357747496
+    return z;
+}
+
+fn assert(ok: bool) void {
+    if (!ok) unreachable;
+}
+
+// run
+//
diff --git a/test/cases/bad_inferred_variable_type.zig b/test/cases/bad_inferred_variable_type.zig
new file mode 100644
index 0000000000000000000000000000000000000000..47ceb9b638185dbc9dafd3ec92900dfa5ad4d4cf
--- /dev/null
+++ b/test/cases/bad_inferred_variable_type.zig
@@ -0,0 +1,9 @@
+pub fn main() void {
+    var x = null;
+    _ = x;
+}
+
+// error
+// output_mode=Exe
+//
+// :2:9: error: variable of type '@TypeOf(null)' must be const or comptime
diff --git a/test/cases/binary_operands.0.zig b/test/cases/binary_operands.0.zig
new file mode 100644
index 0000000000000000000000000000000000000000..e3688232aa27c190ecfcbab4f4ea734093156d98
--- /dev/null
+++ b/test/cases/binary_operands.0.zig
@@ -0,0 +1,9 @@
+pub fn main() void {
+    var i: u8 = 5;
+    i += 20;
+    if (i != 25) unreachable;
+}
+
+// run
+// target=wasm32-wasi
+//
diff --git a/test/cases/binary_operands.1.zig b/test/cases/binary_operands.1.zig
new file mode 100644
index 0000000000000000000000000000000000000000..fdee492d227abb71eca039c996d32c6a24568d43
--- /dev/null
+++ b/test/cases/binary_operands.1.zig
@@ -0,0 +1,8 @@
+pub fn main() void {
+    var i: i32 = 2147483647;
+    if (i +% 1 != -2147483648) unreachable;
+    return;
+}
+
+// run
+//
diff --git a/test/cases/binary_operands.10.zig b/test/cases/binary_operands.10.zig
new file mode 100644
index 0000000000000000000000000000000000000000..63e045c258199ca9127804d16969e7ba2d4c9a64
--- /dev/null
+++ b/test/cases/binary_operands.10.zig
@@ -0,0 +1,13 @@
+pub fn main() void {
+    var i: u32 = 5;
+    i *= 7;
+    var result: u32 = foo(i, 10);
+    if (result != 350) unreachable;
+    return;
+}
+fn foo(x: u32, y: u32) u32 {
+    return x * y;
+}
+
+// run
+//
diff --git a/test/cases/binary_operands.11.zig b/test/cases/binary_operands.11.zig
new file mode 100644
index 0000000000000000000000000000000000000000..f461bcc0af9ba6cb1cae194c078fb53bcd6b24bd
--- /dev/null
+++ b/test/cases/binary_operands.11.zig
@@ -0,0 +1,9 @@
+pub fn main() void {
+    var i: i32 = 2147483647;
+    const result = i *% 2;
+    if (result != -2) unreachable;
+    return;
+}
+
+// run
+//
diff --git a/test/cases/binary_operands.12.zig b/test/cases/binary_operands.12.zig
new file mode 100644
index 0000000000000000000000000000000000000000..0ffb5e22309d4642af7b59c80999f2ce465d7c45
--- /dev/null
+++ b/test/cases/binary_operands.12.zig
@@ -0,0 +1,8 @@
+pub fn main() void {
+    var i: u3 = 3;
+    if (i *% 3 != 1) unreachable;
+    return;
+}
+
+// run
+//
diff --git a/test/cases/binary_operands.13.zig b/test/cases/binary_operands.13.zig
new file mode 100644
index 0000000000000000000000000000000000000000..e62107b47e71c7bb3d7a0cf2d8e9fcf9b8ee7a0c
--- /dev/null
+++ b/test/cases/binary_operands.13.zig
@@ -0,0 +1,8 @@
+pub fn main() void {
+    var i: i4 = 3;
+    if (i *% 3 != 1) unreachable;
+    return;
+}
+
+// run
+//
diff --git a/test/cases/binary_operands.14.zig b/test/cases/binary_operands.14.zig
new file mode 100644
index 0000000000000000000000000000000000000000..fcc7245ad97d3606a1d364981bbae5c1339cc8d7
--- /dev/null
+++ b/test/cases/binary_operands.14.zig
@@ -0,0 +1,13 @@
+pub fn main() void {
+    var i: u32 = 352;
+    i /= 7; // i = 50
+    var result: u32 = foo(i, 7);
+    if (result != 7) unreachable;
+    return;
+}
+fn foo(x: u32, y: u32) u32 {
+    return x / y;
+}
+
+// run
+//
diff --git a/test/cases/binary_operands.15.zig b/test/cases/binary_operands.15.zig
new file mode 100644
index 0000000000000000000000000000000000000000..c709e5dfd2327111b9ea86deaa341e12d148df0e
--- /dev/null
+++ b/test/cases/binary_operands.15.zig
@@ -0,0 +1,8 @@
+pub fn main() u8 {
+    var i: u8 = 5;
+    i &= 6;
+    return i - 4;
+}
+
+// run
+//
diff --git a/test/cases/binary_operands.16.zig b/test/cases/binary_operands.16.zig
new file mode 100644
index 0000000000000000000000000000000000000000..fe1813b8772784ea7a9617f755223f0ed34fefb1
--- /dev/null
+++ b/test/cases/binary_operands.16.zig
@@ -0,0 +1,8 @@
+pub fn main() u8 {
+    var i: u8 = 5;
+    i |= 6;
+    return i - 7;
+}
+
+// run
+//
diff --git a/test/cases/binary_operands.17.zig b/test/cases/binary_operands.17.zig
new file mode 100644
index 0000000000000000000000000000000000000000..439d3d6d6b59699ca309a7705ac83b312fd33b9b
--- /dev/null
+++ b/test/cases/binary_operands.17.zig
@@ -0,0 +1,8 @@
+pub fn main() u8 {
+    var i: u8 = 5;
+    i ^= 6;
+    return i - 3;
+}
+
+// run
+//
diff --git a/test/cases/binary_operands.18.zig b/test/cases/binary_operands.18.zig
new file mode 100644
index 0000000000000000000000000000000000000000..c21aa586c555e8fd882ba31a0bbbe5169e6ff5e0
--- /dev/null
+++ b/test/cases/binary_operands.18.zig
@@ -0,0 +1,9 @@
+pub fn main() void {
+    var b: bool = false;
+    b = b or false;
+    if (b) unreachable;
+    return;
+}
+
+// run
+//
diff --git a/test/cases/binary_operands.19.zig b/test/cases/binary_operands.19.zig
new file mode 100644
index 0000000000000000000000000000000000000000..e95470391cf1bec9d9412b1b4156eb26d77669f7
--- /dev/null
+++ b/test/cases/binary_operands.19.zig
@@ -0,0 +1,9 @@
+pub fn main() void {
+    var b: bool = true;
+    b = b or false;
+    if (!b) unreachable;
+    return;
+}
+
+// run
+//
diff --git a/test/cases/binary_operands.2.zig b/test/cases/binary_operands.2.zig
new file mode 100644
index 0000000000000000000000000000000000000000..7407ed7d9558f22956f631ac9af4edbf31edc24e
--- /dev/null
+++ b/test/cases/binary_operands.2.zig
@@ -0,0 +1,8 @@
+pub fn main() void {
+    var i: i4 = 7;
+    if (i +% 1 != 0) unreachable;
+    return;
+}
+
+// run
+//
diff --git a/test/cases/binary_operands.20.zig b/test/cases/binary_operands.20.zig
new file mode 100644
index 0000000000000000000000000000000000000000..9238bf97c04ed9e5dbb0cc98634eecf96de9fa40
--- /dev/null
+++ b/test/cases/binary_operands.20.zig
@@ -0,0 +1,9 @@
+pub fn main() void {
+    var b: bool = false;
+    b = b or true;
+    if (!b) unreachable;
+    return;
+}
+
+// run
+//
diff --git a/test/cases/binary_operands.21.zig b/test/cases/binary_operands.21.zig
new file mode 100644
index 0000000000000000000000000000000000000000..a2d427bda9d66dbdcb59d300ffbab4e1a6af9076
--- /dev/null
+++ b/test/cases/binary_operands.21.zig
@@ -0,0 +1,9 @@
+pub fn main() void {
+    var b: bool = true;
+    b = b or true;
+    if (!b) unreachable;
+    return;
+}
+
+// run
+//
diff --git a/test/cases/binary_operands.22.zig b/test/cases/binary_operands.22.zig
new file mode 100644
index 0000000000000000000000000000000000000000..aa8439a36189db87ef416602872feb38a3b17993
--- /dev/null
+++ b/test/cases/binary_operands.22.zig
@@ -0,0 +1,9 @@
+pub fn main() void {
+    var b: bool = false;
+    b = b and false;
+    if (b) unreachable;
+    return;
+}
+
+// run
+//
diff --git a/test/cases/binary_operands.23.zig b/test/cases/binary_operands.23.zig
new file mode 100644
index 0000000000000000000000000000000000000000..8596ea77098058f4d23bab966d0cad540704df09
--- /dev/null
+++ b/test/cases/binary_operands.23.zig
@@ -0,0 +1,9 @@
+pub fn main() void {
+    var b: bool = true;
+    b = b and false;
+    if (b) unreachable;
+    return;
+}
+
+// run
+//
diff --git a/test/cases/binary_operands.24.zig b/test/cases/binary_operands.24.zig
new file mode 100644
index 0000000000000000000000000000000000000000..08dc4430a2298ea934e15c140c9aa0f6d65b7603
--- /dev/null
+++ b/test/cases/binary_operands.24.zig
@@ -0,0 +1,9 @@
+pub fn main() void {
+    var b: bool = false;
+    b = b and true;
+    if (b) unreachable;
+    return;
+}
+
+// run
+//
diff --git a/test/cases/binary_operands.25.zig b/test/cases/binary_operands.25.zig
new file mode 100644
index 0000000000000000000000000000000000000000..8aa0acfdb558d082ea40c2533b30502315aa59e3
--- /dev/null
+++ b/test/cases/binary_operands.25.zig
@@ -0,0 +1,9 @@
+pub fn main() void {
+    var b: bool = true;
+    b = b and true;
+    if (!b) unreachable;
+    return;
+}
+
+// run
+//
diff --git a/test/cases/binary_operands.3.zig b/test/cases/binary_operands.3.zig
new file mode 100644
index 0000000000000000000000000000000000000000..0297f1e7a48a877295b059a36e0fc958e2033f61
--- /dev/null
+++ b/test/cases/binary_operands.3.zig
@@ -0,0 +1,7 @@
+pub fn main() u8 {
+    var i: u8 = 255;
+    return i +% 1;
+}
+
+// run
+//
diff --git a/test/cases/binary_operands.4.zig b/test/cases/binary_operands.4.zig
new file mode 100644
index 0000000000000000000000000000000000000000..f0f8910e1463b4127d7da741907491cbbee4394a
--- /dev/null
+++ b/test/cases/binary_operands.4.zig
@@ -0,0 +1,12 @@
+pub fn main() u8 {
+    var i: u8 = 5;
+    i += 20;
+    var result: u8 = foo(i, 10);
+    return result - 35;
+}
+fn foo(x: u8, y: u8) u8 {
+    return x + y;
+}
+
+// run
+//
diff --git a/test/cases/binary_operands.5.zig b/test/cases/binary_operands.5.zig
new file mode 100644
index 0000000000000000000000000000000000000000..51ab437475684082b941075aa3ba636f7985977a
--- /dev/null
+++ b/test/cases/binary_operands.5.zig
@@ -0,0 +1,8 @@
+pub fn main() u8 {
+    var i: u8 = 20;
+    i -= 5;
+    return i - 15;
+}
+
+// run
+//
diff --git a/test/cases/binary_operands.6.zig b/test/cases/binary_operands.6.zig
new file mode 100644
index 0000000000000000000000000000000000000000..5c9c5be68aa1364a8f782aaab099532cd6dde297
--- /dev/null
+++ b/test/cases/binary_operands.6.zig
@@ -0,0 +1,8 @@
+pub fn main() void {
+    var i: i32 = -2147483648;
+    if (i -% 1 != 2147483647) unreachable;
+    return;
+}
+
+// run
+//
diff --git a/test/cases/binary_operands.7.zig b/test/cases/binary_operands.7.zig
new file mode 100644
index 0000000000000000000000000000000000000000..634a47fb0ce4042bd71d386044a2077109f39356
--- /dev/null
+++ b/test/cases/binary_operands.7.zig
@@ -0,0 +1,8 @@
+pub fn main() void {
+    var i: i7 = -64;
+    if (i -% 1 != 63) unreachable;
+    return;
+}
+
+// run
+//
diff --git a/test/cases/binary_operands.8.zig b/test/cases/binary_operands.8.zig
new file mode 100644
index 0000000000000000000000000000000000000000..a20f6646944d35e89980743212ce060d9b3e5930
--- /dev/null
+++ b/test/cases/binary_operands.8.zig
@@ -0,0 +1,7 @@
+pub fn main() void {
+    var i: u4 = 0;
+    if (i -% 1 != 15) unreachable;
+}
+
+// run
+//
diff --git a/test/cases/binary_operands.9.zig b/test/cases/binary_operands.9.zig
new file mode 100644
index 0000000000000000000000000000000000000000..e6c4f5d52b491158f629ec74f7b0f16f624f94ac
--- /dev/null
+++ b/test/cases/binary_operands.9.zig
@@ -0,0 +1,12 @@
+pub fn main() u8 {
+    var i: u8 = 5;
+    i -= 3;
+    var result: u8 = foo(i, 10);
+    return result - 8;
+}
+fn foo(x: u8, y: u8) u8 {
+    return y - x;
+}
+
+// run
+//
diff --git a/test/cases/break_continue.0.zig b/test/cases/break_continue.0.zig
new file mode 100644
index 0000000000000000000000000000000000000000..ac0abdb52dadc98760d9ac2d1b466b185e8bd90d
--- /dev/null
+++ b/test/cases/break_continue.0.zig
@@ -0,0 +1,9 @@
+pub fn main() void {
+    while (true) {
+        break;
+    }
+}
+
+// run
+// target=x86_64-linux,x86_64-macos,aarch64-linux,aarch64-macos
+//
diff --git a/test/cases/break_continue.1.zig b/test/cases/break_continue.1.zig
new file mode 100644
index 0000000000000000000000000000000000000000..9e4f79bd14d7a1340b9fcbc02c271790c642bd07
--- /dev/null
+++ b/test/cases/break_continue.1.zig
@@ -0,0 +1,8 @@
+pub fn main() void {
+    foo: while (true) {
+        break :foo;
+    }
+}
+
+// run
+//
diff --git a/test/cases/break_continue.2.zig b/test/cases/break_continue.2.zig
new file mode 100644
index 0000000000000000000000000000000000000000..ba12f33e3f05b3419a5f3f84631e3d52a3ce9eec
--- /dev/null
+++ b/test/cases/break_continue.2.zig
@@ -0,0 +1,10 @@
+pub fn main() void {
+    var i: u64 = 0;
+    while (true) : (i += 1) {
+        if (i == 4) return;
+        continue;
+    }
+}
+
+// run
+//
diff --git a/test/cases/break_continue.3.zig b/test/cases/break_continue.3.zig
new file mode 100644
index 0000000000000000000000000000000000000000..03e224d26545d7c8d67617dd0a4fb609b6d80405
--- /dev/null
+++ b/test/cases/break_continue.3.zig
@@ -0,0 +1,10 @@
+pub fn main() void {
+    var i: u64 = 0;
+    foo: while (true) : (i += 1) {
+        if (i == 4) return;
+        continue :foo;
+    }
+}
+
+// run
+//
diff --git a/test/cases/catch_at_comptime.0.zig b/test/cases/catch_at_comptime.0.zig
new file mode 100644
index 0000000000000000000000000000000000000000..af1545832dee3b3e558a463ebf9ac75ad36b346e
--- /dev/null
+++ b/test/cases/catch_at_comptime.0.zig
@@ -0,0 +1,11 @@
+pub fn main() void {
+    const i: anyerror!u64 = 0;
+    const caught = i catch 5;
+    assert(caught == 0);
+}
+fn assert(b: bool) void {
+    if (!b) unreachable;
+}
+
+// run
+//
diff --git a/test/cases/catch_at_comptime.1.zig b/test/cases/catch_at_comptime.1.zig
new file mode 100644
index 0000000000000000000000000000000000000000..e05caeae6d9f058b730777d4868e85850dd776c5
--- /dev/null
+++ b/test/cases/catch_at_comptime.1.zig
@@ -0,0 +1,11 @@
+pub fn main() void {
+    const i: anyerror!u64 = error.B;
+    const caught = i catch 5;
+    assert(caught == 5);
+}
+fn assert(b: bool) void {
+    if (!b) unreachable;
+}
+
+// run
+//
diff --git a/test/cases/catch_at_comptime.2.zig b/test/cases/catch_at_comptime.2.zig
new file mode 100644
index 0000000000000000000000000000000000000000..326e6f0b61a4c8a651130c6767a72d77617506a6
--- /dev/null
+++ b/test/cases/catch_at_comptime.2.zig
@@ -0,0 +1,11 @@
+pub fn main() void {
+    const a: anyerror!comptime_int = 42;
+    const b: *const comptime_int = &(a catch unreachable);
+    assert(b.* == 42);
+}
+fn assert(b: bool) void {
+    if (!b) unreachable; // assertion failure
+}
+
+// run
+//
diff --git a/test/cases/catch_at_comptime.3.zig b/test/cases/catch_at_comptime.3.zig
new file mode 100644
index 0000000000000000000000000000000000000000..d00317f697426e19c149abb0e89ae171d0427f45
--- /dev/null
+++ b/test/cases/catch_at_comptime.3.zig
@@ -0,0 +1,10 @@
+pub fn main() void {
+    const a: anyerror!u32 = error.B;
+    _ = &(a catch |err| assert(err == error.B));
+}
+fn assert(b: bool) void {
+    if (!b) unreachable;
+}
+
+// run
+//
diff --git a/test/cases/catch_at_comptime.4.zig b/test/cases/catch_at_comptime.4.zig
new file mode 100644
index 0000000000000000000000000000000000000000..57cb602641ded47982e332f2fbe5f484fa64363f
--- /dev/null
+++ b/test/cases/catch_at_comptime.4.zig
@@ -0,0 +1,10 @@
+pub fn main() void {
+    const a: anyerror!u32 = error.Bar;
+    a catch |err| assert(err == error.Bar);
+}
+fn assert(b: bool) void {
+    if (!b) unreachable;
+}
+
+// run
+//
diff --git a/test/cases/compile_error.zig b/test/cases/compile_error.zig
new file mode 100644
index 0000000000000000000000000000000000000000..dab0f7f7cc9fd2dc36d0bab8dcdaa5b1dbc6fdfb
--- /dev/null
+++ b/test/cases/compile_error.zig
@@ -0,0 +1,7 @@
+export fn foo() void {
+    @compileError("this is an error");
+}
+
+// error
+//
+// :2:5: error: this is an error
diff --git a/test/cases/compile_error_in_inline_fn_call_fixed.0.zig b/test/cases/compile_error_in_inline_fn_call_fixed.0.zig
new file mode 100644
index 0000000000000000000000000000000000000000..1848490b0794abeb37eddb4f413e96cc013f976a
--- /dev/null
+++ b/test/cases/compile_error_in_inline_fn_call_fixed.0.zig
@@ -0,0 +1,16 @@
+pub fn main() void {
+    var x: usize = 3;
+    const y = add(10, 2, x);
+    if (y - 6 != 0) unreachable;
+}
+
+inline fn add(a: usize, b: usize, c: usize) usize {
+    if (a == 10) @compileError("bad");
+    return a + b + c;
+}
+
+// error
+// output_mode=Exe
+//
+// :8:18: error: bad
+// :3:18: note: called from here
diff --git a/test/cases/compile_error_in_inline_fn_call_fixed.1.zig b/test/cases/compile_error_in_inline_fn_call_fixed.1.zig
new file mode 100644
index 0000000000000000000000000000000000000000..1e61c6c790fd3b9f7bde2c5de0ce5b67421bdc1e
--- /dev/null
+++ b/test/cases/compile_error_in_inline_fn_call_fixed.1.zig
@@ -0,0 +1,13 @@
+pub fn main() void {
+    var x: usize = 3;
+    const y = add(1, 2, x);
+    if (y - 6 != 0) unreachable;
+}
+
+inline fn add(a: usize, b: usize, c: usize) usize {
+    if (a == 10) @compileError("bad");
+    return a + b + c;
+}
+
+// run
+//
diff --git a/test/cases/compile_errors/stage1/exe/main_missing_name.zig b/test/cases/compile_errors/stage1/exe/main_missing_name.zig
new file mode 100644
index 0000000000000000000000000000000000000000..1a53e43cfba2967b5cda0210b92a51714634339d
--- /dev/null
+++ b/test/cases/compile_errors/stage1/exe/main_missing_name.zig
@@ -0,0 +1,8 @@
+pub fn (main) void {}
+
+// error
+// backend=stage1
+// target=native
+// output_mode=Exe
+//
+// tmp.zig:1:5: error: missing function name
diff --git a/test/cases/compile_errors/stage1/exe/missing_main_fn_in_executable.zig b/test/cases/compile_errors/stage1/exe/missing_main_fn_in_executable.zig
new file mode 100644
index 0000000000000000000000000000000000000000..65813abac32cf8541b18e12235a16a7cac85f6f0
--- /dev/null
+++ b/test/cases/compile_errors/stage1/exe/missing_main_fn_in_executable.zig
@@ -0,0 +1,8 @@
+
+
+// error
+// backend=stage1
+// target=native
+// output_mode=Exe
+//
+// error: root source file has no member called 'main'
diff --git a/test/cases/compile_errors/stage1/exe/private_main_fn.zig b/test/cases/compile_errors/stage1/exe/private_main_fn.zig
new file mode 100644
index 0000000000000000000000000000000000000000..5a178389e8905d908a3b35a79fa872d9db20940e
--- /dev/null
+++ b/test/cases/compile_errors/stage1/exe/private_main_fn.zig
@@ -0,0 +1,9 @@
+fn main() void {}
+
+// error
+// backend=stage1
+// target=native
+// output_mode=Exe
+//
+// error: 'main' is private
+// tmp.zig:1:1: note: declared here
diff --git a/test/cases/compile_errors/stage1/obj/C_pointer_pointing_to_non_C_ABI_compatible_type_or_has_align_attr.zig b/test/cases/compile_errors/stage1/obj/C_pointer_pointing_to_non_C_ABI_compatible_type_or_has_align_attr.zig
new file mode 100644
index 0000000000000000000000000000000000000000..72c58adbd61cc3a505f7b6f69966e60d63095820
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/C_pointer_pointing_to_non_C_ABI_compatible_type_or_has_align_attr.zig
@@ -0,0 +1,12 @@
+const Foo = struct {};
+export fn a() void {
+    const T = [*c]Foo;
+    var t: T = undefined;
+    _ = t;
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:3:19: error: C pointers cannot point to non-C-ABI-compatible type 'Foo'
diff --git a/test/cases/compile_errors/stage1/obj/C_pointer_to_anyopaque.zig b/test/cases/compile_errors/stage1/obj/C_pointer_to_anyopaque.zig
new file mode 100644
index 0000000000000000000000000000000000000000..36c9789d20f263caa9a96eb2a1fc46fc2fba496c
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/C_pointer_to_anyopaque.zig
@@ -0,0 +1,11 @@
+export fn a() void {
+    var x: *anyopaque = undefined;
+    var y: [*c]anyopaque = x;
+    _ = y;
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:3:16: error: C pointers cannot point to opaque types
diff --git a/test/cases/compile_errors/stage1/obj/Frame_of_generic_function.zig b/test/cases/compile_errors/stage1/obj/Frame_of_generic_function.zig
new file mode 100644
index 0000000000000000000000000000000000000000..d90e53eb4683dba5f55a8e99388d04f47aa91390
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/Frame_of_generic_function.zig
@@ -0,0 +1,14 @@
+export fn entry() void {
+    var frame: @Frame(func) = undefined;
+    _ = frame;
+}
+fn func(comptime T: type) void {
+    var x: T = undefined;
+    _ = x;
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:2:16: error: @Frame() of generic function
diff --git a/test/cases/compile_errors/stage1/obj/Issue_5586_Make_unary_minus_for_unsigned_types_a_compile_error.zig b/test/cases/compile_errors/stage1/obj/Issue_5586_Make_unary_minus_for_unsigned_types_a_compile_error.zig
new file mode 100644
index 0000000000000000000000000000000000000000..e1d498e65f40a2e2583e684186d0f6921cf974ef
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/Issue_5586_Make_unary_minus_for_unsigned_types_a_compile_error.zig
@@ -0,0 +1,16 @@
+export fn f1(x: u32) u32 {
+    const y = -%x;
+    return -y;
+}
+const V = @import("std").meta.Vector;
+export fn f2(x: V(4, u32)) V(4, u32) {
+    const y = -%x;
+    return -y;
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:3:12: error: negation of type 'u32'
+// tmp.zig:8:12: error: negation of type 'u32'
diff --git a/test/cases/compile_errors/stage1/obj/Issue_6823_dont_allow_._to_be_followed_by_.zig b/test/cases/compile_errors/stage1/obj/Issue_6823_dont_allow_._to_be_followed_by_.zig
new file mode 100644
index 0000000000000000000000000000000000000000..1aa0996ba4d7abacfb09a0aff758cd3bca61424c
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/Issue_6823_dont_allow_._to_be_followed_by_.zig
@@ -0,0 +1,10 @@
+fn foo() void {
+    var sequence = "repeat".*** 10;
+    _ = sequence;
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:2:28: error: '.*' cannot be followed by '*'. Are you missing a space?
diff --git a/test/cases/compile_errors/stage1/obj/Issue_9165_windows_tcp_server_compilation_error.zig b/test/cases/compile_errors/stage1/obj/Issue_9165_windows_tcp_server_compilation_error.zig
new file mode 100644
index 0000000000000000000000000000000000000000..3d150693f556edec171b11cc9f0f851c57336fb2
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/Issue_9165_windows_tcp_server_compilation_error.zig
@@ -0,0 +1,16 @@
+const std = @import("std");
+const builtin = @import("builtin");
+pub const io_mode = .evented;
+pub fn main() !void {
+    if (builtin.os.tag == .windows) {
+        _ = try (std.net.StreamServer.init(.{})).accept();
+    } else {
+        @compileError("Unsupported OS");
+    }
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// error: Unsupported OS
diff --git a/test/cases/compile_errors/stage1/obj/access_non-existent_member_of_error_set.zig b/test/cases/compile_errors/stage1/obj/access_non-existent_member_of_error_set.zig
new file mode 100644
index 0000000000000000000000000000000000000000..caddf36a8436cd538c181efc3974f34f7812b7a4
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/access_non-existent_member_of_error_set.zig
@@ -0,0 +1,11 @@
+const Foo = error{A};
+comptime {
+    const z = Foo.Bar;
+    _ = z;
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:3:18: error: no error named 'Bar' in 'Foo'
diff --git a/test/cases/compile_errors/stage1/obj/accessing_runtime_parameter_from_outer_function.zig b/test/cases/compile_errors/stage1/obj/accessing_runtime_parameter_from_outer_function.zig
new file mode 100644
index 0000000000000000000000000000000000000000..73a9e94d4428df5a3de41ef013bf99abe4d5b882
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/accessing_runtime_parameter_from_outer_function.zig
@@ -0,0 +1,21 @@
+fn outer(y: u32) fn (u32) u32 {
+    const st = struct {
+        fn get(z: u32) u32 {
+            return z + y;
+        }
+    };
+    return st.get;
+}
+export fn entry() void {
+    var func = outer(10);
+    var x = func(3);
+    _ = x;
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:4:24: error: 'y' not accessible from inner function
+// tmp.zig:3:28: note: crossed function definition here
+// tmp.zig:1:10: note: declared here
diff --git a/test/cases/compile_errors/stage1/obj/add_assign_on_undefined_value.zig b/test/cases/compile_errors/stage1/obj/add_assign_on_undefined_value.zig
new file mode 100644
index 0000000000000000000000000000000000000000..38e4fef81bc124e03c07c0b029c2b2f7e1d6ede0
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/add_assign_on_undefined_value.zig
@@ -0,0 +1,10 @@
+comptime {
+    var a: i64 = undefined;
+    a += a;
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:3:5: error: use of undefined value here causes undefined behavior
diff --git a/test/cases/compile_errors/stage1/obj/add_on_undefined_value.zig b/test/cases/compile_errors/stage1/obj/add_on_undefined_value.zig
new file mode 100644
index 0000000000000000000000000000000000000000..4a66f9c102ba452512e78a9320bb008b77179a02
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/add_on_undefined_value.zig
@@ -0,0 +1,10 @@
+comptime {
+    var a: i64 = undefined;
+    _ = a + a;
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:3:9: error: use of undefined value here causes undefined behavior
diff --git a/test/cases/compile_errors/stage1/obj/add_overflow_in_function_evaluation.zig b/test/cases/compile_errors/stage1/obj/add_overflow_in_function_evaluation.zig
new file mode 100644
index 0000000000000000000000000000000000000000..d4fa312482d942eb5d787956a072635cb674bf26
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/add_overflow_in_function_evaluation.zig
@@ -0,0 +1,12 @@
+const y = add(65530, 10);
+fn add(a: u16, b: u16) u16 {
+    return a + b;
+}
+
+export fn entry() usize { return @sizeOf(@TypeOf(y)); }
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:3:14: error: operation caused overflow
diff --git a/test/cases/compile_errors/stage1/obj/add_wrap_assign_on_undefined_value.zig b/test/cases/compile_errors/stage1/obj/add_wrap_assign_on_undefined_value.zig
new file mode 100644
index 0000000000000000000000000000000000000000..5f9a4c61fc34d83790db326f1cc925c70c70fe85
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/add_wrap_assign_on_undefined_value.zig
@@ -0,0 +1,10 @@
+comptime {
+    var a: i64 = undefined;
+    a +%= a;
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:3:5: error: use of undefined value here causes undefined behavior
diff --git a/test/cases/compile_errors/stage1/obj/add_wrap_on_undefined_value.zig b/test/cases/compile_errors/stage1/obj/add_wrap_on_undefined_value.zig
new file mode 100644
index 0000000000000000000000000000000000000000..582b8ec1cfc85ff91224f11799f78631c75a2951
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/add_wrap_on_undefined_value.zig
@@ -0,0 +1,10 @@
+comptime {
+    var a: i64 = undefined;
+    _ = a +% a;
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:3:9: error: use of undefined value here causes undefined behavior
diff --git a/test/cases/compile_errors/stage1/obj/addition_with_non_numbers.zig b/test/cases/compile_errors/stage1/obj/addition_with_non_numbers.zig
new file mode 100644
index 0000000000000000000000000000000000000000..8f343926f281ffa3efb54881f03a5f4bd4b4f87f
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/addition_with_non_numbers.zig
@@ -0,0 +1,12 @@
+const Foo = struct {
+    field: i32,
+};
+const x = Foo {.field = 1} + Foo {.field = 2};
+
+export fn entry() usize { return @sizeOf(@TypeOf(x)); }
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:4:28: error: invalid operands to binary expression: 'Foo' and 'Foo'
diff --git a/test/cases/compile_errors/stage1/obj/address_of_number_literal.zig b/test/cases/compile_errors/stage1/obj/address_of_number_literal.zig
new file mode 100644
index 0000000000000000000000000000000000000000..76d321929d9863e9d2ac1a8fece85e4d12ad2d72
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/address_of_number_literal.zig
@@ -0,0 +1,10 @@
+const x = 3;
+const y = &x;
+fn foo() *const i32 { return y; }
+export fn entry() usize { return @sizeOf(@TypeOf(foo)); }
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:3:30: error: expected type '*const i32', found '*const comptime_int'
diff --git a/test/cases/compile_errors/stage1/obj/alignCast_expects_pointer_or_slice.zig b/test/cases/compile_errors/stage1/obj/alignCast_expects_pointer_or_slice.zig
new file mode 100644
index 0000000000000000000000000000000000000000..9f76d3ca4fff45a35b9c12c30ba95260f50a9702
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/alignCast_expects_pointer_or_slice.zig
@@ -0,0 +1,9 @@
+export fn entry() void {
+    @alignCast(4, @as(u32, 3));
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:2:19: error: expected pointer or slice, found 'u32'
diff --git a/test/cases/compile_errors/stage1/obj/align_n_expr_function_pointers_is_a_compile_error.zig b/test/cases/compile_errors/stage1/obj/align_n_expr_function_pointers_is_a_compile_error.zig
new file mode 100644
index 0000000000000000000000000000000000000000..bd41b3e6574b317af3c5e0c1554b8bf39533f7bd
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/align_n_expr_function_pointers_is_a_compile_error.zig
@@ -0,0 +1,9 @@
+export fn foo() align(1) void {
+    return;
+}
+
+// error
+// backend=stage1
+// target=wasm32-freestanding-none
+//
+// tmp.zig:1:23: error: align(N) expr is not allowed on function prototypes in wasm32/wasm64
diff --git a/test/cases/compile_errors/stage1/obj/aligned_variable_of_zero-bit_type.zig b/test/cases/compile_errors/stage1/obj/aligned_variable_of_zero-bit_type.zig
new file mode 100644
index 0000000000000000000000000000000000000000..f09f92aca782d98925abbe67f50ae573cbce32e0
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/aligned_variable_of_zero-bit_type.zig
@@ -0,0 +1,10 @@
+export fn f() void {
+    var s: struct {} align(4) = undefined;
+    _ = s;
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:2:5: error: variable 's' of zero-bit type 'struct:2:12' has no in-memory representation, it cannot be aligned
diff --git a/test/cases/compile_errors/stage1/obj/alignment_of_enum_field_specified.zig b/test/cases/compile_errors/stage1/obj/alignment_of_enum_field_specified.zig
new file mode 100644
index 0000000000000000000000000000000000000000..9b6f1e452d2dd76f36ecf750d232ae9a07ec0e3f
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/alignment_of_enum_field_specified.zig
@@ -0,0 +1,14 @@
+const Number = enum {
+    a,
+    b align(i32),
+};
+export fn entry1() void {
+    var x: Number = undefined;
+    _ = x;
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:3:7: error: expected ',' after field
diff --git a/test/cases/compile_errors/stage1/obj/ambiguous_decl_reference.zig b/test/cases/compile_errors/stage1/obj/ambiguous_decl_reference.zig
new file mode 100644
index 0000000000000000000000000000000000000000..82e6a0a24cadfc2539c66dcc54f07691d6c9815d
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/ambiguous_decl_reference.zig
@@ -0,0 +1,21 @@
+fn foo() void {}
+fn bar() void {
+    const S = struct {
+        fn baz() void {
+            foo();
+        }
+        fn foo() void {}
+    };
+    S.baz();
+}
+export fn entry() void {
+    bar();
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:5:13: error: ambiguous reference
+// tmp.zig:7:9: note: declared here
+// tmp.zig:1:1: note: also declared here
diff --git a/test/cases/compile_errors/stage1/obj/and_on_undefined_value.zig b/test/cases/compile_errors/stage1/obj/and_on_undefined_value.zig
new file mode 100644
index 0000000000000000000000000000000000000000..6071d81062fcc32291a7673bcb6e2877ea7d3358
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/and_on_undefined_value.zig
@@ -0,0 +1,10 @@
+comptime {
+    var a: bool = undefined;
+    _ = a and a;
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:3:9: error: use of undefined value here causes undefined behavior
diff --git a/test/cases/compile_errors/stage1/obj/array_access_of_non_array.zig b/test/cases/compile_errors/stage1/obj/array_access_of_non_array.zig
new file mode 100644
index 0000000000000000000000000000000000000000..7045f2fdbd304867e7e52ce889c7f69212923e74
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/array_access_of_non_array.zig
@@ -0,0 +1,15 @@
+export fn f() void {
+    var bad : bool = undefined;
+    bad[0] = bad[0];
+}
+export fn g() void {
+    var bad : bool = undefined;
+    _ = bad[0];
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:3:8: error: array access of non-array type 'bool'
+// tmp.zig:7:12: error: array access of non-array type 'bool'
diff --git a/test/cases/compile_errors/stage1/obj/array_access_of_type.zig b/test/cases/compile_errors/stage1/obj/array_access_of_type.zig
new file mode 100644
index 0000000000000000000000000000000000000000..c0029f24924ee24368470c500f05d2b66e26d233
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/array_access_of_type.zig
@@ -0,0 +1,10 @@
+export fn foo() void {
+    var b: u8[40] = undefined;
+    _ = b;
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:2:14: error: array access of non-array type 'type'
diff --git a/test/cases/compile_errors/stage1/obj/array_access_of_undeclared_identifier.zig b/test/cases/compile_errors/stage1/obj/array_access_of_undeclared_identifier.zig
new file mode 100644
index 0000000000000000000000000000000000000000..7d16a0d60e6d9465bba265454034a66a67e2dac0
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/array_access_of_undeclared_identifier.zig
@@ -0,0 +1,9 @@
+export fn f() void {
+    i[i] = i[i];
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:2:5: error: use of undeclared identifier 'i'
diff --git a/test/cases/compile_errors/stage1/obj/array_access_with_non_integer_index.zig b/test/cases/compile_errors/stage1/obj/array_access_with_non_integer_index.zig
new file mode 100644
index 0000000000000000000000000000000000000000..de0a58656c5789a4f3689cf0a9a7eeed41a6fd26
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/array_access_with_non_integer_index.zig
@@ -0,0 +1,17 @@
+export fn f() void {
+    var array = "aoeu";
+    var bad = false;
+    array[bad] = array[bad];
+}
+export fn g() void {
+    var array = "aoeu";
+    var bad = false;
+    _ = array[bad];
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:4:11: error: expected type 'usize', found 'bool'
+// tmp.zig:9:15: error: expected type 'usize', found 'bool'
diff --git a/test/cases/compile_errors/stage1/obj/array_concatenation_with_wrong_type.zig b/test/cases/compile_errors/stage1/obj/array_concatenation_with_wrong_type.zig
new file mode 100644
index 0000000000000000000000000000000000000000..ccddc7efbd5b2b37ba81375cad57fda646d78988
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/array_concatenation_with_wrong_type.zig
@@ -0,0 +1,11 @@
+const src = "aoeu";
+const derp: usize = 1234;
+const a = derp ++ "foo";
+
+export fn entry() usize { return @sizeOf(@TypeOf(a)); }
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:3:11: error: expected array, found 'usize'
diff --git a/test/cases/compile_errors/stage1/obj/array_in_c_exported_function.zig b/test/cases/compile_errors/stage1/obj/array_in_c_exported_function.zig
new file mode 100644
index 0000000000000000000000000000000000000000..5137755474a6ed7bcfa530a6463232db78a9142f
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/array_in_c_exported_function.zig
@@ -0,0 +1,14 @@
+export fn zig_array(x: [10]u8) void {
+    try std.testing.expect(std.mem.eql(u8, &x, "1234567890"));
+}
+const std = @import("std");
+export fn zig_return_array() [10]u8 {
+    return "1234567890".*;
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:1:24: error: parameter of type '[10]u8' not allowed in function with calling convention 'C'
+// tmp.zig:5:30: error: return type '[10]u8' not allowed in function with calling convention 'C'
diff --git a/test/cases/compile_errors/stage1/obj/asm_at_compile_time.zig b/test/cases/compile_errors/stage1/obj/asm_at_compile_time.zig
new file mode 100644
index 0000000000000000000000000000000000000000..fcfd5e7da6b1df490029c1f9e6213d3dc90ab6d1
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/asm_at_compile_time.zig
@@ -0,0 +1,17 @@
+comptime {
+    doSomeAsm();
+}
+
+fn doSomeAsm() void {
+    asm volatile (
+        \\.globl aoeu;
+        \\.type aoeu, @function;
+        \\.set aoeu, derp;
+    );
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:6:5: error: unable to evaluate constant expression
diff --git a/test/cases/compile_errors/stage1/obj/assign_inline_fn_to_non-comptime_var.zig b/test/cases/compile_errors/stage1/obj/assign_inline_fn_to_non-comptime_var.zig
new file mode 100644
index 0000000000000000000000000000000000000000..7714bb728293133efdcad1c65208995d8d81b8a1
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/assign_inline_fn_to_non-comptime_var.zig
@@ -0,0 +1,12 @@
+export fn entry() void {
+    var a = b;
+    _ = a;
+}
+fn b() callconv(.Inline) void { }
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:2:5: error: functions marked inline must be stored in const or comptime var
+// tmp.zig:5:1: note: declared here
diff --git a/test/cases/compile_errors/stage1/obj/assign_null_to_non-optional_pointer.zig b/test/cases/compile_errors/stage1/obj/assign_null_to_non-optional_pointer.zig
new file mode 100644
index 0000000000000000000000000000000000000000..110d6c26299e260fc40c5e5d329e34f5048a0eb3
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/assign_null_to_non-optional_pointer.zig
@@ -0,0 +1,9 @@
+const a: *u8 = null;
+
+export fn entry() usize { return @sizeOf(@TypeOf(a)); }
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:1:16: error: expected type '*u8', found '@Type(.Null)'
diff --git a/test/cases/compile_errors/stage1/obj/assign_through_constant_pointer.zig b/test/cases/compile_errors/stage1/obj/assign_through_constant_pointer.zig
new file mode 100644
index 0000000000000000000000000000000000000000..69ba383843554e341ea9ec8263217d351cf38c5d
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/assign_through_constant_pointer.zig
@@ -0,0 +1,10 @@
+export fn f() void {
+  var cstr = "Hat";
+  cstr[0] = 'W';
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:3:13: error: cannot assign to constant
diff --git a/test/cases/compile_errors/stage1/obj/assign_through_constant_slice.zig b/test/cases/compile_errors/stage1/obj/assign_through_constant_slice.zig
new file mode 100644
index 0000000000000000000000000000000000000000..55d2e7e7c7f6dd134a93d02a8a13f96e8db8e68a
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/assign_through_constant_slice.zig
@@ -0,0 +1,10 @@
+export fn f() void {
+  var cstr: []const u8 = "Hat";
+  cstr[0] = 'W';
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:3:13: error: cannot assign to constant
diff --git a/test/cases/compile_errors/stage1/obj/assign_to_constant_field.zig b/test/cases/compile_errors/stage1/obj/assign_to_constant_field.zig
new file mode 100644
index 0000000000000000000000000000000000000000..610818118ae0c203106f0c41232525a70d9ca70b
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/assign_to_constant_field.zig
@@ -0,0 +1,13 @@
+const Foo = struct {
+    field: i32,
+};
+export fn derp() void {
+    const f = Foo {.field = 1234,};
+    f.field = 0;
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:6:15: error: cannot assign to constant
diff --git a/test/cases/compile_errors/stage1/obj/assign_to_constant_variable.zig b/test/cases/compile_errors/stage1/obj/assign_to_constant_variable.zig
new file mode 100644
index 0000000000000000000000000000000000000000..531f669c1aa4af7b066b112aef22547d104c0698
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/assign_to_constant_variable.zig
@@ -0,0 +1,10 @@
+export fn f() void {
+    const a = 3;
+    a = 4;
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:3:9: error: cannot assign to constant
diff --git a/test/cases/compile_errors/stage1/obj/assign_to_invalid_dereference.zig b/test/cases/compile_errors/stage1/obj/assign_to_invalid_dereference.zig
new file mode 100644
index 0000000000000000000000000000000000000000..7fef5db83c33e930d40686158e122b081a9c9121
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/assign_to_invalid_dereference.zig
@@ -0,0 +1,9 @@
+export fn entry() void {
+    'a'.* = 1;
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:2:8: error: attempt to dereference non-pointer type 'comptime_int'
diff --git a/test/cases/compile_errors/stage1/obj/assign_too_big_number_to_u16.zig b/test/cases/compile_errors/stage1/obj/assign_too_big_number_to_u16.zig
new file mode 100644
index 0000000000000000000000000000000000000000..3138ed5faf7169849afeee1fb37ec6543aad39c2
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/assign_too_big_number_to_u16.zig
@@ -0,0 +1,10 @@
+export fn foo() void {
+    var vga_mem: u16 = 0xB8000;
+    _ = vga_mem;
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:2:24: error: integer value 753664 cannot be coerced to type 'u16'
diff --git a/test/cases/compile_errors/stage1/obj/assign_unreachable.zig b/test/cases/compile_errors/stage1/obj/assign_unreachable.zig
new file mode 100644
index 0000000000000000000000000000000000000000..f87adcd9942298fa9130ce2f91be392d92db90b2
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/assign_unreachable.zig
@@ -0,0 +1,10 @@
+export fn f() void {
+    const a = return;
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:2:5: error: unreachable code
+// tmp.zig:2:15: note: control flow is diverted here
diff --git a/test/cases/compile_errors/stage1/obj/assigning_to_struct_or_union_fields_that_are_not_optionals_with_a_function_that_returns_an_optional.zig b/test/cases/compile_errors/stage1/obj/assigning_to_struct_or_union_fields_that_are_not_optionals_with_a_function_that_returns_an_optional.zig
new file mode 100644
index 0000000000000000000000000000000000000000..8285991c05e042fd12132177640690ca176f8d6f
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/assigning_to_struct_or_union_fields_that_are_not_optionals_with_a_function_that_returns_an_optional.zig
@@ -0,0 +1,21 @@
+fn maybe(is: bool) ?u8 {
+    if (is) return @as(u8, 10) else return null;
+}
+const U = union {
+    Ye: u8,
+};
+const S = struct {
+    num: u8,
+};
+export fn entry() void {
+    var u = U{ .Ye = maybe(false) };
+    var s = S{ .num = maybe(false) };
+    _ = u;
+    _ = s;
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:11:27: error: cannot convert optional to payload type. consider using `.?`, `orelse`, or `if`. expected type 'u8', found '?u8'
diff --git a/test/cases/compile_errors/stage1/obj/async_function_depends_on_its_own_frame.zig b/test/cases/compile_errors/stage1/obj/async_function_depends_on_its_own_frame.zig
new file mode 100644
index 0000000000000000000000000000000000000000..4dde5860bafc4709d376e1703df95b14ce58420f
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/async_function_depends_on_its_own_frame.zig
@@ -0,0 +1,13 @@
+export fn entry() void {
+    _ = async amain();
+}
+fn amain() callconv(.Async) void {
+    var x: [@sizeOf(@Frame(amain))]u8 = undefined;
+    _ = x;
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:4:1: error: cannot resolve '@Frame(amain)': function not fully analyzed yet
diff --git a/test/cases/compile_errors/stage1/obj/async_function_indirectly_depends_on_its_own_frame.zig b/test/cases/compile_errors/stage1/obj/async_function_indirectly_depends_on_its_own_frame.zig
new file mode 100644
index 0000000000000000000000000000000000000000..4dac0d4fa33fbc45db20184af0c0734552b9df81
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/async_function_indirectly_depends_on_its_own_frame.zig
@@ -0,0 +1,17 @@
+export fn entry() void {
+    _ = async amain();
+}
+fn amain() callconv(.Async) void {
+    other();
+}
+fn other() void {
+    var x: [@sizeOf(@Frame(amain))]u8 = undefined;
+    _ = x;
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:4:1: error: unable to determine async function frame of 'amain'
+// tmp.zig:5:10: note: analysis of function 'other' depends on the frame
diff --git a/test/cases/compile_errors/stage1/obj/atomic_orderings_of_atomicStore_Acquire_or_AcqRel.zig b/test/cases/compile_errors/stage1/obj/atomic_orderings_of_atomicStore_Acquire_or_AcqRel.zig
new file mode 100644
index 0000000000000000000000000000000000000000..dfc7ff5036871218e35687d4ee5c4e9d54282aed
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/atomic_orderings_of_atomicStore_Acquire_or_AcqRel.zig
@@ -0,0 +1,10 @@
+export fn entry() void {
+    var x: u32 = 0;
+    @atomicStore(u32, &x, 1, .Acquire);
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:3:30: error: @atomicStore atomic ordering must not be Acquire or AcqRel
diff --git a/test/cases/compile_errors/stage1/obj/atomic_orderings_of_cmpxchg-failure_stricter_than_success.zig b/test/cases/compile_errors/stage1/obj/atomic_orderings_of_cmpxchg-failure_stricter_than_success.zig
new file mode 100644
index 0000000000000000000000000000000000000000..929950e754ed419589dc91c2056c684a8f5c5c07
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/atomic_orderings_of_cmpxchg-failure_stricter_than_success.zig
@@ -0,0 +1,11 @@
+const AtomicOrder = @import("std").builtin.AtomicOrder;
+export fn f() void {
+    var x: i32 = 1234;
+    while (!@cmpxchgWeak(i32, &x, 1234, 5678, AtomicOrder.Monotonic, AtomicOrder.SeqCst)) {}
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:4:81: error: failure atomic ordering must be no stricter than success
diff --git a/test/cases/compile_errors/stage1/obj/atomic_orderings_of_cmpxchg-success_Monotonic_or_stricter.zig b/test/cases/compile_errors/stage1/obj/atomic_orderings_of_cmpxchg-success_Monotonic_or_stricter.zig
new file mode 100644
index 0000000000000000000000000000000000000000..fe3344e53664537243ba930ca72069af4011bc14
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/atomic_orderings_of_cmpxchg-success_Monotonic_or_stricter.zig
@@ -0,0 +1,11 @@
+const AtomicOrder = @import("std").builtin.AtomicOrder;
+export fn f() void {
+    var x: i32 = 1234;
+    while (!@cmpxchgWeak(i32, &x, 1234, 5678, AtomicOrder.Unordered, AtomicOrder.Unordered)) {}
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:4:58: error: success atomic ordering must be Monotonic or stricter
diff --git a/test/cases/compile_errors/stage1/obj/atomic_orderings_of_fence_Acquire_or_stricter.zig b/test/cases/compile_errors/stage1/obj/atomic_orderings_of_fence_Acquire_or_stricter.zig
new file mode 100644
index 0000000000000000000000000000000000000000..8a01871a80ce34c31d290bea280ff8f98fc0f33e
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/atomic_orderings_of_fence_Acquire_or_stricter.zig
@@ -0,0 +1,9 @@
+export fn entry() void {
+    @fence(.Monotonic);
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:2:12: error: atomic ordering must be Acquire or stricter
diff --git a/test/cases/compile_errors/stage1/obj/atomicrmw_with_bool_op_not_.Xchg.zig b/test/cases/compile_errors/stage1/obj/atomicrmw_with_bool_op_not_.Xchg.zig
new file mode 100644
index 0000000000000000000000000000000000000000..0b5b0cd3c1ecfa6a7250928ff8291dcfc70fd734
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/atomicrmw_with_bool_op_not_.Xchg.zig
@@ -0,0 +1,10 @@
+export fn entry() void {
+    var x = false;
+    _ = @atomicRmw(bool, &x, .Add, true, .SeqCst);
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:3:30: error: @atomicRmw with bool only allowed with .Xchg
diff --git a/test/cases/compile_errors/stage1/obj/atomicrmw_with_enum_op_not_.Xchg.zig b/test/cases/compile_errors/stage1/obj/atomicrmw_with_enum_op_not_.Xchg.zig
new file mode 100644
index 0000000000000000000000000000000000000000..adbf4ca45e8d073fa381f8e3f32243b57da5ba03
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/atomicrmw_with_enum_op_not_.Xchg.zig
@@ -0,0 +1,16 @@
+export fn entry() void {
+    const E = enum(u8) {
+        a,
+        b,
+        c,
+        d,
+    };
+    var x: E = .a;
+    _ = @atomicRmw(E, &x, .Add, .b, .SeqCst);
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:9:27: error: @atomicRmw with enum only allowed with .Xchg
diff --git a/test/cases/compile_errors/stage1/obj/atomicrmw_with_float_op_not_.Xchg_.Add_or_.Sub.zig b/test/cases/compile_errors/stage1/obj/atomicrmw_with_float_op_not_.Xchg_.Add_or_.Sub.zig
new file mode 100644
index 0000000000000000000000000000000000000000..4f3ebfcef6af9293418aa92edb8290127f5b3726
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/atomicrmw_with_float_op_not_.Xchg_.Add_or_.Sub.zig
@@ -0,0 +1,10 @@
+export fn entry() void {
+    var x: f32 = 0;
+    _ = @atomicRmw(f32, &x, .And, 2, .SeqCst);
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:3:29: error: @atomicRmw with float only allowed with .Xchg, .Add and .Sub
diff --git a/test/cases/compile_errors/stage1/obj/attempt_to_cast_enum_literal_to_error.zig b/test/cases/compile_errors/stage1/obj/attempt_to_cast_enum_literal_to_error.zig
new file mode 100644
index 0000000000000000000000000000000000000000..f1c30815fca0dfce8bea8128e6a15bfbf983a243
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/attempt_to_cast_enum_literal_to_error.zig
@@ -0,0 +1,11 @@
+export fn entry() void {
+    switch (error.Hi) {
+        .Hi => {},
+    }
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:3:9: error: expected type 'error{Hi}', found '@Type(.EnumLiteral)'
diff --git a/test/cases/compile_errors/stage1/obj/attempt_to_close_over_comptime_variable_from_outer_scope.zig b/test/cases/compile_errors/stage1/obj/attempt_to_close_over_comptime_variable_from_outer_scope.zig
new file mode 100644
index 0000000000000000000000000000000000000000..58eb9d19d20f03b16a30f252c953b818bfa6e77b
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/attempt_to_close_over_comptime_variable_from_outer_scope.zig
@@ -0,0 +1,14 @@
+fn SimpleList(comptime L: usize) type {
+    var T = u8;
+    return struct {
+        array: [L]T,
+    };
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:4:19: error: mutable 'T' not accessible from here
+// tmp.zig:2:9: note: declared mutable here
+// tmp.zig:3:12: note: crosses namespace boundary here
diff --git a/test/cases/compile_errors/stage1/obj/attempt_to_create_17_bit_float_type.zig b/test/cases/compile_errors/stage1/obj/attempt_to_create_17_bit_float_type.zig
new file mode 100644
index 0000000000000000000000000000000000000000..ba7393fcb76d8f003bc81feb2348b94290dc58e8
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/attempt_to_create_17_bit_float_type.zig
@@ -0,0 +1,10 @@
+const builtin = @import("std").builtin;
+comptime {
+    _ = @Type(.{ .Float = .{ .bits = 17 } });
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:3:16: error: 17-bit float unsupported
diff --git a/test/cases/compile_errors/stage1/obj/attempt_to_negate_a_non-integer_non-float_or_non-vector_type.zig b/test/cases/compile_errors/stage1/obj/attempt_to_negate_a_non-integer_non-float_or_non-vector_type.zig
new file mode 100644
index 0000000000000000000000000000000000000000..e9bbf921aba193bbdb74c01d65ecd6bd57f8a858
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/attempt_to_negate_a_non-integer_non-float_or_non-vector_type.zig
@@ -0,0 +1,14 @@
+fn foo() anyerror!u32 {
+    return 1;
+}
+
+export fn entry() void {
+    const x = -foo();
+    _ = x;
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:6:15: error: negation of type 'anyerror!u32'
diff --git a/test/cases/compile_errors/stage1/obj/attempt_to_use_0_bit_type_in_extern_fn.zig b/test/cases/compile_errors/stage1/obj/attempt_to_use_0_bit_type_in_extern_fn.zig
new file mode 100644
index 0000000000000000000000000000000000000000..021cd97f190493043b72f1aa12338e5c4b5b2cc2
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/attempt_to_use_0_bit_type_in_extern_fn.zig
@@ -0,0 +1,17 @@
+extern fn foo(ptr: fn(*void) callconv(.C) void) void;
+
+export fn entry() void {
+    foo(bar);
+}
+
+fn bar(x: *void) callconv(.C) void { _ = x; }
+export fn entry2() void {
+    bar(&{});
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:1:23: error: parameter of type '*void' has 0 bits; not allowed in function with calling convention 'C'
+// tmp.zig:7:11: error: parameter of type '*void' has 0 bits; not allowed in function with calling convention 'C'
diff --git a/test/cases/compile_errors/stage1/obj/attempted_double_ampersand.zig b/test/cases/compile_errors/stage1/obj/attempted_double_ampersand.zig
new file mode 100644
index 0000000000000000000000000000000000000000..c749b172c6541a3db255aebc0d2f26f1dd62c70a
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/attempted_double_ampersand.zig
@@ -0,0 +1,12 @@
+export fn entry(a: bool, b: bool) i32 {
+    if (a && b) {
+        return 1234;
+    }
+    return 5678;
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:2:11: error: ambiguous use of '&&'; use 'and' for logical AND, or change whitespace to ' & &' for bitwise AND
diff --git a/test/cases/compile_errors/stage1/obj/attempted_double_pipe_on_boolean_values.zig b/test/cases/compile_errors/stage1/obj/attempted_double_pipe_on_boolean_values.zig
new file mode 100644
index 0000000000000000000000000000000000000000..b991b1b61b5c603779d53d63c0b9afabd6006b8e
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/attempted_double_pipe_on_boolean_values.zig
@@ -0,0 +1,13 @@
+export fn entry(a: bool, b: bool) i32 {
+    if (a || b) {
+        return 1234;
+    }
+    return 5678;
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:2:9: error: expected error set type, found 'bool'
+// tmp.zig:2:11: note: `||` merges error sets; `or` performs boolean OR
diff --git a/test/cases/compile_errors/stage1/obj/attempted_implicit_cast_from_T_to_slice_const_T.zig b/test/cases/compile_errors/stage1/obj/attempted_implicit_cast_from_T_to_slice_const_T.zig
new file mode 100644
index 0000000000000000000000000000000000000000..c3b0847129cdd4de1f4525e676ffb0fce2b40d9d
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/attempted_implicit_cast_from_T_to_slice_const_T.zig
@@ -0,0 +1,10 @@
+export fn entry() void {
+    const x: [*]const bool = true;
+    _ = x;
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:2:30: error: expected type '[*]const bool', found 'bool'
diff --git a/test/cases/compile_errors/stage1/obj/attempted_implicit_cast_from_const_T_to_array_len_1_T.zig b/test/cases/compile_errors/stage1/obj/attempted_implicit_cast_from_const_T_to_array_len_1_T.zig
new file mode 100644
index 0000000000000000000000000000000000000000..760866dd651acbf6c48e91bfe5665825e01c1634
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/attempted_implicit_cast_from_const_T_to_array_len_1_T.zig
@@ -0,0 +1,14 @@
+export fn entry(byte: u8) void {
+    const w: i32 = 1234;
+    var x: *const i32 = &w;
+    var y: *[1]i32 = x;
+    y[0] += 1;
+    _ = byte;
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:4:22: error: expected type '*[1]i32', found '*const i32'
+// tmp.zig:4:22: note: cast discards const qualifier
diff --git a/test/cases/compile_errors/stage1/obj/attempted_implicit_cast_from_const_T_to_sliceT.zig b/test/cases/compile_errors/stage1/obj/attempted_implicit_cast_from_const_T_to_sliceT.zig
new file mode 100644
index 0000000000000000000000000000000000000000..3ff9937983279a8a54947cea711bd3afcea56a84
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/attempted_implicit_cast_from_const_T_to_sliceT.zig
@@ -0,0 +1,11 @@
+export fn entry() void {
+    const u: u32 = 42;
+    const x: []u32 = &u;
+    _ = x;
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:3:23: error: expected type '[]u32', found '*const u32'
diff --git a/test/cases/compile_errors/stage1/obj/bad_alignCast_at_comptime.zig b/test/cases/compile_errors/stage1/obj/bad_alignCast_at_comptime.zig
new file mode 100644
index 0000000000000000000000000000000000000000..f1ed25e19168d8e4c890e806ef5b6d30d2995494
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/bad_alignCast_at_comptime.zig
@@ -0,0 +1,11 @@
+comptime {
+    const ptr = @intToPtr(*align(1) i32, 0x1);
+    const aligned = @alignCast(4, ptr);
+    _ = aligned;
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:3:35: error: pointer address 0x1 is not aligned to 4 bytes
diff --git a/test/cases/compile_errors/stage1/obj/bad_alignment_in_asynccall.zig b/test/cases/compile_errors/stage1/obj/bad_alignment_in_asynccall.zig
new file mode 100644
index 0000000000000000000000000000000000000000..399914000994b76b44c91e8200b74dafcd7aa1be
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/bad_alignment_in_asynccall.zig
@@ -0,0 +1,12 @@
+export fn entry() void {
+    var ptr: fn () callconv(.Async) void = func;
+    var bytes: [64]u8 = undefined;
+    _ = @asyncCall(&bytes, {}, ptr, .{});
+}
+fn func() callconv(.Async) void {}
+
+// error
+// backend=stage1
+// target=aarch64-linux-none
+//
+// tmp.zig:4:21: error: expected type '[]align(8) u8', found '*[64]u8'
diff --git a/test/cases/compile_errors/stage1/obj/bad_alignment_in_implicit_cast_from_array_pointer_to_slice.zig b/test/cases/compile_errors/stage1/obj/bad_alignment_in_implicit_cast_from_array_pointer_to_slice.zig
new file mode 100644
index 0000000000000000000000000000000000000000..12064bd9ab0b6b4e8c3f6789bf091d5f12721463
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/bad_alignment_in_implicit_cast_from_array_pointer_to_slice.zig
@@ -0,0 +1,11 @@
+export fn a() void {
+    var x: [10]u8 = undefined;
+    var y: []align(16) u8 = &x;
+    _ = y;
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:3:30: error: expected type '[]align(16) u8', found '*[10]u8'
diff --git a/test/cases/compile_errors/stage1/obj/bad_alignment_type.zig b/test/cases/compile_errors/stage1/obj/bad_alignment_type.zig
new file mode 100644
index 0000000000000000000000000000000000000000..a4d8b7d68f6cceca709cb5b93d3b7677e4cb7d7d
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/bad_alignment_type.zig
@@ -0,0 +1,15 @@
+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;
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:2:20: error: expected type 'u29', found 'bool'
+// tmp.zig:6:19: error: fractional component prevents float value 12.340000 from being casted to type 'u29'
diff --git a/test/cases/compile_errors/stage1/obj/bad_identifier_in_function_with_struct_defined_inside_function_which_references_local_const.zig b/test/cases/compile_errors/stage1/obj/bad_identifier_in_function_with_struct_defined_inside_function_which_references_local_const.zig
new file mode 100644
index 0000000000000000000000000000000000000000..7e44ad5057cc67a71b976c538150574f42cb177f
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/bad_identifier_in_function_with_struct_defined_inside_function_which_references_local_const.zig
@@ -0,0 +1,17 @@
+export fn entry() void {
+    const BlockKind = u32;
+
+    const Block = struct {
+        kind: BlockKind,
+    };
+
+    bogus;
+
+    _ = Block;
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:8:5: error: use of undeclared identifier 'bogus'
diff --git a/test/cases/compile_errors/stage1/obj/bad_import.zig b/test/cases/compile_errors/stage1/obj/bad_import.zig
new file mode 100644
index 0000000000000000000000000000000000000000..1a7ab5f00b78f479da870f6009dbdea06dc2a4b3
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/bad_import.zig
@@ -0,0 +1,7 @@
+const bogus = @import("bogus-does-not-exist.zig",);
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:1:23: error: unable to load '${DIR}bogus-does-not-exist.zig': FileNotFound
diff --git a/test/cases/compile_errors/stage1/obj/bad_usage_of_call.zig b/test/cases/compile_errors/stage1/obj/bad_usage_of_call.zig
new file mode 100644
index 0000000000000000000000000000000000000000..c77ccf1a525ca5144581da98903e60aa74f19b7b
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/bad_usage_of_call.zig
@@ -0,0 +1,30 @@
+export fn entry1() void {
+    @call(.{}, foo, {});
+}
+export fn entry2() void {
+    comptime @call(.{ .modifier = .never_inline }, foo, .{});
+}
+export fn entry3() void {
+    comptime @call(.{ .modifier = .never_tail }, foo, .{});
+}
+export fn entry4() void {
+    @call(.{ .modifier = .never_inline }, bar, .{});
+}
+export fn entry5(c: bool) void {
+    var baz = if (c) baz1 else baz2;
+    @call(.{ .modifier = .compile_time }, baz, .{});
+}
+fn foo() void {}
+fn bar() callconv(.Inline) void {}
+fn baz1() void {}
+fn baz2() void {}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:2:21: error: expected tuple or struct, found 'void'
+// tmp.zig:5:14: error: unable to perform 'never_inline' call at compile-time
+// tmp.zig:8:14: error: unable to perform 'never_tail' call at compile-time
+// tmp.zig:11:5: error: no-inline call of inline function
+// tmp.zig:15:5: error: the specified modifier requires a comptime-known function
diff --git a/test/cases/compile_errors/stage1/obj/bin_and_assign_on_undefined_value.zig b/test/cases/compile_errors/stage1/obj/bin_and_assign_on_undefined_value.zig
new file mode 100644
index 0000000000000000000000000000000000000000..1076f9abdb6c170e84f0770f5ec33d04e0c572f1
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/bin_and_assign_on_undefined_value.zig
@@ -0,0 +1,10 @@
+comptime {
+    var a: i64 = undefined;
+    a &= a;
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:3:5: error: use of undefined value here causes undefined behavior
diff --git a/test/cases/compile_errors/stage1/obj/bin_and_on_undefined_value.zig b/test/cases/compile_errors/stage1/obj/bin_and_on_undefined_value.zig
new file mode 100644
index 0000000000000000000000000000000000000000..a53d9a10ac66b5ba7f107648fea3f18fb7c0c37d
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/bin_and_on_undefined_value.zig
@@ -0,0 +1,10 @@
+comptime {
+    var a: i64 = undefined;
+    _ = a & a;
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:3:9: error: use of undefined value here causes undefined behavior
diff --git a/test/cases/compile_errors/stage1/obj/bin_not_on_undefined_value.zig b/test/cases/compile_errors/stage1/obj/bin_not_on_undefined_value.zig
new file mode 100644
index 0000000000000000000000000000000000000000..7e0f554f0b1a718848f4b551f5ae51556cb17e4a
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/bin_not_on_undefined_value.zig
@@ -0,0 +1,10 @@
+comptime {
+    var a: i64 = undefined;
+    _ = ~a;
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:3:10: error: use of undefined value here causes undefined behavior
diff --git a/test/cases/compile_errors/stage1/obj/bin_or_assign_on_undefined_value.zig b/test/cases/compile_errors/stage1/obj/bin_or_assign_on_undefined_value.zig
new file mode 100644
index 0000000000000000000000000000000000000000..cc61fc03e168cb211ced6b390c2f2923fb719615
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/bin_or_assign_on_undefined_value.zig
@@ -0,0 +1,10 @@
+comptime {
+    var a: i64 = undefined;
+    a |= a;
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:3:5: error: use of undefined value here causes undefined behavior
diff --git a/test/cases/compile_errors/stage1/obj/bin_or_on_undefined_value.zig b/test/cases/compile_errors/stage1/obj/bin_or_on_undefined_value.zig
new file mode 100644
index 0000000000000000000000000000000000000000..7ac30bcb4e69471e3e317cc559dca17520d26776
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/bin_or_on_undefined_value.zig
@@ -0,0 +1,10 @@
+comptime {
+    var a: i64 = undefined;
+    _ = a | a;
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:3:9: error: use of undefined value here causes undefined behavior
diff --git a/test/cases/compile_errors/stage1/obj/bin_xor_assign_on_undefined_value.zig b/test/cases/compile_errors/stage1/obj/bin_xor_assign_on_undefined_value.zig
new file mode 100644
index 0000000000000000000000000000000000000000..37e3eae321bc7246cd8f1ccce419300891497d04
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/bin_xor_assign_on_undefined_value.zig
@@ -0,0 +1,10 @@
+comptime {
+    var a: i64 = undefined;
+    a ^= a;
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:3:5: error: use of undefined value here causes undefined behavior
diff --git a/test/cases/compile_errors/stage1/obj/bin_xor_on_undefined_value.zig b/test/cases/compile_errors/stage1/obj/bin_xor_on_undefined_value.zig
new file mode 100644
index 0000000000000000000000000000000000000000..f1656b60131df144286c32a984458cf33dc9793e
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/bin_xor_on_undefined_value.zig
@@ -0,0 +1,10 @@
+comptime {
+    var a: i64 = undefined;
+    _ = a ^ a;
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:3:9: error: use of undefined value here causes undefined behavior
diff --git a/test/cases/compile_errors/stage1/obj/binary_not_on_number_literal.zig b/test/cases/compile_errors/stage1/obj/binary_not_on_number_literal.zig
new file mode 100644
index 0000000000000000000000000000000000000000..34ddf9adfa0c44c3180917e53927313ab69f04ed
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/binary_not_on_number_literal.zig
@@ -0,0 +1,11 @@
+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);
+
+export fn entry() usize { return @sizeOf(@TypeOf(block_aligned_stuff)); }
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:3:60: error: unable to perform binary not operation on type 'comptime_int'
diff --git a/test/cases/compile_errors/stage1/obj/bitCast_same_size_but_bit_count_mismatch.zig b/test/cases/compile_errors/stage1/obj/bitCast_same_size_but_bit_count_mismatch.zig
new file mode 100644
index 0000000000000000000000000000000000000000..9150dc32853c9ff6c5bd3d9f6553bd4aa2ceee3f
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/bitCast_same_size_but_bit_count_mismatch.zig
@@ -0,0 +1,10 @@
+export fn entry(byte: u8) void {
+    var oops = @bitCast(u7, byte);
+    _ = oops;
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:2:25: error: destination type 'u7' has 7 bits but source type 'u8' has 8 bits
diff --git a/test/cases/compile_errors/stage1/obj/bitCast_to_enum_type.zig b/test/cases/compile_errors/stage1/obj/bitCast_to_enum_type.zig
new file mode 100644
index 0000000000000000000000000000000000000000..4d63ab9e019a540760e3d3196e66dbd3b999bc2f
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/bitCast_to_enum_type.zig
@@ -0,0 +1,10 @@
+export fn entry() void {
+    const y = @bitCast(enum(u32) { a, b }, @as(u32, 3));
+    _ = y;
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:2:24: error: cannot cast a value of type 'y'
diff --git a/test/cases/compile_errors/stage1/obj/bitCast_with_different_sizes_inside_an_expression.zig b/test/cases/compile_errors/stage1/obj/bitCast_with_different_sizes_inside_an_expression.zig
new file mode 100644
index 0000000000000000000000000000000000000000..64caef7cd0cdf99997a8a228d4a70c9abe33fa53
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/bitCast_with_different_sizes_inside_an_expression.zig
@@ -0,0 +1,10 @@
+export fn entry() void {
+    var foo = (@bitCast(u8, @as(f32, 1.0)) == 0xf);
+    _ = foo;
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:2:25: error: destination type 'u8' has size 1 but source type 'f32' has size 4
diff --git a/test/cases/compile_errors/stage1/obj/bit_shifting_only_works_on_integer_types.zig b/test/cases/compile_errors/stage1/obj/bit_shifting_only_works_on_integer_types.zig
new file mode 100644
index 0000000000000000000000000000000000000000..7d1c5873a1fe3242af429f7492719d1b53b7dc55
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/bit_shifting_only_works_on_integer_types.zig
@@ -0,0 +1,10 @@
+export fn entry() void {
+    const x = &@as(u8, 1) << 10;
+    _ = x;
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:2:16: error: bit shifting operation expected integer type, found '*const u8'
diff --git a/test/cases/compile_errors/stage1/obj/bogus_compile_var.zig b/test/cases/compile_errors/stage1/obj/bogus_compile_var.zig
new file mode 100644
index 0000000000000000000000000000000000000000..845d943c7ddc973769b2db96407f611f6c2bb43e
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/bogus_compile_var.zig
@@ -0,0 +1,8 @@
+const x = @import("builtin").bogus;
+export fn entry() usize { return @sizeOf(@TypeOf(x)); }
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:1:29: error: container 'builtin' has no member called 'bogus'
diff --git a/test/cases/compile_errors/stage1/obj/bogus_method_call_on_slice.zig b/test/cases/compile_errors/stage1/obj/bogus_method_call_on_slice.zig
new file mode 100644
index 0000000000000000000000000000000000000000..3ede578b34e57005baa67405fb3bf406a78ab276
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/bogus_method_call_on_slice.zig
@@ -0,0 +1,11 @@
+var self = "aoeu";
+fn f(m: []const u8) void {
+    m.copy(u8, self[0..], m);
+}
+export fn entry() usize { return @sizeOf(@TypeOf(f)); }
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:3:6: error: no member named 'copy' in '[]const u8'
diff --git a/test/cases/compile_errors/stage1/obj/bool_not_on_undefined_value.zig b/test/cases/compile_errors/stage1/obj/bool_not_on_undefined_value.zig
new file mode 100644
index 0000000000000000000000000000000000000000..5c99a9739b5941044e38593009ac0636adceef54
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/bool_not_on_undefined_value.zig
@@ -0,0 +1,10 @@
+comptime {
+    var a: bool = undefined;
+    _ = !a;
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:3:10: error: use of undefined value here causes undefined behavior
diff --git a/test/cases/compile_errors/stage1/obj/branch_on_undefined_value.zig b/test/cases/compile_errors/stage1/obj/branch_on_undefined_value.zig
new file mode 100644
index 0000000000000000000000000000000000000000..f4b922a3328af9c42082a5e461eb84f6569020da
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/branch_on_undefined_value.zig
@@ -0,0 +1,9 @@
+const x = if (undefined) true else false;
+
+export fn entry() usize { return @sizeOf(@TypeOf(x)); }
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:1:15: error: use of undefined value here causes undefined behavior
diff --git a/test/cases/compile_errors/stage1/obj/cImport_with_bogus_include.zig b/test/cases/compile_errors/stage1/obj/cImport_with_bogus_include.zig
new file mode 100644
index 0000000000000000000000000000000000000000..141f21cb9a7ef9a9534a15cd6d0955b6ddef4a5c
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/cImport_with_bogus_include.zig
@@ -0,0 +1,9 @@
+const c = @cImport(@cInclude("bogus.h"));
+export fn entry() usize { return @sizeOf(@TypeOf(c.bogo)); }
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:1:11: error: C import failed
+// .h:1:10: note: 'bogus.h' file not found
diff --git a/test/cases/compile_errors/stage1/obj/call_assigned_to_constant.zig b/test/cases/compile_errors/stage1/obj/call_assigned_to_constant.zig
new file mode 100644
index 0000000000000000000000000000000000000000..ca4e8b67cd02ece3a12191a4cb66b2cbb6b89055
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/call_assigned_to_constant.zig
@@ -0,0 +1,24 @@
+const Foo = struct {
+    x: i32,
+};
+fn foo() Foo {
+    return .{ .x = 42 };
+}
+fn bar(val: anytype) Foo {
+    return .{ .x = val };
+}
+export fn entry() void {
+    const baz: Foo = undefined;
+    baz = foo();
+}
+export fn entry1() void {
+    const baz: Foo = undefined;
+    baz = bar(42);
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:12:14: error: cannot assign to constant
+// tmp.zig:16:14: error: cannot assign to constant
diff --git a/test/cases/compile_errors/stage1/obj/call_with_new_stack_on_unsupported_target.zig b/test/cases/compile_errors/stage1/obj/call_with_new_stack_on_unsupported_target.zig
new file mode 100644
index 0000000000000000000000000000000000000000..7cb504a3f9d645c58bfbfe3fbb1b5d10ba9a9d7f
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/call_with_new_stack_on_unsupported_target.zig
@@ -0,0 +1,11 @@
+var buf: [10]u8 align(16) = undefined;
+export fn entry() void {
+    @call(.{ .stack = &buf }, foo, .{});
+}
+fn foo() void {}
+
+// error
+// backend=stage1
+// target=wasm32-wasi-none
+//
+// tmp.zig:3:5: error: target arch 'wasm32' does not support calling with a new stack
diff --git a/test/cases/compile_errors/stage1/obj/callconv_apcs_aapcs_aapcsvfp_on_unsupported_platform.zig b/test/cases/compile_errors/stage1/obj/callconv_apcs_aapcs_aapcsvfp_on_unsupported_platform.zig
new file mode 100644
index 0000000000000000000000000000000000000000..fa062878036cc6a321068c9b1489a809367fde59
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/callconv_apcs_aapcs_aapcsvfp_on_unsupported_platform.zig
@@ -0,0 +1,11 @@
+export fn entry1() callconv(.APCS) void {}
+export fn entry2() callconv(.AAPCS) void {}
+export fn entry3() callconv(.AAPCSVFP) void {}
+
+// error
+// backend=stage1
+// target=x86_64-linux-none
+//
+// tmp.zig:1:29: error: callconv 'APCS' is only available on ARM, not x86_64
+// 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
diff --git a/test/cases/compile_errors/stage1/obj/callconv_interrupt_on_unsupported_platform.zig b/test/cases/compile_errors/stage1/obj/callconv_interrupt_on_unsupported_platform.zig
new file mode 100644
index 0000000000000000000000000000000000000000..8304fb90c1edc167edec2f9ca142bd6675c3116d
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/callconv_interrupt_on_unsupported_platform.zig
@@ -0,0 +1,7 @@
+export fn entry() callconv(.Interrupt) void {}
+
+// error
+// backend=stage1
+// target=aarch64-linux-none
+//
+// tmp.zig:1:28: error: callconv 'Interrupt' is only available on x86, x86_64, AVR, and MSP430, not aarch64
diff --git a/test/cases/compile_errors/stage1/obj/callconv_signal_on_unsupported_platform.zig b/test/cases/compile_errors/stage1/obj/callconv_signal_on_unsupported_platform.zig
new file mode 100644
index 0000000000000000000000000000000000000000..4b19b188fdd8c8b6d03c54886f97e5e75614e83c
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/callconv_signal_on_unsupported_platform.zig
@@ -0,0 +1,7 @@
+export fn entry() callconv(.Signal) void {}
+
+// error
+// backend=stage1
+// target=x86_64-linux-none
+//
+// tmp.zig:1:28: error: callconv 'Signal' is only available on AVR, not x86_64
diff --git a/test/cases/compile_errors/stage1/obj/callconv_stdcall_fastcall_thiscall_on_unsupported_platform-0.zig b/test/cases/compile_errors/stage1/obj/callconv_stdcall_fastcall_thiscall_on_unsupported_platform-0.zig
new file mode 100644
index 0000000000000000000000000000000000000000..f4994107cd13bae21514393ebcce71f88f36b785
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/callconv_stdcall_fastcall_thiscall_on_unsupported_platform-0.zig
@@ -0,0 +1,23 @@
+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;
+    _ = a;
+}
+export fn entry2() void {
+    var a: F2 = undefined;
+    _ = a;
+}
+export fn entry3() void {
+    var a: F3 = undefined;
+    _ = a;
+}
+
+// error
+// backend=stage1
+// target=x86_64-linux-none
+//
+// 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
diff --git a/test/cases/compile_errors/stage1/obj/callconv_stdcall_fastcall_thiscall_on_unsupported_platform-1.zig b/test/cases/compile_errors/stage1/obj/callconv_stdcall_fastcall_thiscall_on_unsupported_platform-1.zig
new file mode 100644
index 0000000000000000000000000000000000000000..aa23f9ae51714129903e57ab42655c3656eada31
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/callconv_stdcall_fastcall_thiscall_on_unsupported_platform-1.zig
@@ -0,0 +1,11 @@
+export fn entry1() callconv(.Stdcall) void {}
+export fn entry2() callconv(.Fastcall) void {}
+export fn entry3() callconv(.Thiscall) void {}
+
+// error
+// backend=stage1
+// target=x86_64-linux-none
+//
+// tmp.zig:1:29: error: callconv 'Stdcall' is only available on x86, not x86_64
+// 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
diff --git a/test/cases/compile_errors/stage1/obj/callconv_vectorcall_on_unsupported_platform.zig b/test/cases/compile_errors/stage1/obj/callconv_vectorcall_on_unsupported_platform.zig
new file mode 100644
index 0000000000000000000000000000000000000000..e60e6ab42c0b9ab8bc756af0ec979502ad9a3dc8
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/callconv_vectorcall_on_unsupported_platform.zig
@@ -0,0 +1,7 @@
+export fn entry() callconv(.Vectorcall) void {}
+
+// error
+// backend=stage1
+// target=x86_64-linux-none
+//
+// tmp.zig:1:28: error: callconv 'Vectorcall' is only available on x86 and AArch64, not x86_64
diff --git a/test/cases/compile_errors/stage1/obj/calling_a_generic_function_only_known_at_runtime.zig b/test/cases/compile_errors/stage1/obj/calling_a_generic_function_only_known_at_runtime.zig
new file mode 100644
index 0000000000000000000000000000000000000000..3081f0f1e184573eccf3625c0373233f8d4494b5
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/calling_a_generic_function_only_known_at_runtime.zig
@@ -0,0 +1,14 @@
+var foos = [_]fn(anytype) void { foo1, foo2 };
+
+fn foo1(arg: anytype) void {_ = arg;}
+fn foo2(arg: anytype) void {_ = arg;}
+
+pub fn main() !void {
+    foos[0](true);
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:7:9: error: calling a generic function requires compile-time known function value
diff --git a/test/cases/compile_errors/stage1/obj/calling_function_with_naked_calling_convention.zig b/test/cases/compile_errors/stage1/obj/calling_function_with_naked_calling_convention.zig
new file mode 100644
index 0000000000000000000000000000000000000000..401f84e687da591d8ea817f5f1c27f4bfd02a563
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/calling_function_with_naked_calling_convention.zig
@@ -0,0 +1,11 @@
+export fn entry() void {
+    foo();
+}
+fn foo() callconv(.Naked) void { }
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:2:5: error: unable to call function with naked calling convention
+// tmp.zig:4:1: note: declared here
diff --git a/test/cases/compile_errors/stage1/obj/calling_var_args_extern_function_passing_array_instead_of_pointer.zig b/test/cases/compile_errors/stage1/obj/calling_var_args_extern_function_passing_array_instead_of_pointer.zig
new file mode 100644
index 0000000000000000000000000000000000000000..a71ab051f280967e4af951c8d35d672523a5b9ae
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/calling_var_args_extern_function_passing_array_instead_of_pointer.zig
@@ -0,0 +1,10 @@
+export fn entry() void {
+    foo("hello".*,);
+}
+pub extern fn foo(format: *const u8, ...) void;
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:2:16: error: expected type '*const u8', found '[5:0]u8'
diff --git a/test/cases/compile_errors/stage1/obj/cannot_break_out_of_defer_expression.zig b/test/cases/compile_errors/stage1/obj/cannot_break_out_of_defer_expression.zig
new file mode 100644
index 0000000000000000000000000000000000000000..3c7ae4fa2f0669ab158e410357191c0fde58523f
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/cannot_break_out_of_defer_expression.zig
@@ -0,0 +1,13 @@
+export fn foo() void {
+    while (true) {
+        defer {
+            break;
+        }
+    }
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:4:13: error: cannot break out of defer expression
diff --git a/test/cases/compile_errors/stage1/obj/cannot_continue_out_of_defer_expression.zig b/test/cases/compile_errors/stage1/obj/cannot_continue_out_of_defer_expression.zig
new file mode 100644
index 0000000000000000000000000000000000000000..56b8ced05be00935793775af365f84ef919ef950
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/cannot_continue_out_of_defer_expression.zig
@@ -0,0 +1,13 @@
+export fn foo() void {
+    while (true) {
+        defer {
+            continue;
+        }
+    }
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:4:13: error: cannot continue out of defer expression
diff --git a/test/cases/compile_errors/stage1/obj/capture_group_on_switch_prong_with_incompatible_payload_types.zig b/test/cases/compile_errors/stage1/obj/capture_group_on_switch_prong_with_incompatible_payload_types.zig
new file mode 100644
index 0000000000000000000000000000000000000000..ce2068d6c701421af71d3e6a738070889511c9a9
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/capture_group_on_switch_prong_with_incompatible_payload_types.zig
@@ -0,0 +1,21 @@
+const Union = union(enum) {
+    A: usize,
+    B: isize,
+};
+comptime {
+    var u = Union{ .A = 8 };
+    switch (u) {
+        .A, .B => |e| {
+            _ = e;
+            unreachable;
+        },
+    }
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:8:20: error: capture group with incompatible types
+// tmp.zig:8:9: note: type 'usize' here
+// tmp.zig:8:13: note: type 'isize' here
diff --git a/test/cases/compile_errors/stage1/obj/cast_enum_literal_to_enum_but_it_doesnt_match.zig b/test/cases/compile_errors/stage1/obj/cast_enum_literal_to_enum_but_it_doesnt_match.zig
new file mode 100644
index 0000000000000000000000000000000000000000..ba53646efcc8c700484eaa330c17083dd822ca68
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/cast_enum_literal_to_enum_but_it_doesnt_match.zig
@@ -0,0 +1,15 @@
+const Foo = enum {
+    a,
+    b,
+};
+export fn entry() void {
+    const x: Foo = .c;
+    _ = x;
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:6:20: error: enum 'Foo' has no field named 'c'
+// tmp.zig:1:13: note: 'Foo' declared here
diff --git a/test/cases/compile_errors/stage1/obj/cast_error_union_of_global_error_set_to_error_union_of_smaller_error_set.zig b/test/cases/compile_errors/stage1/obj/cast_error_union_of_global_error_set_to_error_union_of_smaller_error_set.zig
new file mode 100644
index 0000000000000000000000000000000000000000..08962afc855f31095613daa866f17448e16e5f9e
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/cast_error_union_of_global_error_set_to_error_union_of_smaller_error_set.zig
@@ -0,0 +1,16 @@
+const SmallErrorSet = error{A};
+export fn entry() void {
+    var x: SmallErrorSet!i32 = foo();
+    _ = x;
+}
+fn foo() anyerror!i32 {
+    return error.B;
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:3:35: error: expected type 'SmallErrorSet!i32', found 'anyerror!i32'
+// tmp.zig:3:35: note: error set 'anyerror' cannot cast into error set 'SmallErrorSet'
+// tmp.zig:3:35: note: cannot cast global error set into smaller set
diff --git a/test/cases/compile_errors/stage1/obj/cast_global_error_set_to_error_set.zig b/test/cases/compile_errors/stage1/obj/cast_global_error_set_to_error_set.zig
new file mode 100644
index 0000000000000000000000000000000000000000..be9487cc5a9486cc766828d6675e56fe1f02157c
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/cast_global_error_set_to_error_set.zig
@@ -0,0 +1,15 @@
+const SmallErrorSet = error{A};
+export fn entry() void {
+    var x: SmallErrorSet = foo();
+    _ = x;
+}
+fn foo() anyerror {
+    return error.B;
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:3:31: error: expected type 'SmallErrorSet', found 'anyerror'
+// tmp.zig:3:31: note: cannot cast global error set into smaller set
diff --git a/test/cases/compile_errors/stage1/obj/cast_negative_integer_literal_to_usize.zig b/test/cases/compile_errors/stage1/obj/cast_negative_integer_literal_to_usize.zig
new file mode 100644
index 0000000000000000000000000000000000000000..763e0c8a238ecf83aaa354f2652088fd819360cd
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/cast_negative_integer_literal_to_usize.zig
@@ -0,0 +1,10 @@
+export fn entry() void {
+    const x = @as(usize, -10);
+    _ = x;
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:2:26: error: cannot cast negative value -10 to unsigned integer type 'usize'
diff --git a/test/cases/compile_errors/stage1/obj/cast_negative_value_to_unsigned_integer.zig b/test/cases/compile_errors/stage1/obj/cast_negative_value_to_unsigned_integer.zig
new file mode 100644
index 0000000000000000000000000000000000000000..d2e318714054f8265defd34dad989ac64baac418
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/cast_negative_value_to_unsigned_integer.zig
@@ -0,0 +1,17 @@
+comptime {
+    const value: i32 = -1;
+    const unsigned = @intCast(u32, value);
+    _ = unsigned;
+}
+export fn entry1() void {
+    const value: i32 = -1;
+    const unsigned: u32 = value;
+    _ = unsigned;
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:3:22: error: attempt to cast negative value to unsigned integer
+// tmp.zig:8:27: error: cannot cast negative value -1 to unsigned integer type 'u32'
diff --git a/test/cases/compile_errors/stage1/obj/cast_unreachable.zig b/test/cases/compile_errors/stage1/obj/cast_unreachable.zig
new file mode 100644
index 0000000000000000000000000000000000000000..b043108737805b841e274e1787145796448b94c7
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/cast_unreachable.zig
@@ -0,0 +1,11 @@
+fn f() i32 {
+    return @as(i32, return 1);
+}
+export fn entry() void { _ = f(); }
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:2:12: error: unreachable code
+// tmp.zig:2:21: note: control flow is diverted here
diff --git a/test/cases/compile_errors/stage1/obj/casting_bit_offset_pointer_to_regular_pointer.zig b/test/cases/compile_errors/stage1/obj/casting_bit_offset_pointer_to_regular_pointer.zig
new file mode 100644
index 0000000000000000000000000000000000000000..f109cdf2955bf947976dd16b1f5de07bec3d4216
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/casting_bit_offset_pointer_to_regular_pointer.zig
@@ -0,0 +1,21 @@
+const BitField = packed struct {
+    a: u3,
+    b: u3,
+    c: u2,
+};
+
+fn foo(bit_field: *const BitField) u3 {
+    return bar(&bit_field.b);
+}
+
+fn bar(x: *const u3) u3 {
+    return x.*;
+}
+
+export fn entry() usize { return @sizeOf(@TypeOf(foo)); }
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:8:26: error: expected type '*const u3', found '*align(:3:1) const u3'
diff --git a/test/cases/compile_errors/stage1/obj/catch_on_undefined_value.zig b/test/cases/compile_errors/stage1/obj/catch_on_undefined_value.zig
new file mode 100644
index 0000000000000000000000000000000000000000..53a5f1c2a958df64ecd574fd082b91ec9439fada
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/catch_on_undefined_value.zig
@@ -0,0 +1,10 @@
+comptime {
+    var a: anyerror!bool = undefined;
+    _ = a catch false;
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:3:11: error: use of undefined value here causes undefined behavior
diff --git a/test/cases/compile_errors/stage1/obj/chained_comparison_operators.zig b/test/cases/compile_errors/stage1/obj/chained_comparison_operators.zig
new file mode 100644
index 0000000000000000000000000000000000000000..1e4ed8d82e1b7dcb925f05ac6f5ec443f94cfb45
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/chained_comparison_operators.zig
@@ -0,0 +1,9 @@
+export fn a(value: u32) bool {
+    return 1 < value < 1000;
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:2:22: error: comparison operators cannot be chained
diff --git a/test/cases/compile_errors/stage1/obj/cmpxchg_with_float.zig b/test/cases/compile_errors/stage1/obj/cmpxchg_with_float.zig
new file mode 100644
index 0000000000000000000000000000000000000000..11f2dc21c31bf50b88373242f696da9c903ddd08
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/cmpxchg_with_float.zig
@@ -0,0 +1,10 @@
+export fn entry() void {
+    var x: f32 = 0;
+    _ = @cmpxchgWeak(f32, &x, 1, 2, .SeqCst, .SeqCst);
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:3:22: error: expected bool, integer, enum or pointer type, found 'f32'
diff --git a/test/cases/compile_errors/stage1/obj/colliding_invalid_top_level_functions.zig b/test/cases/compile_errors/stage1/obj/colliding_invalid_top_level_functions.zig
new file mode 100644
index 0000000000000000000000000000000000000000..344edbaa9fa2fbd73a93f00e9a8a067b4e61a00f
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/colliding_invalid_top_level_functions.zig
@@ -0,0 +1,10 @@
+fn func() bogus {}
+fn func() bogus {}
+export fn entry() usize { return @sizeOf(@TypeOf(func)); }
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:2:1: error: redeclaration of 'func'
+// tmp.zig:1:1: note: other declaration here
diff --git a/test/cases/compile_errors/stage1/obj/compare_optional_to_non-optional_with_invalid_types.zig b/test/cases/compile_errors/stage1/obj/compare_optional_to_non-optional_with_invalid_types.zig
new file mode 100644
index 0000000000000000000000000000000000000000..32e1fe9b246381a8b09016ac565d9ac36655b298
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/compare_optional_to_non-optional_with_invalid_types.zig
@@ -0,0 +1,35 @@
+export fn inconsistentChildType() void {
+    var x: ?i32 = undefined;
+    const y: comptime_int = 10;
+    _ = (x == y);
+}
+
+export fn optionalToOptional() void {
+    var x: ?i32 = undefined;
+    var y: ?i32 = undefined;
+    _ = (x == y);
+}
+
+export fn optionalVector() void {
+    var x: ?@Vector(10, i32) = undefined;
+    var y: @Vector(10, i32) = undefined;
+    _ = (x == y);
+}
+
+export fn invalidChildType() void {
+    var x: ?[3]i32 = undefined;
+    var y: [3]i32 = undefined;
+    _ = (x == y);
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// :4:12: error: cannot compare types '?i32' and 'comptime_int'
+// :4:12: note: optional child type 'i32' must be the same as non-optional type 'comptime_int'
+// :10:12: error: cannot compare types '?i32' and '?i32'
+// :10:12: note: optional to optional comparison is only supported for optional pointer types
+// :16:12: error: TODO add comparison of optional vector
+// :22:12: error: cannot compare types '?[3]i32' and '[3]i32'
+// :22:12: note: operator not supported for type '[3]i32'
diff --git a/test/cases/compile_errors/stage1/obj/comparing_a_non-optional_pointer_against_null.zig b/test/cases/compile_errors/stage1/obj/comparing_a_non-optional_pointer_against_null.zig
new file mode 100644
index 0000000000000000000000000000000000000000..62b570803494ef8c4cb2ec15a8388b762e4960b8
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/comparing_a_non-optional_pointer_against_null.zig
@@ -0,0 +1,10 @@
+export fn entry() void {
+    var x: i32 = 1;
+    _ = &x == null;
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:3:12: error: comparison of '*i32' with null
diff --git a/test/cases/compile_errors/stage1/obj/comparing_against_undefined_produces_undefined_value.zig b/test/cases/compile_errors/stage1/obj/comparing_against_undefined_produces_undefined_value.zig
new file mode 100644
index 0000000000000000000000000000000000000000..8bad61e6d1d6321166386d17fe4c60db4800c623
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/comparing_against_undefined_produces_undefined_value.zig
@@ -0,0 +1,9 @@
+export fn entry() void {
+    if (2 == undefined) {}
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:2:11: error: use of undefined value here causes undefined behavior
diff --git a/test/cases/compile_errors/stage1/obj/comparison_operators_with_undefined_value.zig b/test/cases/compile_errors/stage1/obj/comparison_operators_with_undefined_value.zig
new file mode 100644
index 0000000000000000000000000000000000000000..818a575fc8b30cfd26929eb61b6923f9a5cd85bb
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/comparison_operators_with_undefined_value.zig
@@ -0,0 +1,47 @@
+// operator ==
+comptime {
+    var a: i64 = undefined;
+    var x: i32 = 0;
+    if (a == a) x += 1;
+}
+// operator !=
+comptime {
+    var a: i64 = undefined;
+    var x: i32 = 0;
+    if (a != a) x += 1;
+}
+// operator >
+comptime {
+    var a: i64 = undefined;
+    var x: i32 = 0;
+    if (a > a) x += 1;
+}
+// operator <
+comptime {
+    var a: i64 = undefined;
+    var x: i32 = 0;
+    if (a < a) x += 1;
+}
+// operator >=
+comptime {
+    var a: i64 = undefined;
+    var x: i32 = 0;
+    if (a >= a) x += 1;
+}
+// operator <=
+comptime {
+    var a: i64 = undefined;
+    var x: i32 = 0;
+    if (a <= a) x += 1;
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:5:11: error: use of undefined value here causes undefined behavior
+// tmp.zig:11:11: error: use of undefined value here causes undefined behavior
+// tmp.zig:17:11: error: use of undefined value here causes undefined behavior
+// tmp.zig:23:11: error: use of undefined value here causes undefined behavior
+// tmp.zig:29:11: error: use of undefined value here causes undefined behavior
+// tmp.zig:35:11: error: use of undefined value here causes undefined behavior
diff --git a/test/cases/compile_errors/stage1/obj/comparison_with_error_union_and_error_value.zig b/test/cases/compile_errors/stage1/obj/comparison_with_error_union_and_error_value.zig
new file mode 100644
index 0000000000000000000000000000000000000000..16f3b21c3d39a539fb324f9f62e4874eb028ba79
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/comparison_with_error_union_and_error_value.zig
@@ -0,0 +1,10 @@
+export fn entry() void {
+    var number_or_error: anyerror!i32 = error.SomethingAwful;
+    _ = number_or_error == error.SomethingAwful;
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:3:25: error: operator not allowed for type 'anyerror!i32'
diff --git a/test/cases/compile_errors/stage1/obj/compile-time_division_by_zero.zig b/test/cases/compile_errors/stage1/obj/compile-time_division_by_zero.zig
new file mode 100644
index 0000000000000000000000000000000000000000..e16f5f8cf40daa97aa8da6e62898055520129cc3
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/compile-time_division_by_zero.zig
@@ -0,0 +1,12 @@
+comptime {
+    const a: i32 = 1;
+    const b: i32 = 0;
+    const c = a / b;
+    _ = c;
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:4:17: error: division by zero
diff --git a/test/cases/compile_errors/stage1/obj/compile-time_remainder_division_by_zero.zig b/test/cases/compile_errors/stage1/obj/compile-time_remainder_division_by_zero.zig
new file mode 100644
index 0000000000000000000000000000000000000000..63f0def52c1e50e85118461ba84a00e30559ce31
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/compile-time_remainder_division_by_zero.zig
@@ -0,0 +1,12 @@
+comptime {
+    const a: i32 = 1;
+    const b: i32 = 0;
+    const c = a % b;
+    _ = c;
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:4:17: error: division by zero
diff --git a/test/cases/compile_errors/stage1/obj/compileError_shows_traceback_of_references_that_caused_it.zig b/test/cases/compile_errors/stage1/obj/compileError_shows_traceback_of_references_that_caused_it.zig
new file mode 100644
index 0000000000000000000000000000000000000000..c58e9b77680998a77442bc2900d396b5337df346
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/compileError_shows_traceback_of_references_that_caused_it.zig
@@ -0,0 +1,14 @@
+const foo = @compileError("aoeu",);
+
+const bar = baz + foo;
+const baz = 1;
+
+export fn entry() i32 {
+    return bar;
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:1:13: error: aoeu
diff --git a/test/cases/compile_errors/stage1/obj/compileLog_of_tagged_enum_doesnt_crash_the_compiler.zig b/test/cases/compile_errors/stage1/obj/compileLog_of_tagged_enum_doesnt_crash_the_compiler.zig
new file mode 100644
index 0000000000000000000000000000000000000000..36e1ee111850e05b7be54c3017c49bbc61d94205
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/compileLog_of_tagged_enum_doesnt_crash_the_compiler.zig
@@ -0,0 +1,17 @@
+const Bar = union(enum(u32)) {
+    X: i32 = 1
+};
+
+fn testCompileLog(x: Bar) void {
+    @compileLog(x);
+}
+
+pub fn main () void {
+    comptime testCompileLog(Bar{.X = 123});
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:6:5: error: found compile log statement
diff --git a/test/cases/compile_errors/stage1/obj/compile_error_in_struct_init_expression.zig b/test/cases/compile_errors/stage1/obj/compile_error_in_struct_init_expression.zig
new file mode 100644
index 0000000000000000000000000000000000000000..041d09b0026eff658af85697258f1bfcd6abcfdb
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/compile_error_in_struct_init_expression.zig
@@ -0,0 +1,16 @@
+const Foo = struct {
+    a: i32 = crap,
+    b: i32,
+};
+export fn entry() void {
+    var x = Foo{
+        .b = 5,
+    };
+    _ = x;
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:2:14: error: use of undeclared identifier 'crap'
diff --git a/test/cases/compile_errors/stage1/obj/compile_error_when_evaluating_return_type_of_inferred_error_set.zig b/test/cases/compile_errors/stage1/obj/compile_error_when_evaluating_return_type_of_inferred_error_set.zig
new file mode 100644
index 0000000000000000000000000000000000000000..7b1d11b0a43962a9af927bd4e6b719142cc8e8b3
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/compile_error_when_evaluating_return_type_of_inferred_error_set.zig
@@ -0,0 +1,14 @@
+const Car = struct {
+    foo: *SymbolThatDoesNotExist,
+    pub fn init() !Car {}
+};
+export fn entry() void {
+    const car = Car.init();
+    _ = car;
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:2:11: error: use of undeclared identifier 'SymbolThatDoesNotExist'
diff --git a/test/cases/compile_errors/stage1/obj/compile_log.zig b/test/cases/compile_errors/stage1/obj/compile_log.zig
new file mode 100644
index 0000000000000000000000000000000000000000..7f5d52240769afe7e61eb9f70ed52ef8f9c6f6fb
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/compile_log.zig
@@ -0,0 +1,16 @@
+export fn foo() void {
+    comptime bar(12, "hi",);
+}
+fn bar(a: i32, b: []const u8) void {
+    @compileLog("begin",);
+    @compileLog("a", a, "b", b);
+    @compileLog("end",);
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:5:5: error: found compile log statement
+// tmp.zig:6:5: error: found compile log statement
+// tmp.zig:7:5: error: found compile log statement
diff --git a/test/cases/compile_errors/stage1/obj/compile_log_a_pointer_to_an_opaque_value.zig b/test/cases/compile_errors/stage1/obj/compile_log_a_pointer_to_an_opaque_value.zig
new file mode 100644
index 0000000000000000000000000000000000000000..d585712b8ac4752808d6ade84a270bb917b250fd
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/compile_log_a_pointer_to_an_opaque_value.zig
@@ -0,0 +1,9 @@
+export fn entry() void {
+    @compileLog(@ptrCast(*const anyopaque, &entry));
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:2:5: error: found compile log statement
diff --git a/test/cases/compile_errors/stage1/obj/compile_log_statement_inside_function_which_must_be_comptime_evaluated.zig b/test/cases/compile_errors/stage1/obj/compile_log_statement_inside_function_which_must_be_comptime_evaluated.zig
new file mode 100644
index 0000000000000000000000000000000000000000..19b96048cb90dd9857a26f57ee8a77e8d757edf7
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/compile_log_statement_inside_function_which_must_be_comptime_evaluated.zig
@@ -0,0 +1,14 @@
+fn Foo(comptime T: type) type {
+    @compileLog(@typeName(T));
+    return T;
+}
+export fn entry() void {
+    _ = Foo(i32);
+    _ = @typeName(Foo(i32));
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:2:5: error: found compile log statement
diff --git a/test/cases/compile_errors/stage1/obj/compile_log_statement_warning_deduplication_in_generic_fn.zig b/test/cases/compile_errors/stage1/obj/compile_log_statement_warning_deduplication_in_generic_fn.zig
new file mode 100644
index 0000000000000000000000000000000000000000..991021932de33be551079056aae4ee8060183a7d
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/compile_log_statement_warning_deduplication_in_generic_fn.zig
@@ -0,0 +1,14 @@
+export fn entry() void {
+    inner(1);
+    inner(2);
+}
+fn inner(comptime n: usize) void {
+    comptime var i = 0;
+    inline while (i < n) : (i += 1) { @compileLog("!@#$"); }
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:7:39: error: found compile log statement
diff --git a/test/cases/compile_errors/stage1/obj/compile_time_division_by_zero.zig b/test/cases/compile_errors/stage1/obj/compile_time_division_by_zero.zig
new file mode 100644
index 0000000000000000000000000000000000000000..7f7e168f027cc4221584ed770602b8a86b937c7a
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/compile_time_division_by_zero.zig
@@ -0,0 +1,12 @@
+const y = foo(0);
+fn foo(x: u32) u32 {
+    return 1 / x;
+}
+
+export fn entry() usize { return @sizeOf(@TypeOf(y)); }
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:3:14: error: division by zero
diff --git a/test/cases/compile_errors/stage1/obj/comptime_cast_enum_to_union_but_field_has_payload.zig b/test/cases/compile_errors/stage1/obj/comptime_cast_enum_to_union_but_field_has_payload.zig
new file mode 100644
index 0000000000000000000000000000000000000000..c3cf9e76e5029a8d274d43ddfecfc2e12dd40b70
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/comptime_cast_enum_to_union_but_field_has_payload.zig
@@ -0,0 +1,17 @@
+const Letter = enum { A, B, C };
+const Value = union(Letter) {
+    A: i32,
+    B,
+    C,
+};
+export fn entry() void {
+    var x: Value = Letter.A;
+    _ = x;
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:8:26: error: cast to union 'Value' must initialize 'i32' field 'A'
+// tmp.zig:3:5: note: field 'A' declared here
diff --git a/test/cases/compile_errors/stage1/obj/comptime_continue_inside_runtime_catch.zig b/test/cases/compile_errors/stage1/obj/comptime_continue_inside_runtime_catch.zig
new file mode 100644
index 0000000000000000000000000000000000000000..7eefeb80b4a1f31c3855d85811752a4e970ee104
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/comptime_continue_inside_runtime_catch.zig
@@ -0,0 +1,16 @@
+export fn entry() void {
+    const ints = [_]u8{ 1, 2 };
+    inline for (ints) |_| {
+        bad() catch continue;
+    }
+}
+fn bad() !void {
+    return error.Bad;
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:4:21: error: comptime control flow inside runtime block
+// tmp.zig:4:15: note: runtime block created here
diff --git a/test/cases/compile_errors/stage1/obj/comptime_continue_inside_runtime_if_bool.zig b/test/cases/compile_errors/stage1/obj/comptime_continue_inside_runtime_if_bool.zig
new file mode 100644
index 0000000000000000000000000000000000000000..9ace5ddceb6513056031aa183fdcff5070c31245
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/comptime_continue_inside_runtime_if_bool.zig
@@ -0,0 +1,15 @@
+export fn entry() void {
+    var p: usize = undefined;
+    comptime var q = true;
+    inline while (q) {
+        if (p == 11) continue;
+        q = false;
+    }
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:5:22: error: comptime control flow inside runtime block
+// tmp.zig:5:9: note: runtime block created here
diff --git a/test/cases/compile_errors/stage1/obj/comptime_continue_inside_runtime_if_error.zig b/test/cases/compile_errors/stage1/obj/comptime_continue_inside_runtime_if_error.zig
new file mode 100644
index 0000000000000000000000000000000000000000..554ba3c43e5ab55e5855acaf1a24269d87b85d77
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/comptime_continue_inside_runtime_if_error.zig
@@ -0,0 +1,15 @@
+export fn entry() void {
+    var p: anyerror!i32 = undefined;
+    comptime var q = true;
+    inline while (q) {
+        if (p) |_| continue else |_| {}
+        q = false;
+    }
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:5:20: error: comptime control flow inside runtime block
+// tmp.zig:5:9: note: runtime block created here
diff --git a/test/cases/compile_errors/stage1/obj/comptime_continue_inside_runtime_if_optional.zig b/test/cases/compile_errors/stage1/obj/comptime_continue_inside_runtime_if_optional.zig
new file mode 100644
index 0000000000000000000000000000000000000000..32c71e5c7751725196a0e809f43e369ff24dec41
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/comptime_continue_inside_runtime_if_optional.zig
@@ -0,0 +1,15 @@
+export fn entry() void {
+    var p: ?i32 = undefined;
+    comptime var q = true;
+    inline while (q) {
+        if (p) |_| continue;
+        q = false;
+    }
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:5:20: error: comptime control flow inside runtime block
+// tmp.zig:5:9: note: runtime block created here
diff --git a/test/cases/compile_errors/stage1/obj/comptime_continue_inside_runtime_switch.zig b/test/cases/compile_errors/stage1/obj/comptime_continue_inside_runtime_switch.zig
new file mode 100644
index 0000000000000000000000000000000000000000..d145897b4167ff3892fcd35e0e87100759bbdcc2
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/comptime_continue_inside_runtime_switch.zig
@@ -0,0 +1,18 @@
+export fn entry() void {
+    var p: i32 = undefined;
+    comptime var q = true;
+    inline while (q) {
+        switch (p) {
+            11 => continue,
+            else => {},
+        }
+        q = false;
+    }
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:6:19: error: comptime control flow inside runtime block
+// tmp.zig:5:9: note: runtime block created here
diff --git a/test/cases/compile_errors/stage1/obj/comptime_continue_inside_runtime_while_bool.zig b/test/cases/compile_errors/stage1/obj/comptime_continue_inside_runtime_while_bool.zig
new file mode 100644
index 0000000000000000000000000000000000000000..8e57854728208344098e268d501647199e51106c
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/comptime_continue_inside_runtime_while_bool.zig
@@ -0,0 +1,15 @@
+export fn entry() void {
+    var p: usize = undefined;
+    comptime var q = true;
+    outer: inline while (q) {
+        while (p == 11) continue :outer;
+        q = false;
+    }
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:5:25: error: comptime control flow inside runtime block
+// tmp.zig:5:9: note: runtime block created here
diff --git a/test/cases/compile_errors/stage1/obj/comptime_continue_inside_runtime_while_error.zig b/test/cases/compile_errors/stage1/obj/comptime_continue_inside_runtime_while_error.zig
new file mode 100644
index 0000000000000000000000000000000000000000..818455c3540bb7ae27e552703411a5ce023540d2
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/comptime_continue_inside_runtime_while_error.zig
@@ -0,0 +1,17 @@
+export fn entry() void {
+    var p: anyerror!usize = undefined;
+    comptime var q = true;
+    outer: inline while (q) {
+        while (p) |_| {
+            continue :outer;
+        } else |_| {}
+        q = false;
+    }
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:6:13: error: comptime control flow inside runtime block
+// tmp.zig:5:9: note: runtime block created here
diff --git a/test/cases/compile_errors/stage1/obj/comptime_continue_inside_runtime_while_optional.zig b/test/cases/compile_errors/stage1/obj/comptime_continue_inside_runtime_while_optional.zig
new file mode 100644
index 0000000000000000000000000000000000000000..ed22cc2cacc6573104293ab240be3e39413303ed
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/comptime_continue_inside_runtime_while_optional.zig
@@ -0,0 +1,15 @@
+export fn entry() void {
+    var p: ?usize = undefined;
+    comptime var q = true;
+    outer: inline while (q) {
+        while (p) |_| continue :outer;
+        q = false;
+    }
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:5:23: error: comptime control flow inside runtime block
+// tmp.zig:5:9: note: runtime block created here
diff --git a/test/cases/compile_errors/stage1/obj/comptime_float_in_asm_input.zig b/test/cases/compile_errors/stage1/obj/comptime_float_in_asm_input.zig
new file mode 100644
index 0000000000000000000000000000000000000000..92ffadc4f7b6431ae6985ae0e6ae45932c2be649
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/comptime_float_in_asm_input.zig
@@ -0,0 +1,9 @@
+export fn foo() void {
+    asm volatile ("" : : [bar]"r"(3.17) : "");
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:2:35: error: expected sized integer or sized float, found comptime_float
diff --git a/test/cases/compile_errors/stage1/obj/comptime_implicit_cast_f64_to_f32.zig b/test/cases/compile_errors/stage1/obj/comptime_implicit_cast_f64_to_f32.zig
new file mode 100644
index 0000000000000000000000000000000000000000..af5d49c7cbf4a139206d2493864621b4dea3edd8
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/comptime_implicit_cast_f64_to_f32.zig
@@ -0,0 +1,11 @@
+export fn entry() void {
+    const x: f64 = 16777217;
+    const y: f32 = x;
+    _ = y;
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:3:20: error: cast of value 16777217.000000 to type 'f32' loses information
diff --git a/test/cases/compile_errors/stage1/obj/comptime_int_in_asm_input.zig b/test/cases/compile_errors/stage1/obj/comptime_int_in_asm_input.zig
new file mode 100644
index 0000000000000000000000000000000000000000..3e3ccf8c2738073424d8e735b2f9ed14edc0a6dc
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/comptime_int_in_asm_input.zig
@@ -0,0 +1,9 @@
+export fn foo() void {
+    asm volatile ("" : : [bar]"r"(3) : "");
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:2:35: error: expected sized integer or sized float, found comptime_int
diff --git a/test/cases/compile_errors/stage1/obj/comptime_ptrcast_of_zero-sized_type.zig b/test/cases/compile_errors/stage1/obj/comptime_ptrcast_of_zero-sized_type.zig
new file mode 100644
index 0000000000000000000000000000000000000000..231e735cfa4d58e356123505bb6c8f7134146963
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/comptime_ptrcast_of_zero-sized_type.zig
@@ -0,0 +1,12 @@
+fn foo() void {
+    const node: struct {} = undefined;
+    const vla_ptr = @ptrCast([*]const u8, &node);
+    _ = vla_ptr;
+}
+comptime { foo(); }
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:3:21: error: '*const struct:2:17' and '[*]const u8' do not have the same in-memory representation
diff --git a/test/cases/compile_errors/stage1/obj/comptime_slice-sentinel_does_not_match_memory_at_target_index_terminated.zig b/test/cases/compile_errors/stage1/obj/comptime_slice-sentinel_does_not_match_memory_at_target_index_terminated.zig
new file mode 100644
index 0000000000000000000000000000000000000000..598d23a305ba1c9e28f9f1e8fd2379ebbc5a3863
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/comptime_slice-sentinel_does_not_match_memory_at_target_index_terminated.zig
@@ -0,0 +1,67 @@
+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 {
+    comptime {
+        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 {
+    comptime {
+        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 {
+    comptime {
+        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 {
+    comptime {
+        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 {
+    comptime {
+        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 {
+    comptime {
+        var buf = [_:0]u8{ 'a', 'b', 'c', 'd' } ++ [_]u8{undefined} ** 10;
+        var target: []u8 = &buf;
+        const slice = target[0..3 :0];
+        _ = slice;
+    }
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// :4:29: error: slice-sentinel does not match memory at target index
+// :12:29: error: slice-sentinel does not match memory at target index
+// :20:29: error: slice-sentinel does not match memory at target index
+// :28:29: error: slice-sentinel does not match memory at target index
+// :36:29: error: slice-sentinel does not match memory at target index
+// :44:29: error: slice-sentinel does not match memory at target index
+// :52:29: error: slice-sentinel does not match memory at target index
diff --git a/test/cases/compile_errors/stage1/obj/comptime_slice-sentinel_does_not_match_memory_at_target_index_unterminated.zig b/test/cases/compile_errors/stage1/obj/comptime_slice-sentinel_does_not_match_memory_at_target_index_unterminated.zig
new file mode 100644
index 0000000000000000000000000000000000000000..d6b469aaf164d55a85c886799aff7cb033866391
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/comptime_slice-sentinel_does_not_match_memory_at_target_index_unterminated.zig
@@ -0,0 +1,67 @@
+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 {
+    comptime {
+        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 {
+    comptime {
+        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 {
+    comptime {
+        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 {
+    comptime {
+        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 {
+    comptime {
+        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 {
+    comptime {
+        var buf = [_]u8{ 'a', 'b', 'c', 'd' } ++ [_]u8{undefined} ** 10;
+        var target: []u8 = &buf;
+        const slice = target[0..3 :0];
+        _ = slice;
+    }
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// :4:29: error: slice-sentinel does not match memory at target index
+// :12:29: error: slice-sentinel does not match memory at target index
+// :20:29: error: slice-sentinel does not match memory at target index
+// :28:29: error: slice-sentinel does not match memory at target index
+// :36:29: error: slice-sentinel does not match memory at target index
+// :44:29: error: slice-sentinel does not match memory at target index
+// :52:29: error: slice-sentinel does not match memory at target index
diff --git a/test/cases/compile_errors/stage1/obj/comptime_slice-sentinel_does_not_match_target-sentinel.zig b/test/cases/compile_errors/stage1/obj/comptime_slice-sentinel_does_not_match_target-sentinel.zig
new file mode 100644
index 0000000000000000000000000000000000000000..b204cfc6840d6bc557585665348883f063e63730
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/comptime_slice-sentinel_does_not_match_target-sentinel.zig
@@ -0,0 +1,67 @@
+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 {
+    comptime {
+        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 {
+    comptime {
+        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 {
+    comptime {
+        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 {
+    comptime {
+        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 {
+    comptime {
+        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 {
+    comptime {
+        var buf = [_:0]u8{ 'a', 'b', 'c', 'd' } ++ [_]u8{undefined} ** 10;
+        var target: []u8 = &buf;
+        const slice = target[0..14 :255];
+        _ = slice;
+    }
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// :4:29: error: slice-sentinel does not match target-sentinel
+// :12:29: error: slice-sentinel does not match target-sentinel
+// :20:29: error: slice-sentinel does not match target-sentinel
+// :28:29: error: slice-sentinel does not match target-sentinel
+// :36:29: error: slice-sentinel does not match target-sentinel
+// :44:29: error: slice-sentinel does not match target-sentinel
+// :52:29: error: slice-sentinel does not match target-sentinel
diff --git a/test/cases/compile_errors/stage1/obj/comptime_slice-sentinel_is_out_of_bounds_terminated.zig b/test/cases/compile_errors/stage1/obj/comptime_slice-sentinel_is_out_of_bounds_terminated.zig
new file mode 100644
index 0000000000000000000000000000000000000000..82c19126c0bc97729cde29149e6fa79e0c099e44
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/comptime_slice-sentinel_is_out_of_bounds_terminated.zig
@@ -0,0 +1,67 @@
+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 {
+    comptime {
+        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 {
+    comptime {
+        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 {
+    comptime {
+        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 {
+    comptime {
+        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 {
+    comptime {
+        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 {
+    comptime {
+        var buf = [_:0]u8{ 'a', 'b', 'c', 'd' } ++ [_]u8{undefined} ** 10;
+        var target: []u8 = &buf;
+        const slice = target[0..15 :0];
+        _ = slice;
+    }
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// :4:29: error: out of bounds slice
+// :12:29: error: out of bounds slice
+// :20:29: error: out of bounds slice
+// :28:29: error: out of bounds slice
+// :36:29: error: out of bounds slice
+// :44:29: error: out of bounds slice
+// :52:29: error: out of bounds slice
diff --git a/test/cases/compile_errors/stage1/obj/comptime_slice-sentinel_is_out_of_bounds_unterminated.zig b/test/cases/compile_errors/stage1/obj/comptime_slice-sentinel_is_out_of_bounds_unterminated.zig
new file mode 100644
index 0000000000000000000000000000000000000000..952b17600a80e7b4503152802cb5a930ddc05634
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/comptime_slice-sentinel_is_out_of_bounds_unterminated.zig
@@ -0,0 +1,67 @@
+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 {
+    comptime {
+        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 {
+    comptime {
+        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 {
+    comptime {
+        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 {
+    comptime {
+        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 {
+    comptime {
+        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 {
+    comptime {
+        var buf = [_]u8{ 'a', 'b', 'c', 'd' } ++ [_]u8{undefined} ** 10;
+        var target: []u8 = &buf;
+        const slice = target[0..14 :0];
+        _ = slice;
+    }
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// :4:29: error: slice-sentinel is out of bounds
+// :12:29: error: slice-sentinel is out of bounds
+// :20:29: error: slice-sentinel is out of bounds
+// :28:29: error: slice-sentinel is out of bounds
+// :36:29: error: slice-sentinel is out of bounds
+// :44:29: error: slice-sentinel is out of bounds
+// :52:29: error: slice-sentinel is out of bounds
diff --git a/test/cases/compile_errors/stage1/obj/comptime_slice_of_an_undefined_slice.zig b/test/cases/compile_errors/stage1/obj/comptime_slice_of_an_undefined_slice.zig
new file mode 100644
index 0000000000000000000000000000000000000000..4aa519f41ee031d2f7a103ab5505cfde1a887599
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/comptime_slice_of_an_undefined_slice.zig
@@ -0,0 +1,11 @@
+comptime {
+    var a: []u8 = undefined;
+    var b = a[0..10];
+    _ = b;
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:3:14: error: slice of undefined
diff --git a/test/cases/compile_errors/stage1/obj/comptime_slice_of_undefined_pointer_non-zero_len.zig b/test/cases/compile_errors/stage1/obj/comptime_slice_of_undefined_pointer_non-zero_len.zig
new file mode 100644
index 0000000000000000000000000000000000000000..ec7fbdc6e2d7f8badd0fbae6c4ee71d245cbef64
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/comptime_slice_of_undefined_pointer_non-zero_len.zig
@@ -0,0 +1,10 @@
+export fn entry() void {
+    const slice = @as([*]i32, undefined)[0..1];
+    _ = slice;
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:2:41: error: non-zero length slice of undefined pointer
diff --git a/test/cases/compile_errors/stage1/obj/comptime_struct_field_no_init_value.zig b/test/cases/compile_errors/stage1/obj/comptime_struct_field_no_init_value.zig
new file mode 100644
index 0000000000000000000000000000000000000000..b889911a4dcf253ec2e00941ef50e47494a93717
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/comptime_struct_field_no_init_value.zig
@@ -0,0 +1,13 @@
+const Foo = struct {
+    comptime b: i32,
+};
+export fn entry() void {
+    var f: Foo = undefined;
+    _ = f;
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:2:5: error: comptime field without default initialization value
diff --git a/test/cases/compile_errors/stage1/obj/const_frame_cast_to_anyframe.zig b/test/cases/compile_errors/stage1/obj/const_frame_cast_to_anyframe.zig
new file mode 100644
index 0000000000000000000000000000000000000000..affdb953d72f317ea094a806b6c08aa05c135256
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/const_frame_cast_to_anyframe.zig
@@ -0,0 +1,19 @@
+export fn a() void {
+    const f = async func();
+    resume f;
+}
+export fn b() void {
+    const f = async func();
+    var x: anyframe = &f;
+    _ = x;
+}
+fn func() void {
+    suspend {}
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:3:12: error: expected type 'anyframe', found '*const @Frame(func)'
+// tmp.zig:7:24: error: expected type 'anyframe', found '*const @Frame(func)'
diff --git a/test/cases/compile_errors/stage1/obj/const_is_a_statement_not_an_expression.zig b/test/cases/compile_errors/stage1/obj/const_is_a_statement_not_an_expression.zig
new file mode 100644
index 0000000000000000000000000000000000000000..b90878abeb653a690cc8e018f9c6fd5f8a13d9f2
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/const_is_a_statement_not_an_expression.zig
@@ -0,0 +1,9 @@
+export fn f() void {
+    (const a = 0);
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:2:6: error: expected expression, found 'const'
diff --git a/test/cases/compile_errors/stage1/obj/container_init_with_non-type.zig b/test/cases/compile_errors/stage1/obj/container_init_with_non-type.zig
new file mode 100644
index 0000000000000000000000000000000000000000..3364b2f5b61e1f08e1ca3e0b28b2355a069eaba5
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/container_init_with_non-type.zig
@@ -0,0 +1,10 @@
+const zero: i32 = 0;
+const a = zero{1};
+
+export fn entry() usize { return @sizeOf(@TypeOf(a)); }
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:2:11: error: expected type 'type', found 'i32'
diff --git a/test/cases/compile_errors/stage1/obj/control_flow_uses_comptime_var_at_runtime.zig b/test/cases/compile_errors/stage1/obj/control_flow_uses_comptime_var_at_runtime.zig
new file mode 100644
index 0000000000000000000000000000000000000000..cb2c3e9f6eed4abb8a31959366ff92c7bbc6d6b8
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/control_flow_uses_comptime_var_at_runtime.zig
@@ -0,0 +1,15 @@
+export fn foo() void {
+    comptime var i = 0;
+    while (i < 5) : (i += 1) {
+        bar();
+    }
+}
+
+fn bar() void { }
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:3:5: error: control flow attempts to use compile-time variable at runtime
+// tmp.zig:3:24: note: compile-time variable assigned here
diff --git a/test/cases/compile_errors/stage1/obj/control_reaches_end_of_non-void_function.zig b/test/cases/compile_errors/stage1/obj/control_reaches_end_of_non-void_function.zig
new file mode 100644
index 0000000000000000000000000000000000000000..e15c1bd40bcb827a1d99c629de9f9ecc381cccde
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/control_reaches_end_of_non-void_function.zig
@@ -0,0 +1,8 @@
+fn a() i32 {}
+export fn entry() void { _ = a(); }
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:1:12: error: expected type 'i32', found 'void'
diff --git a/test/cases/compile_errors/stage1/obj/declaration_between_fields.zig b/test/cases/compile_errors/stage1/obj/declaration_between_fields.zig
new file mode 100644
index 0000000000000000000000000000000000000000..25a1ff5abc7450a896cdd73605b2b6d523f12d78
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/declaration_between_fields.zig
@@ -0,0 +1,24 @@
+const S = struct {
+    const foo = 2;
+    const bar = 2;
+    const baz = 2;
+    a: struct {
+        a: u32,
+        b: u32,
+    },
+    const foo1 = 2;
+    const bar1 = 2;
+    const baz1 = 2;
+    b: usize,
+};
+comptime {
+    _ = S;
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:9:5: error: declarations are not allowed between container fields
+// tmp.zig:5:5: note: field before declarations here
+// tmp.zig:12:5: note: field after declarations here
diff --git a/test/cases/compile_errors/stage1/obj/declaration_with_same_name_as_primitive_must_use_special_syntax.zig b/test/cases/compile_errors/stage1/obj/declaration_with_same_name_as_primitive_must_use_special_syntax.zig
new file mode 100644
index 0000000000000000000000000000000000000000..46b0257ed5673fa2e417dd0ac159ad736f33ec7d
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/declaration_with_same_name_as_primitive_must_use_special_syntax.zig
@@ -0,0 +1,12 @@
+const u8 = u16;
+export fn entry() void {
+    const a: u8 = 300;
+    _ = a;
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:1:7: error: name shadows primitive 'u8'
+// tmp.zig:1:7: note: consider using @"u8" to disambiguate
diff --git a/test/cases/compile_errors/stage1/obj/deduplicate_undeclared_identifier.zig b/test/cases/compile_errors/stage1/obj/deduplicate_undeclared_identifier.zig
new file mode 100644
index 0000000000000000000000000000000000000000..1e3b3bf6db35bab027549f97f8d93b781541eee6
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/deduplicate_undeclared_identifier.zig
@@ -0,0 +1,12 @@
+export fn a() void {
+    x += 1;
+}
+export fn b() void {
+    x += 1;
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:2:5: error: use of undeclared identifier 'x'
diff --git a/test/cases/compile_errors/stage1/obj/deref_on_undefined_value.zig b/test/cases/compile_errors/stage1/obj/deref_on_undefined_value.zig
new file mode 100644
index 0000000000000000000000000000000000000000..f64d567a26c242685a23f91fb3752134f97b4940
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/deref_on_undefined_value.zig
@@ -0,0 +1,10 @@
+comptime {
+    var a: *u8 = undefined;
+    _ = a.*;
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:3:9: error: attempt to dereference undefined value
diff --git a/test/cases/compile_errors/stage1/obj/deref_slice_and_get_len_field.zig b/test/cases/compile_errors/stage1/obj/deref_slice_and_get_len_field.zig
new file mode 100644
index 0000000000000000000000000000000000000000..98097597cc8f4db61359dd8b2751a63edd4c3dd0
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/deref_slice_and_get_len_field.zig
@@ -0,0 +1,10 @@
+export fn entry() void {
+    var a: []u8 = undefined;
+    _ = a.*.len;
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:3:10: error: attempt to dereference non-pointer type '[]u8'
diff --git a/test/cases/compile_errors/stage1/obj/dereference_an_array.zig b/test/cases/compile_errors/stage1/obj/dereference_an_array.zig
new file mode 100644
index 0000000000000000000000000000000000000000..0dd91f70e53aa347ea69ddd58c570dc119e0aa65
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/dereference_an_array.zig
@@ -0,0 +1,14 @@
+var s_buffer: [10]u8 = undefined;
+pub fn pass(in: []u8) []u8 {
+    var out = &s_buffer;
+    out.*.* = in[0];
+    return out.*[0..1];
+}
+
+export fn entry() usize { return @sizeOf(@TypeOf(pass)); }
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:4:10: error: attempt to dereference non-pointer type '[10]u8'
diff --git a/test/cases/compile_errors/stage1/obj/dereference_unknown_length_pointer.zig b/test/cases/compile_errors/stage1/obj/dereference_unknown_length_pointer.zig
new file mode 100644
index 0000000000000000000000000000000000000000..c305e4bc98abcae6029bd64f708e8ecf2b022a5b
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/dereference_unknown_length_pointer.zig
@@ -0,0 +1,9 @@
+export fn entry(x: [*]i32) i32 {
+    return x.*;
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:2:13: error: index syntax required for unknown-length pointer type '[*]i32'
diff --git a/test/cases/compile_errors/stage1/obj/direct_struct_loop.zig b/test/cases/compile_errors/stage1/obj/direct_struct_loop.zig
new file mode 100644
index 0000000000000000000000000000000000000000..3062e617d68ab393aa0238d4575a3c48667fba59
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/direct_struct_loop.zig
@@ -0,0 +1,8 @@
+const A = struct { a : A, };
+export fn entry() usize { return @sizeOf(A); }
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:1:11: error: struct 'A' depends on itself
diff --git a/test/cases/compile_errors/stage1/obj/directly_embedding_opaque_type_in_struct_and_union.zig b/test/cases/compile_errors/stage1/obj/directly_embedding_opaque_type_in_struct_and_union.zig
new file mode 100644
index 0000000000000000000000000000000000000000..8b8d84ad2a649ca8977b02a04a50fa88d0fa38d9
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/directly_embedding_opaque_type_in_struct_and_union.zig
@@ -0,0 +1,29 @@
+const O = opaque {};
+const Foo = struct {
+    o: O,
+};
+const Bar = union {
+    One: i32,
+    Two: O,
+};
+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;
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// 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:19:22: error: opaque types have unknown size and therefore cannot be directly embedded in structs
diff --git a/test/cases/compile_errors/stage1/obj/disallow_coercion_from_non-null-terminated_pointer_to_null-terminated_pointer.zig b/test/cases/compile_errors/stage1/obj/disallow_coercion_from_non-null-terminated_pointer_to_null-terminated_pointer.zig
new file mode 100644
index 0000000000000000000000000000000000000000..1d0a6216dde20f319ede3315fbd986f4ccd01aa0
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/disallow_coercion_from_non-null-terminated_pointer_to_null-terminated_pointer.zig
@@ -0,0 +1,12 @@
+extern fn puts(s: [*:0]const u8) c_int;
+pub fn main() void {
+    const no_zero_array = [_]u8{'h', 'e', 'l', 'l', 'o'};
+    const no_zero_ptr: [*]const u8 = &no_zero_array;
+    _ = puts(no_zero_ptr);
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:5:14: error: expected type '[*:0]const u8', found '[*]const u8'
diff --git a/test/cases/compile_errors/stage1/obj/discarding_error_value.zig b/test/cases/compile_errors/stage1/obj/discarding_error_value.zig
new file mode 100644
index 0000000000000000000000000000000000000000..dcfa22e8cb3412e1b2741267973eca6d9e3c3884
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/discarding_error_value.zig
@@ -0,0 +1,12 @@
+export fn entry() void {
+    _ = foo();
+}
+fn foo() !void {
+    return error.OutOfMemory;
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:2:12: error: error is discarded. consider using `try`, `catch`, or `if`
diff --git a/test/cases/compile_errors/stage1/obj/div_assign_on_undefined_value.zig b/test/cases/compile_errors/stage1/obj/div_assign_on_undefined_value.zig
new file mode 100644
index 0000000000000000000000000000000000000000..5f18e6286a27390aa974a1c493dd55ccf5de63a6
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/div_assign_on_undefined_value.zig
@@ -0,0 +1,10 @@
+comptime {
+    var a: i64 = undefined;
+    a /= a;
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:3:5: error: use of undefined value here causes undefined behavior
diff --git a/test/cases/compile_errors/stage1/obj/div_on_undefined_value.zig b/test/cases/compile_errors/stage1/obj/div_on_undefined_value.zig
new file mode 100644
index 0000000000000000000000000000000000000000..9857b1c77981d947f731c13c8411d215a8a84f80
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/div_on_undefined_value.zig
@@ -0,0 +1,10 @@
+comptime {
+    var a: i64 = undefined;
+    _ = a / a;
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:3:9: error: use of undefined value here causes undefined behavior
diff --git a/test/cases/compile_errors/stage1/obj/division_by_zero.zig b/test/cases/compile_errors/stage1/obj/division_by_zero.zig
new file mode 100644
index 0000000000000000000000000000000000000000..3023f0c6f3f729891880630b31d43754fc1957ed
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/division_by_zero.zig
@@ -0,0 +1,18 @@
+const lit_int_x = 1 / 0;
+const lit_float_x = 1.0 / 0.0;
+const int_x = @as(u32, 1) / @as(u32, 0);
+const float_x = @as(f32, 1.0) / @as(f32, 0.0);
+
+export fn entry1() usize { return @sizeOf(@TypeOf(lit_int_x)); }
+export fn entry2() usize { return @sizeOf(@TypeOf(lit_float_x)); }
+export fn entry3() usize { return @sizeOf(@TypeOf(int_x)); }
+export fn entry4() usize { return @sizeOf(@TypeOf(float_x)); }
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:1:21: error: division by zero
+// tmp.zig:2:25: error: division by zero
+// tmp.zig:3:27: error: division by zero
+// tmp.zig:4:31: error: division by zero
diff --git a/test/cases/compile_errors/stage1/obj/dont_implicit_cast_double_pointer_to_anyopaque.zig b/test/cases/compile_errors/stage1/obj/dont_implicit_cast_double_pointer_to_anyopaque.zig
new file mode 100644
index 0000000000000000000000000000000000000000..f61dec2ee07f86f50a1188d1e8d50697cf997892
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/dont_implicit_cast_double_pointer_to_anyopaque.zig
@@ -0,0 +1,13 @@
+export fn entry() void {
+    var a: u32 = 1;
+    var ptr: *align(@alignOf(u32)) anyopaque = &a;
+    var b: *u32 = @ptrCast(*u32, ptr);
+    var ptr2: *anyopaque = &b;
+    _ = ptr2;
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:5:29: error: expected type '*anyopaque', found '**u32'
diff --git a/test/cases/compile_errors/stage1/obj/double_optional_on_main_return_value.zig b/test/cases/compile_errors/stage1/obj/double_optional_on_main_return_value.zig
new file mode 100644
index 0000000000000000000000000000000000000000..c61ac400baf048c781f0bee5a4d779696d7583ec
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/double_optional_on_main_return_value.zig
@@ -0,0 +1,8 @@
+pub fn main() ??void {
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// error: expected return type of main to be 'void', '!void', 'noreturn', 'u8', or '!u8'
diff --git a/test/cases/compile_errors/stage1/obj/duplicate_boolean_switch_value.zig b/test/cases/compile_errors/stage1/obj/duplicate_boolean_switch_value.zig
new file mode 100644
index 0000000000000000000000000000000000000000..5b85c0a2eb93e20680e5dbc78b27d0890ac37c96
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/duplicate_boolean_switch_value.zig
@@ -0,0 +1,23 @@
+comptime {
+    const x = switch (true) {
+        true => false,
+        false => true,
+        true => false,
+    };
+    _ = x;
+}
+comptime {
+    const x = switch (true) {
+        false => true,
+        true => false,
+        false => true,
+    };
+    _ = x;
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:5:9: error: duplicate switch value
+// tmp.zig:13:9: error: duplicate switch value
diff --git a/test/cases/compile_errors/stage1/obj/duplicate_enum_field.zig b/test/cases/compile_errors/stage1/obj/duplicate_enum_field.zig
new file mode 100644
index 0000000000000000000000000000000000000000..cd024270bd10f18aefd50c91527404b236c7a45f
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/duplicate_enum_field.zig
@@ -0,0 +1,16 @@
+const Foo = enum {
+    Bar,
+    Bar,
+};
+
+export fn entry() void {
+    const a: Foo = undefined;
+    _ = a;
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:3:5: error: duplicate enum field: 'Bar'
+// tmp.zig:2:5: note: other field here
diff --git a/test/cases/compile_errors/stage1/obj/duplicate_error_in_switch.zig b/test/cases/compile_errors/stage1/obj/duplicate_error_in_switch.zig
new file mode 100644
index 0000000000000000000000000000000000000000..140a14ec81969d9d8eb5fb8d12cdce57c607fa09
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/duplicate_error_in_switch.zig
@@ -0,0 +1,22 @@
+export fn entry() void {
+    foo(452) catch |err| switch (err) {
+        error.Foo => {},
+        error.Bar => {},
+        error.Foo => {},
+        else => {},
+    };
+}
+fn foo(x: i32) !void {
+    switch (x) {
+        0 ... 10 => return error.Foo,
+        11 ... 20 => return error.Bar,
+        else => {},
+    }
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// 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 here
diff --git a/test/cases/compile_errors/stage1/obj/duplicate_error_value_in_error_set.zig b/test/cases/compile_errors/stage1/obj/duplicate_error_value_in_error_set.zig
new file mode 100644
index 0000000000000000000000000000000000000000..30d3bee8ab9d8f3dbb4ac1f6f0e1191fbade1a8f
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/duplicate_error_value_in_error_set.zig
@@ -0,0 +1,15 @@
+const Foo = error {
+    Bar,
+    Bar,
+};
+export fn entry() void {
+    const a: Foo = undefined;
+    _ = a;
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:3:5: error: duplicate error set field 'Bar'
+// tmp.zig:2:5: note: previous declaration here
diff --git a/test/cases/compile_errors/stage1/obj/duplicate_field_in_struct_value_expression.zig b/test/cases/compile_errors/stage1/obj/duplicate_field_in_struct_value_expression.zig
new file mode 100644
index 0000000000000000000000000000000000000000..1c0bac75e2ee9b1ab3a8173dd41059e83379ee7f
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/duplicate_field_in_struct_value_expression.zig
@@ -0,0 +1,20 @@
+const A = struct {
+    x : i32,
+    y : i32,
+    z : i32,
+};
+export fn f() void {
+    const a = A {
+        .z = 1,
+        .y = 2,
+        .x = 3,
+        .z = 4,
+    };
+    _ = a;
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:11:9: error: duplicate field
diff --git a/test/cases/compile_errors/stage1/obj/duplicate_struct_field.zig b/test/cases/compile_errors/stage1/obj/duplicate_struct_field.zig
new file mode 100644
index 0000000000000000000000000000000000000000..93afdef70eded4469ec9def53b25ab34a43f7836
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/duplicate_struct_field.zig
@@ -0,0 +1,15 @@
+const Foo = struct {
+    Bar: i32,
+    Bar: usize,
+};
+export fn entry() void {
+    const a: Foo = undefined;
+    _ = a;
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:3:5: error: duplicate struct field: 'Bar'
+// tmp.zig:2:5: note: other field here
diff --git a/test/cases/compile_errors/stage1/obj/duplicate_union_field.zig b/test/cases/compile_errors/stage1/obj/duplicate_union_field.zig
new file mode 100644
index 0000000000000000000000000000000000000000..5cbdcb7820a6559e19cd613c45aa52d41d7a76b2
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/duplicate_union_field.zig
@@ -0,0 +1,15 @@
+const Foo = union {
+    Bar: i32,
+    Bar: usize,
+};
+export fn entry() void {
+    const a: Foo = undefined;
+    _ = a;
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:3:5: error: duplicate union field: 'Bar'
+// tmp.zig:2:5: note: other field here
diff --git a/test/cases/compile_errors/stage1/obj/embedFile_with_bogus_file.zig b/test/cases/compile_errors/stage1/obj/embedFile_with_bogus_file.zig
new file mode 100644
index 0000000000000000000000000000000000000000..a03949b40a4295082f15b68c348738d89cb42f18
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/embedFile_with_bogus_file.zig
@@ -0,0 +1,9 @@
+const resource = @embedFile("bogus.txt",);
+
+export fn entry() usize { return @sizeOf(@TypeOf(resource)); }
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:1:29: error: unable to find '
diff --git a/test/cases/compile_errors/stage1/obj/empty_for_loop_body.zig b/test/cases/compile_errors/stage1/obj/empty_for_loop_body.zig
new file mode 100644
index 0000000000000000000000000000000000000000..b824c9313181ebd36819aedf1bb1d5f942652743
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/empty_for_loop_body.zig
@@ -0,0 +1,9 @@
+export fn a() void {
+    for(undefined) |x|;
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:2:23: error: expected block or assignment, found ';'
diff --git a/test/cases/compile_errors/stage1/obj/empty_if_body.zig b/test/cases/compile_errors/stage1/obj/empty_if_body.zig
new file mode 100644
index 0000000000000000000000000000000000000000..0a7b5b1b8b70a0ab536c4ca97516be800b3b0fab
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/empty_if_body.zig
@@ -0,0 +1,9 @@
+export fn a() void {
+    if(true);
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:2:13: error: expected block or assignment, found ';'
diff --git a/test/cases/compile_errors/stage1/obj/empty_switch_on_an_integer.zig b/test/cases/compile_errors/stage1/obj/empty_switch_on_an_integer.zig
new file mode 100644
index 0000000000000000000000000000000000000000..a7b8e2a81bd47da183d12713a52efa068450c53d
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/empty_switch_on_an_integer.zig
@@ -0,0 +1,10 @@
+export fn entry() void {
+    var x: u32 = 0;
+    switch(x) {}
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:3:5: error: switch must handle all possibilities
diff --git a/test/cases/compile_errors/stage1/obj/empty_while_loop_body.zig b/test/cases/compile_errors/stage1/obj/empty_while_loop_body.zig
new file mode 100644
index 0000000000000000000000000000000000000000..01b21325188cec26a31063713b72f16f7bde2d26
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/empty_while_loop_body.zig
@@ -0,0 +1,9 @@
+export fn a() void {
+    while(true);
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:2:16: error: expected block or assignment, found ';'
diff --git a/test/cases/compile_errors/stage1/obj/endless_loop_in_function_evaluation.zig b/test/cases/compile_errors/stage1/obj/endless_loop_in_function_evaluation.zig
new file mode 100644
index 0000000000000000000000000000000000000000..302ee242e094611b64e0dcbee97e895b06016c05
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/endless_loop_in_function_evaluation.zig
@@ -0,0 +1,12 @@
+const seventh_fib_number = fibonacci(7);
+fn fibonacci(x: i32) i32 {
+    return fibonacci(x - 1) + fibonacci(x - 2);
+}
+
+export fn entry() usize { return @sizeOf(@TypeOf(seventh_fib_number)); }
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:3:21: error: evaluation exceeded 1000 backwards branches
diff --git a/test/cases/compile_errors/stage1/obj/enum_field_value_references_enum.zig b/test/cases/compile_errors/stage1/obj/enum_field_value_references_enum.zig
new file mode 100644
index 0000000000000000000000000000000000000000..ebf32db5e04242bfd89f4a4befda66f347f6451e
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/enum_field_value_references_enum.zig
@@ -0,0 +1,15 @@
+pub const Foo = enum(c_int) {
+    A = Foo.B,
+    C = D,
+};
+export fn entry() void {
+    var s: Foo = Foo.E;
+    _ = s;
+}
+const D = 1;
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:1:17: error: enum 'Foo' depends on itself
diff --git a/test/cases/compile_errors/stage1/obj/enum_in_field_count_range_but_not_matching_tag.zig b/test/cases/compile_errors/stage1/obj/enum_in_field_count_range_but_not_matching_tag.zig
new file mode 100644
index 0000000000000000000000000000000000000000..e783cbee5293c2d755c32bd167a26e97528d1826
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/enum_in_field_count_range_but_not_matching_tag.zig
@@ -0,0 +1,15 @@
+const Foo = enum(u32) {
+    A = 10,
+    B = 11,
+};
+export fn entry() void {
+    var x = @intToEnum(Foo, 0);
+    _ = x;
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:6:13: error: enum 'Foo' has no tag matching integer value 0
+// tmp.zig:1:13: note: 'Foo' declared here
diff --git a/test/cases/compile_errors/stage1/obj/enum_value_already_taken.zig b/test/cases/compile_errors/stage1/obj/enum_value_already_taken.zig
new file mode 100644
index 0000000000000000000000000000000000000000..60e88f0062de86e0d1dad3064773dc338e1fd93c
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/enum_value_already_taken.zig
@@ -0,0 +1,18 @@
+const MultipleChoice = enum(u32) {
+    A = 20,
+    B = 40,
+    C = 60,
+    D = 1000,
+    E = 60,
+};
+export fn entry() void {
+    var x = MultipleChoice.C;
+    _ = x;
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:6:5: error: enum tag value 60 already taken
+// tmp.zig:4:5: note: other occurrence here
diff --git a/test/cases/compile_errors/stage1/obj/enum_with_0_fields.zig b/test/cases/compile_errors/stage1/obj/enum_with_0_fields.zig
new file mode 100644
index 0000000000000000000000000000000000000000..9ee18f51ca21c32cb7d35173c0faa9309983e1d2
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/enum_with_0_fields.zig
@@ -0,0 +1,7 @@
+const Foo = enum {};
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:1:13: error: enum declarations must have at least one tag
diff --git a/test/cases/compile_errors/stage1/obj/enum_with_declarations_unavailable_for_reify_type.zig b/test/cases/compile_errors/stage1/obj/enum_with_declarations_unavailable_for_reify_type.zig
new file mode 100644
index 0000000000000000000000000000000000000000..ffe9a2a78acabed0e4b018e63f88f76e9e4bb74d
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/enum_with_declarations_unavailable_for_reify_type.zig
@@ -0,0 +1,9 @@
+export fn entry() void {
+    _ = @Type(@typeInfo(enum { foo, const bar = 1; }));
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:2:15: error: Type.Enum.decls must be empty for @Type
diff --git a/test/cases/compile_errors/stage1/obj/error_equality_but_sets_have_no_common_members.zig b/test/cases/compile_errors/stage1/obj/error_equality_but_sets_have_no_common_members.zig
new file mode 100644
index 0000000000000000000000000000000000000000..d42169b5036f40ba0725358de24a370d58b85bc9
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/error_equality_but_sets_have_no_common_members.zig
@@ -0,0 +1,16 @@
+const Set1 = error{A, C};
+const Set2 = error{B, D};
+export fn entry() void {
+    foo(Set1.A);
+}
+fn foo(x: Set1) void {
+    if (x == Set2.B) {
+
+    }
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:7:11: error: error sets 'Set1' and 'Set2' have no common errors
diff --git a/test/cases/compile_errors/stage1/obj/error_not_handled_in_switch.zig b/test/cases/compile_errors/stage1/obj/error_not_handled_in_switch.zig
new file mode 100644
index 0000000000000000000000000000000000000000..12ee35daef7d556a854562dc3afdec5bb17ab7d0
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/error_not_handled_in_switch.zig
@@ -0,0 +1,20 @@
+export fn entry() void {
+    foo(452) catch |err| switch (err) {
+        error.Foo => {},
+    };
+}
+fn foo(x: i32) !void {
+    switch (x) {
+        0 ... 10 => return error.Foo,
+        11 ... 20 => return error.Bar,
+        21 ... 30 => return error.Baz,
+        else => {},
+    }
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:2:26: error: error.Baz not handled in switch
+// tmp.zig:2:26: error: error.Bar not handled in switch
diff --git a/test/cases/compile_errors/stage1/obj/error_note_for_function_parameter_incompatibility.zig b/test/cases/compile_errors/stage1/obj/error_note_for_function_parameter_incompatibility.zig
new file mode 100644
index 0000000000000000000000000000000000000000..edc421d8f43cc25f806dff0f26b73493c8b3d451
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/error_note_for_function_parameter_incompatibility.zig
@@ -0,0 +1,12 @@
+fn do_the_thing(func: fn (arg: i32) void) void { _ = func; }
+fn bar(arg: bool) void { _ = arg; }
+export fn entry() void {
+    do_the_thing(bar);
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// 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'
diff --git a/test/cases/compile_errors/stage1/obj/error_union_operator_with_non_error_set_LHS.zig b/test/cases/compile_errors/stage1/obj/error_union_operator_with_non_error_set_LHS.zig
new file mode 100644
index 0000000000000000000000000000000000000000..785e42fb9b6d2bb0cc935964d8c8145ef2c80f33
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/error_union_operator_with_non_error_set_LHS.zig
@@ -0,0 +1,11 @@
+comptime {
+    const z = i32!i32;
+    var x: z = undefined;
+    _ = x;
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:2:15: error: expected error set type, found type 'i32'
diff --git a/test/cases/compile_errors/stage1/obj/error_when_evaluating_return_type.zig b/test/cases/compile_errors/stage1/obj/error_when_evaluating_return_type.zig
new file mode 100644
index 0000000000000000000000000000000000000000..60731740b79dfaff5366a283ef4ac2b20d4d1f04
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/error_when_evaluating_return_type.zig
@@ -0,0 +1,17 @@
+const Foo = struct {
+    map: @as(i32, i32),
+
+    fn init() Foo {
+        return undefined;
+    }
+};
+export fn entry() void {
+    var rule_set = try Foo.init();
+    _ = rule_set;
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:2:19: error: expected type 'i32', found 'type'
diff --git a/test/cases/compile_errors/stage1/obj/exceeded_maximum_bit_width_of_integer.zig b/test/cases/compile_errors/stage1/obj/exceeded_maximum_bit_width_of_integer.zig
new file mode 100644
index 0000000000000000000000000000000000000000..2a3c795f8187ade0b6ee9b599dd76bad27f079c1
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/exceeded_maximum_bit_width_of_integer.zig
@@ -0,0 +1,15 @@
+export fn entry1() void {
+    const T = u65536;
+    _ = T;
+}
+export fn entry2() void {
+    var x: i65536 = 1;
+    _ = x;
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// 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
diff --git a/test/cases/compile_errors/stage1/obj/explicit_cast_float_literal_to_integer_when_there_is_a_fraction_component.zig b/test/cases/compile_errors/stage1/obj/explicit_cast_float_literal_to_integer_when_there_is_a_fraction_component.zig
new file mode 100644
index 0000000000000000000000000000000000000000..696fef57fa83c849e1b776b394fdbb76d592bfb3
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/explicit_cast_float_literal_to_integer_when_there_is_a_fraction_component.zig
@@ -0,0 +1,9 @@
+export fn entry() i32 {
+    return @as(i32, 12.34);
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:2:21: error: fractional component prevents float value 12.340000 from being casted to type 'i32'
diff --git a/test/cases/compile_errors/stage1/obj/explicit_error_set_cast_known_at_comptime_violates_error_sets.zig b/test/cases/compile_errors/stage1/obj/explicit_error_set_cast_known_at_comptime_violates_error_sets.zig
new file mode 100644
index 0000000000000000000000000000000000000000..4a41920107e283aa1dae9ae42ae7554cba1e8bd1
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/explicit_error_set_cast_known_at_comptime_violates_error_sets.zig
@@ -0,0 +1,13 @@
+const Set1 = error {A, B};
+const Set2 = error {A, C};
+comptime {
+    var x = Set1.B;
+    var y = @errSetCast(Set2, x);
+    _ = y;
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:5:13: error: error.B not a member of error set 'Set2'
diff --git a/test/cases/compile_errors/stage1/obj/explicitly_casting_non_tag_type_to_enum.zig b/test/cases/compile_errors/stage1/obj/explicitly_casting_non_tag_type_to_enum.zig
new file mode 100644
index 0000000000000000000000000000000000000000..1999fd70a7750f7fb0d51ae7b9476d6fe28d99c3
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/explicitly_casting_non_tag_type_to_enum.zig
@@ -0,0 +1,18 @@
+const Small = enum(u2) {
+    One,
+    Two,
+    Three,
+    Four,
+};
+
+export fn entry() void {
+    var y = @as(f32, 3);
+    var x = @intToEnum(Small, y);
+    _ = x;
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:10:31: error: expected integer type, found 'f32'
diff --git a/test/cases/compile_errors/stage1/obj/export_function_with_comptime_parameter.zig b/test/cases/compile_errors/stage1/obj/export_function_with_comptime_parameter.zig
new file mode 100644
index 0000000000000000000000000000000000000000..ccfda1ba67eb7757532b4f60d597c7864ac77074
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/export_function_with_comptime_parameter.zig
@@ -0,0 +1,9 @@
+export fn foo(comptime x: i32, y: i32) i32{
+    return x + y;
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:1:15: error: comptime parameter not allowed in function with calling convention 'C'
diff --git a/test/cases/compile_errors/stage1/obj/export_generic_function.zig b/test/cases/compile_errors/stage1/obj/export_generic_function.zig
new file mode 100644
index 0000000000000000000000000000000000000000..9f6bcd4cf489ab8375e0d63d2ed35c62ff3b7336
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/export_generic_function.zig
@@ -0,0 +1,10 @@
+export fn foo(num: anytype) i32 {
+    _ = num;
+    return 0;
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:1:15: error: parameter of type 'anytype' not allowed in function with calling convention 'C'
diff --git a/test/cases/compile_errors/stage1/obj/exported_async_function.zig b/test/cases/compile_errors/stage1/obj/exported_async_function.zig
new file mode 100644
index 0000000000000000000000000000000000000000..b9ac591227d95ea9cf01595a357c97d4e00950fb
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/exported_async_function.zig
@@ -0,0 +1,7 @@
+export fn foo() callconv(.Async) void {}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:1:1: error: exported function cannot be async
diff --git a/test/cases/compile_errors/stage1/obj/exported_enum_without_explicit_integer_tag_type.zig b/test/cases/compile_errors/stage1/obj/exported_enum_without_explicit_integer_tag_type.zig
new file mode 100644
index 0000000000000000000000000000000000000000..c432bedd6b7179ad8988fcfb7b843d54dffc7f1e
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/exported_enum_without_explicit_integer_tag_type.zig
@@ -0,0 +1,15 @@
+const E = enum { one, two };
+comptime {
+    @export(E, .{ .name = "E" });
+}
+const e: E = .two;
+comptime {
+    @export(e, .{ .name = "e" });
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:3:13: error: exported enum without explicit integer tag type
+// tmp.zig:7:13: error: exported enum value without explicit integer tag type
diff --git a/test/cases/compile_errors/stage1/obj/extern_function_pointer_mismatch.zig b/test/cases/compile_errors/stage1/obj/extern_function_pointer_mismatch.zig
new file mode 100644
index 0000000000000000000000000000000000000000..888b59a6265fa359aa0d97dd58c037f9d0798c75
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/extern_function_pointer_mismatch.zig
@@ -0,0 +1,12 @@
+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;}
+export fn c(x: i32) i32 {return x + 2;}
+
+export fn entry() usize { return @sizeOf(@TypeOf(fns)); }
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:1:37: error: expected type 'fn(i32) i32', found 'fn(i32) callconv(.C) i32'
diff --git a/test/cases/compile_errors/stage1/obj/extern_function_with_comptime_parameter.zig b/test/cases/compile_errors/stage1/obj/extern_function_with_comptime_parameter.zig
new file mode 100644
index 0000000000000000000000000000000000000000..93e26b9543af4b2d63411aa117a2a9698a151987
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/extern_function_with_comptime_parameter.zig
@@ -0,0 +1,11 @@
+extern fn foo(comptime x: i32, y: i32) i32;
+fn f() i32 {
+    return foo(1, 2);
+}
+export fn entry() usize { return @sizeOf(@TypeOf(f)); }
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:1:15: error: comptime parameter not allowed in function with calling convention 'C'
diff --git a/test/cases/compile_errors/stage1/obj/extern_struct_with_extern-compatible_but_inferred_integer_tag_type.zig b/test/cases/compile_errors/stage1/obj/extern_struct_with_extern-compatible_but_inferred_integer_tag_type.zig
new file mode 100644
index 0000000000000000000000000000000000000000..8f45a0e5dc2f5e378e5c80fe46d700db7bc9f10b
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/extern_struct_with_extern-compatible_but_inferred_integer_tag_type.zig
@@ -0,0 +1,43 @@
+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",
+@"24",@"25",@"26",@"27",@"28",@"29",@"30",@"31",@"32",@"33",@"34",
+@"35",@"36",@"37",@"38",@"39",@"40",@"41",@"42",@"43",@"44",@"45",
+@"46",@"47",@"48",@"49",@"50",@"51",@"52",@"53",@"54",@"55",@"56",
+@"57",@"58",@"59",@"60",@"61",@"62",@"63",@"64",@"65",@"66",@"67",
+@"68",@"69",@"70",@"71",@"72",@"73",@"74",@"75",@"76",@"77",@"78",
+@"79",@"80",@"81",@"82",@"83",@"84",@"85",@"86",@"87",@"88",@"89",
+@"90",@"91",@"92",@"93",@"94",@"95",@"96",@"97",@"98",@"99",@"100",
+@"101",@"102",@"103",@"104",@"105",@"106",@"107",@"108",@"109",
+@"110",@"111",@"112",@"113",@"114",@"115",@"116",@"117",@"118",
+@"119",@"120",@"121",@"122",@"123",@"124",@"125",@"126",@"127",
+@"128",@"129",@"130",@"131",@"132",@"133",@"134",@"135",@"136",
+@"137",@"138",@"139",@"140",@"141",@"142",@"143",@"144",@"145",
+@"146",@"147",@"148",@"149",@"150",@"151",@"152",@"153",@"154",
+@"155",@"156",@"157",@"158",@"159",@"160",@"161",@"162",@"163",
+@"164",@"165",@"166",@"167",@"168",@"169",@"170",@"171",@"172",
+@"173",@"174",@"175",@"176",@"177",@"178",@"179",@"180",@"181",
+@"182",@"183",@"184",@"185",@"186",@"187",@"188",@"189",@"190",
+@"191",@"192",@"193",@"194",@"195",@"196",@"197",@"198",@"199",
+@"200",@"201",@"202",@"203",@"204",@"205",@"206",@"207",@"208",
+@"209",@"210",@"211",@"212",@"213",@"214",@"215",@"216",@"217",
+@"218",@"219",@"220",@"221",@"222",@"223",@"224",@"225",@"226",
+@"227",@"228",@"229",@"230",@"231",@"232",@"233",@"234",@"235",
+@"236",@"237",@"238",@"239",@"240",@"241",@"242",@"243",@"244",
+@"245",@"246",@"247",@"248",@"249",@"250",@"251",@"252",@"253",
+@"254",@"255"
+};
+pub const S = extern struct {
+    e: E,
+};
+export fn entry() void {
+    if (@typeInfo(E).Enum.tag_type != u8) @compileError("did not infer u8 tag type");
+    const s: S = undefined;
+    _ = s;
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:31:5: error: extern structs cannot contain fields of type 'E'
diff --git a/test/cases/compile_errors/stage1/obj/extern_struct_with_non-extern-compatible_integer_tag_type.zig b/test/cases/compile_errors/stage1/obj/extern_struct_with_non-extern-compatible_integer_tag_type.zig
new file mode 100644
index 0000000000000000000000000000000000000000..aa508056a192627c3ae7cb35509b6996f40010a2
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/extern_struct_with_non-extern-compatible_integer_tag_type.zig
@@ -0,0 +1,14 @@
+pub const E = enum(u31) { A, B, C };
+pub const S = extern struct {
+    e: E,
+};
+export fn entry() void {
+    const s: S = undefined;
+    _ = s;
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:3:5: error: extern structs cannot contain fields of type 'E'
diff --git a/test/cases/compile_errors/stage1/obj/extern_union_field_missing_type.zig b/test/cases/compile_errors/stage1/obj/extern_union_field_missing_type.zig
new file mode 100644
index 0000000000000000000000000000000000000000..9d8532f8a1dfd622a6003514537fa05f684a5d47
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/extern_union_field_missing_type.zig
@@ -0,0 +1,13 @@
+const Letter = extern union {
+    A,
+};
+export fn entry() void {
+    var a = Letter { .A = {} };
+    _ = a;
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:2:5: error: union field missing type
diff --git a/test/cases/compile_errors/stage1/obj/extern_union_given_enum_tag_type.zig b/test/cases/compile_errors/stage1/obj/extern_union_given_enum_tag_type.zig
new file mode 100644
index 0000000000000000000000000000000000000000..86ac42cccf6891c91542a079ca389ea0939eeb12
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/extern_union_given_enum_tag_type.zig
@@ -0,0 +1,20 @@
+const Letter = enum {
+    A,
+    B,
+    C,
+};
+const Payload = extern union(Letter) {
+    A: i32,
+    B: f64,
+    C: bool,
+};
+export fn entry() void {
+    var a = Payload { .A = 1234 };
+    _ = a;
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:6:30: error: extern union does not support enum tag type
diff --git a/test/cases/compile_errors/stage1/obj/extern_variable_has_no_type.zig b/test/cases/compile_errors/stage1/obj/extern_variable_has_no_type.zig
new file mode 100644
index 0000000000000000000000000000000000000000..58d67f14e110d2937b53765a83b86a34fadd593a
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/extern_variable_has_no_type.zig
@@ -0,0 +1,10 @@
+extern var foo;
+pub export fn entry() void {
+    foo;
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:1:8: error: unable to infer variable type
diff --git a/test/cases/compile_errors/stage1/obj/fieldParentPtr-bad_field_name.zig b/test/cases/compile_errors/stage1/obj/fieldParentPtr-bad_field_name.zig
new file mode 100644
index 0000000000000000000000000000000000000000..73022167f51b481cc5e3c1964560d180f783a04e
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/fieldParentPtr-bad_field_name.zig
@@ -0,0 +1,12 @@
+const Foo = extern struct {
+    derp: i32,
+};
+export fn foo(a: *i32) *Foo {
+    return @fieldParentPtr(Foo, "a", a);
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:5:33: error: struct 'Foo' has no field 'a'
diff --git a/test/cases/compile_errors/stage1/obj/fieldParentPtr-comptime_field_ptr_not_based_on_struct.zig b/test/cases/compile_errors/stage1/obj/fieldParentPtr-comptime_field_ptr_not_based_on_struct.zig
new file mode 100644
index 0000000000000000000000000000000000000000..9375f4639a020f37f1f1320d0978f131279303df
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/fieldParentPtr-comptime_field_ptr_not_based_on_struct.zig
@@ -0,0 +1,17 @@
+const Foo = struct {
+    a: i32,
+    b: i32,
+};
+const foo = Foo { .a = 1, .b = 2, };
+
+comptime {
+    const field_ptr = @intToPtr(*i32, 0x1234);
+    const another_foo_ptr = @fieldParentPtr(Foo, "b", field_ptr);
+    _ = another_foo_ptr;
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:9:55: error: pointer value not based on parent struct
diff --git a/test/cases/compile_errors/stage1/obj/fieldParentPtr-comptime_wrong_field_index.zig b/test/cases/compile_errors/stage1/obj/fieldParentPtr-comptime_wrong_field_index.zig
new file mode 100644
index 0000000000000000000000000000000000000000..c322543dc01886dc35b4f455ffce8fe92a8aed12
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/fieldParentPtr-comptime_wrong_field_index.zig
@@ -0,0 +1,16 @@
+const Foo = struct {
+    a: i32,
+    b: i32,
+};
+const foo = Foo { .a = 1, .b = 2, };
+
+comptime {
+    const another_foo_ptr = @fieldParentPtr(Foo, "b", &foo.a);
+    _ = another_foo_ptr;
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:8:29: error: field 'b' has index 1 but pointer value is index 0 of struct 'Foo'
diff --git a/test/cases/compile_errors/stage1/obj/fieldParentPtr-field_pointer_is_not_pointer.zig b/test/cases/compile_errors/stage1/obj/fieldParentPtr-field_pointer_is_not_pointer.zig
new file mode 100644
index 0000000000000000000000000000000000000000..71360e56810662e40958a553e4f180c82248db8c
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/fieldParentPtr-field_pointer_is_not_pointer.zig
@@ -0,0 +1,12 @@
+const Foo = extern struct {
+    a: i32,
+};
+export fn foo(a: i32) *Foo {
+    return @fieldParentPtr(Foo, "a", a);
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:5:38: error: expected pointer, found 'i32'
diff --git a/test/cases/compile_errors/stage1/obj/fieldParentPtr-non_struct.zig b/test/cases/compile_errors/stage1/obj/fieldParentPtr-non_struct.zig
new file mode 100644
index 0000000000000000000000000000000000000000..16b9a9b3328caaae919dc651d4c01f88b7d578a2
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/fieldParentPtr-non_struct.zig
@@ -0,0 +1,10 @@
+const Foo = i32;
+export fn foo(a: *i32) *Foo {
+    return @fieldParentPtr(Foo, "a", a);
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:3:28: error: expected struct type, found 'i32'
diff --git a/test/cases/compile_errors/stage1/obj/field_access_of_opaque_type.zig b/test/cases/compile_errors/stage1/obj/field_access_of_opaque_type.zig
new file mode 100644
index 0000000000000000000000000000000000000000..963c89dafe79b6ac6b7c0d63c11f30dd458725a2
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/field_access_of_opaque_type.zig
@@ -0,0 +1,16 @@
+const MyType = opaque {};
+
+export fn entry() bool {
+    var x: i32 = 1;
+    return bar(@ptrCast(*MyType, &x));
+}
+
+fn bar(x: *MyType) bool {
+    return x.blah;
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:9:13: error: no member named 'blah' in opaque type 'MyType'
diff --git a/test/cases/compile_errors/stage1/obj/field_access_of_slices.zig b/test/cases/compile_errors/stage1/obj/field_access_of_slices.zig
new file mode 100644
index 0000000000000000000000000000000000000000..45ca7113674e923e0c53ea970f518ac96e8cd8ba
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/field_access_of_slices.zig
@@ -0,0 +1,11 @@
+export fn entry() void {
+    var slice: []i32 = undefined;
+    const info = @TypeOf(slice).unknown;
+    _ = info;
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:3:32: error: type 'type' does not support field access
diff --git a/test/cases/compile_errors/stage1/obj/field_access_of_unknown_length_pointer.zig b/test/cases/compile_errors/stage1/obj/field_access_of_unknown_length_pointer.zig
new file mode 100644
index 0000000000000000000000000000000000000000..f9a37cabccbe99a588faf9f1e1237eb46322dcd8
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/field_access_of_unknown_length_pointer.zig
@@ -0,0 +1,13 @@
+const Foo = extern struct {
+    a: i32,
+};
+
+export fn entry(foo: [*]Foo) void {
+    foo.a += 1;
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:6:8: error: type '[*]Foo' does not support field access
diff --git a/test/cases/compile_errors/stage1/obj/field_type_supplied_in_an_enum.zig b/test/cases/compile_errors/stage1/obj/field_type_supplied_in_an_enum.zig
new file mode 100644
index 0000000000000000000000000000000000000000..d6ba214c0ccb145003d52e6ee9d4d63ffa2cece6
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/field_type_supplied_in_an_enum.zig
@@ -0,0 +1,12 @@
+const Letter = enum {
+    A: void,
+    B,
+    C,
+};
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:2:8: error: enum fields do not have types
+// tmp.zig:1:16: note: consider 'union(enum)' here to make it a tagged union
diff --git a/test/cases/compile_errors/stage1/obj/floatToInt_comptime_safety.zig b/test/cases/compile_errors/stage1/obj/floatToInt_comptime_safety.zig
new file mode 100644
index 0000000000000000000000000000000000000000..1e5fa746a14b4fff82df228d6d28ad5a5ff19169
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/floatToInt_comptime_safety.zig
@@ -0,0 +1,17 @@
+comptime {
+    _ = @floatToInt(i8, @as(f32, -129.1));
+}
+comptime {
+    _ = @floatToInt(u8, @as(f32, -1.1));
+}
+comptime {
+    _ = @floatToInt(u8, @as(f32, 256.1));
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:2:9: error: integer value '-129' cannot be stored in type 'i8'
+// tmp.zig:5:9: error: integer value '-1' cannot be stored in type 'u8'
+// tmp.zig:8:9: error: integer value '256' cannot be stored in type 'u8'
diff --git a/test/cases/compile_errors/stage1/obj/float_literal_too_large_error.zig b/test/cases/compile_errors/stage1/obj/float_literal_too_large_error.zig
new file mode 100644
index 0000000000000000000000000000000000000000..c3865c31108cadfed1a77490a6a23ea861e6ee79
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/float_literal_too_large_error.zig
@@ -0,0 +1,10 @@
+comptime {
+    const a = 0x1.0p18495;
+    _ = a;
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:2:15: error: float literal out of range of any type
diff --git a/test/cases/compile_errors/stage1/obj/float_literal_too_small_error_denormal.zig b/test/cases/compile_errors/stage1/obj/float_literal_too_small_error_denormal.zig
new file mode 100644
index 0000000000000000000000000000000000000000..0b0bfee1de541f72fbbe2f9913449ca9dde3bb8b
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/float_literal_too_small_error_denormal.zig
@@ -0,0 +1,10 @@
+comptime {
+    const a = 0x1.0p-19000;
+    _ = a;
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:2:15: error: float literal out of range of any type
diff --git a/test/cases/compile_errors/stage1/obj/for_loop_body_expression_ignored.zig b/test/cases/compile_errors/stage1/obj/for_loop_body_expression_ignored.zig
new file mode 100644
index 0000000000000000000000000000000000000000..6281d4b276f702179d5a44cf6d67302ecc0aec78
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/for_loop_body_expression_ignored.zig
@@ -0,0 +1,18 @@
+fn returns() usize {
+    return 2;
+}
+export fn f1() void {
+    for ("hello") |_| returns();
+}
+export fn f2() void {
+    var x: anyerror!i32 = error.Bad;
+    for ("hello") |_| returns() else unreachable;
+    _ = x;
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:5:30: error: expression value is ignored
+// tmp.zig:9:30: error: expression value is ignored
diff --git a/test/cases/compile_errors/stage1/obj/frame_called_outside_of_function_definition.zig b/test/cases/compile_errors/stage1/obj/frame_called_outside_of_function_definition.zig
new file mode 100644
index 0000000000000000000000000000000000000000..d14099815287f35321510c87104e0a5831a970a6
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/frame_called_outside_of_function_definition.zig
@@ -0,0 +1,11 @@
+var handle_undef: anyframe = undefined;
+var handle_dummy: anyframe = @frame();
+export fn entry() bool {
+    return handle_undef == handle_dummy;
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:2:30: error: @frame() called outside of function definition
diff --git a/test/cases/compile_errors/stage1/obj/frame_causes_function_to_be_async.zig b/test/cases/compile_errors/stage1/obj/frame_causes_function_to_be_async.zig
new file mode 100644
index 0000000000000000000000000000000000000000..f8493b08b2c9e3374ee9c5c8297601c397964dea
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/frame_causes_function_to_be_async.zig
@@ -0,0 +1,13 @@
+export fn entry() void {
+    func();
+}
+fn func() void {
+    _ = @frame();
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:1:1: error: function with calling convention 'C' cannot be async
+// tmp.zig:5:9: note: @frame() causes function to be async
diff --git a/test/cases/compile_errors/stage1/obj/function_alignment_non_power_of_2.zig b/test/cases/compile_errors/stage1/obj/function_alignment_non_power_of_2.zig
new file mode 100644
index 0000000000000000000000000000000000000000..617939a120fc6275ce1b9a486f75ab4e90541a76
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/function_alignment_non_power_of_2.zig
@@ -0,0 +1,8 @@
+extern fn foo() align(3) void;
+export fn entry() void { return foo(); }
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:1:23: error: alignment value 3 is not a power of 2
diff --git a/test/cases/compile_errors/stage1/obj/function_call_assigned_to_incorrect_type.zig b/test/cases/compile_errors/stage1/obj/function_call_assigned_to_incorrect_type.zig
new file mode 100644
index 0000000000000000000000000000000000000000..51bc82ffb867bb9f670aa99021c02767f6d1b159
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/function_call_assigned_to_incorrect_type.zig
@@ -0,0 +1,13 @@
+export fn entry() void {
+    var arr: [4]f32 = undefined;
+    arr = concat();
+}
+fn concat() [16]f32 {
+    return [1]f32{0}**16;
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:3:17: error: expected type '[4]f32', found '[16]f32'
diff --git a/test/cases/compile_errors/stage1/obj/function_parameter_is_opaque.zig b/test/cases/compile_errors/stage1/obj/function_parameter_is_opaque.zig
new file mode 100644
index 0000000000000000000000000000000000000000..5b52370d868e8e6e28fd7a40d070c8d3bce995da
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/function_parameter_is_opaque.zig
@@ -0,0 +1,29 @@
+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 {_ = p;}
+export fn entry3() void {
+    _ = foo;
+}
+
+fn bar(p: @TypeOf(null)) void {_ = p;}
+export fn entry4() void {
+    _ = bar;
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:3:28: error: parameter of opaque type 'FooType' not allowed
+// tmp.zig:8:28: error: parameter of type '@Type(.Null)' not allowed
+// tmp.zig:12:11: error: parameter of opaque type 'FooType' not allowed
+// tmp.zig:17:11: error: parameter of type '@Type(.Null)' not allowed
diff --git a/test/cases/compile_errors/stage1/obj/function_prototype_with_no_body.zig b/test/cases/compile_errors/stage1/obj/function_prototype_with_no_body.zig
new file mode 100644
index 0000000000000000000000000000000000000000..7926faaa4435863b2c5ad4d477e7fd6f1a697ce8
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/function_prototype_with_no_body.zig
@@ -0,0 +1,10 @@
+fn foo() void;
+export fn entry() void {
+    foo();
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:1:1: error: non-extern function has no body
diff --git a/test/cases/compile_errors/stage1/obj/function_returning_opaque_type.zig b/test/cases/compile_errors/stage1/obj/function_returning_opaque_type.zig
new file mode 100644
index 0000000000000000000000000000000000000000..e2c084b517f9437deca2b81981d57d004fe1c6ca
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/function_returning_opaque_type.zig
@@ -0,0 +1,19 @@
+const FooType = opaque {};
+export fn bar() !FooType {
+    return error.InvalidValue;
+}
+export fn bav() !@TypeOf(null) {
+    return error.InvalidValue;
+}
+export fn baz() !@TypeOf(undefined) {
+    return error.InvalidValue;
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:2:18: error: Opaque return type 'FooType' not allowed
+// tmp.zig:1:1: note: type declared here
+// tmp.zig:5:18: error: Null return type '@Type(.Null)' not allowed
+// tmp.zig:8:18: error: Undefined return type '@Type(.Undefined)' not allowed
diff --git a/test/cases/compile_errors/stage1/obj/function_with_ccc_indirectly_calling_async_function.zig b/test/cases/compile_errors/stage1/obj/function_with_ccc_indirectly_calling_async_function.zig
new file mode 100644
index 0000000000000000000000000000000000000000..9fadb992b4c68407ab3c65c208d968b29123bf7a
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/function_with_ccc_indirectly_calling_async_function.zig
@@ -0,0 +1,18 @@
+export fn entry() void {
+    foo();
+}
+fn foo() void {
+    bar();
+}
+fn bar() void {
+    suspend {}
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:1:1: error: function with calling convention 'C' cannot be async
+// tmp.zig:2:8: note: async function call here
+// tmp.zig:5:8: note: async function call here
+// tmp.zig:8:5: note: suspends here
diff --git a/test/cases/compile_errors/stage1/obj/function_with_invalid_return_type.zig b/test/cases/compile_errors/stage1/obj/function_with_invalid_return_type.zig
new file mode 100644
index 0000000000000000000000000000000000000000..897b298a3d346c38f6b509530ec0c264bbfe4e6f
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/function_with_invalid_return_type.zig
@@ -0,0 +1,7 @@
+export fn foo() boid {}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:1:17: error: use of undeclared identifier 'boid'
diff --git a/test/cases/compile_errors/stage1/obj/function_with_non-extern_non-packed_enum_parameter.zig b/test/cases/compile_errors/stage1/obj/function_with_non-extern_non-packed_enum_parameter.zig
new file mode 100644
index 0000000000000000000000000000000000000000..8de26c08b84a4fcef12222ee24e0adbf5a573118
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/function_with_non-extern_non-packed_enum_parameter.zig
@@ -0,0 +1,8 @@
+const Foo = enum { A, B, C };
+export fn entry(foo: Foo) void { _ = foo; }
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:2:22: error: parameter of type 'Foo' not allowed in function with calling convention 'C'
diff --git a/test/cases/compile_errors/stage1/obj/function_with_non-extern_non-packed_struct_parameter.zig b/test/cases/compile_errors/stage1/obj/function_with_non-extern_non-packed_struct_parameter.zig
new file mode 100644
index 0000000000000000000000000000000000000000..ecb4a3626723eb8d281c2c83821d1e09d8384844
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/function_with_non-extern_non-packed_struct_parameter.zig
@@ -0,0 +1,12 @@
+const Foo = struct {
+    A: i32,
+    B: f32,
+    C: bool,
+};
+export fn entry(foo: Foo) void { _ = foo; }
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:6:22: error: parameter of type 'Foo' not allowed in function with calling convention 'C'
diff --git a/test/cases/compile_errors/stage1/obj/function_with_non-extern_non-packed_union_parameter.zig b/test/cases/compile_errors/stage1/obj/function_with_non-extern_non-packed_union_parameter.zig
new file mode 100644
index 0000000000000000000000000000000000000000..bfe2dc6cfa6114959a15aeab842523783bc94d35
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/function_with_non-extern_non-packed_union_parameter.zig
@@ -0,0 +1,12 @@
+const Foo = union {
+    A: i32,
+    B: f32,
+    C: bool,
+};
+export fn entry(foo: Foo) void { _ = foo; }
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:6:22: error: parameter of type 'Foo' not allowed in function with calling convention 'C'
diff --git a/test/cases/compile_errors/stage1/obj/generic_fn_as_parameter_without_comptime_keyword.zig b/test/cases/compile_errors/stage1/obj/generic_fn_as_parameter_without_comptime_keyword.zig
new file mode 100644
index 0000000000000000000000000000000000000000..72e27e3a0d57babdf71017a0ff6c9767ed598ae2
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/generic_fn_as_parameter_without_comptime_keyword.zig
@@ -0,0 +1,11 @@
+fn f(_: fn (anytype) void) void {}
+fn g(_: anytype) void {}
+export fn entry() void {
+    f(g);
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:1:9: error: parameter of type 'fn(anytype) anytype' must be declared comptime
diff --git a/test/cases/compile_errors/stage1/obj/generic_function_call_assigned_to_incorrect_type.zig b/test/cases/compile_errors/stage1/obj/generic_function_call_assigned_to_incorrect_type.zig
new file mode 100644
index 0000000000000000000000000000000000000000..72ed66b20aba928f16594e677958dece3d809d2c
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/generic_function_call_assigned_to_incorrect_type.zig
@@ -0,0 +1,13 @@
+pub export fn entry() void {
+    var res: []i32 = undefined;
+    res = myAlloc(i32);
+}
+fn myAlloc(comptime arg: type) anyerror!arg{
+    unreachable;
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:3:18: error: expected type '[]i32', found 'anyerror!i32
diff --git a/test/cases/compile_errors/stage1/obj/generic_function_instance_with_non-constant_expression.zig b/test/cases/compile_errors/stage1/obj/generic_function_instance_with_non-constant_expression.zig
new file mode 100644
index 0000000000000000000000000000000000000000..9cdd653766149fe4321fa470bc23a3f2af4f4106
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/generic_function_instance_with_non-constant_expression.zig
@@ -0,0 +1,12 @@
+fn foo(comptime x: i32, y: i32) i32 { return x + y; }
+fn test1(a: i32, b: i32) i32 {
+    return foo(a, b);
+}
+
+export fn entry() usize { return @sizeOf(@TypeOf(test1)); }
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:3:16: error: runtime value cannot be passed to comptime arg
diff --git a/test/cases/compile_errors/stage1/obj/generic_function_returning_opaque_type.zig b/test/cases/compile_errors/stage1/obj/generic_function_returning_opaque_type.zig
new file mode 100644
index 0000000000000000000000000000000000000000..247c1a49bf8a06a7fae2278195e58573a03349b9
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/generic_function_returning_opaque_type.zig
@@ -0,0 +1,25 @@
+const FooType = opaque {};
+fn generic(comptime T: type) !T {
+    return undefined;
+}
+export fn bar() void {
+    _ = generic(FooType);
+}
+export fn bav() void {
+    _ = generic(@TypeOf(null));
+}
+export fn baz() void {
+    _ = generic(@TypeOf(undefined));
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:6:16: error: call to generic function with Opaque return type 'FooType' not allowed
+// tmp.zig:2:1: note: function declared here
+// tmp.zig:1:1: note: type declared here
+// tmp.zig:9:16: error: call to generic function with Null return type '@Type(.Null)' not allowed
+// tmp.zig:2:1: note: function declared here
+// tmp.zig:12:16: error: call to generic function with Undefined return type '@Type(.Undefined)' not allowed
+// tmp.zig:2:1: note: function declared here
diff --git a/test/cases/compile_errors/stage1/obj/generic_function_where_return_type_is_self-referenced.zig b/test/cases/compile_errors/stage1/obj/generic_function_where_return_type_is_self-referenced.zig
new file mode 100644
index 0000000000000000000000000000000000000000..c8d31ec8dfac0e0e5880d56738d235ecb3eb7533
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/generic_function_where_return_type_is_self-referenced.zig
@@ -0,0 +1,15 @@
+fn Foo(comptime T: type) Foo(T) {
+    return struct{ x: T };
+}
+export fn entry() void {
+    const t = Foo(u32) {
+      .x = 1
+    };
+    _ = t;
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:1:29: error: evaluation exceeded 1000 backwards branches
diff --git a/test/cases/compile_errors/stage1/obj/global_variable_alignment_non_power_of_2.zig b/test/cases/compile_errors/stage1/obj/global_variable_alignment_non_power_of_2.zig
new file mode 100644
index 0000000000000000000000000000000000000000..f23f340b1600632d508c78afa7e3553416db0b14
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/global_variable_alignment_non_power_of_2.zig
@@ -0,0 +1,8 @@
+const some_data: [100]u8 align(3) = undefined;
+export fn entry() usize { return @sizeOf(@TypeOf(some_data)); }
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:1:32: error: alignment value 3 is not a power of 2
diff --git a/test/cases/compile_errors/stage1/obj/global_variable_initializer_must_be_constant_expression.zig b/test/cases/compile_errors/stage1/obj/global_variable_initializer_must_be_constant_expression.zig
new file mode 100644
index 0000000000000000000000000000000000000000..d01e828da66600207d8932b4996c898bc5b8d69f
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/global_variable_initializer_must_be_constant_expression.zig
@@ -0,0 +1,9 @@
+extern fn foo() i32;
+const x = foo();
+export fn entry() i32 { return x; }
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:2:11: error: unable to evaluate constant expression
diff --git a/test/cases/compile_errors/stage1/obj/hasDecl_with_non-container.zig b/test/cases/compile_errors/stage1/obj/hasDecl_with_non-container.zig
new file mode 100644
index 0000000000000000000000000000000000000000..e9aeacdd4e9d054a694d86b86707112f094769dd
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/hasDecl_with_non-container.zig
@@ -0,0 +1,9 @@
+export fn entry() void {
+    _ = @hasDecl(i32, "hi");
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:2:18: error: expected struct, enum, or union; found 'i32'
diff --git a/test/cases/compile_errors/stage1/obj/if_condition_is_bool_not_int.zig b/test/cases/compile_errors/stage1/obj/if_condition_is_bool_not_int.zig
new file mode 100644
index 0000000000000000000000000000000000000000..53afb2792a004d85f0bb8697364ae677812b304f
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/if_condition_is_bool_not_int.zig
@@ -0,0 +1,9 @@
+export fn f() void {
+    if (0) {}
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:2:9: error: expected type 'bool', found 'comptime_int'
diff --git a/test/cases/compile_errors/stage1/obj/ignored_assert-err-ok_return_value.zig b/test/cases/compile_errors/stage1/obj/ignored_assert-err-ok_return_value.zig
new file mode 100644
index 0000000000000000000000000000000000000000..4d45ae13043e5589212b4b617bd9685bcaee3196
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/ignored_assert-err-ok_return_value.zig
@@ -0,0 +1,10 @@
+export fn foo() void {
+    bar() catch unreachable;
+}
+fn bar() anyerror!i32 { return 0; }
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:2:11: error: expression value is ignored
diff --git a/test/cases/compile_errors/stage1/obj/ignored_comptime_statement_value.zig b/test/cases/compile_errors/stage1/obj/ignored_comptime_statement_value.zig
new file mode 100644
index 0000000000000000000000000000000000000000..0e82c9ae3ea439da7bd0b886412e8b1654600d43
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/ignored_comptime_statement_value.zig
@@ -0,0 +1,9 @@
+export fn foo() void {
+    comptime {1;}
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:2:15: error: expression value is ignored
diff --git a/test/cases/compile_errors/stage1/obj/ignored_comptime_value.zig b/test/cases/compile_errors/stage1/obj/ignored_comptime_value.zig
new file mode 100644
index 0000000000000000000000000000000000000000..0306ea72ff14e0a826f6093af8cf9021aab7cd6d
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/ignored_comptime_value.zig
@@ -0,0 +1,9 @@
+export fn foo() void {
+    comptime 1;
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:2:5: error: expression value is ignored
diff --git a/test/cases/compile_errors/stage1/obj/ignored_deferred_function_call.zig b/test/cases/compile_errors/stage1/obj/ignored_deferred_function_call.zig
new file mode 100644
index 0000000000000000000000000000000000000000..41812bfda93ba61d3fbfb34415b96463ceba6d59
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/ignored_deferred_function_call.zig
@@ -0,0 +1,10 @@
+export fn foo() void {
+    defer bar();
+}
+fn bar() anyerror!i32 { return 0; }
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:2:14: error: error is ignored. consider using `try`, `catch`, or `if`
diff --git a/test/cases/compile_errors/stage1/obj/ignored_deferred_statement_value.zig b/test/cases/compile_errors/stage1/obj/ignored_deferred_statement_value.zig
new file mode 100644
index 0000000000000000000000000000000000000000..1042c4f40a20ebcc6d49abb1631b8b25ca482724
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/ignored_deferred_statement_value.zig
@@ -0,0 +1,9 @@
+export fn foo() void {
+    defer {1;}
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:2:12: error: expression value is ignored
diff --git a/test/cases/compile_errors/stage1/obj/ignored_expression_in_while_continuation.zig b/test/cases/compile_errors/stage1/obj/ignored_expression_in_while_continuation.zig
new file mode 100644
index 0000000000000000000000000000000000000000..43f3713fc670e731c73a6a7b89e923c59e757038
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/ignored_expression_in_while_continuation.zig
@@ -0,0 +1,22 @@
+export fn a() void {
+    while (true) : (bad()) {}
+}
+export fn b() void {
+    var x: anyerror!i32 = 1234;
+    while (x) |_| : (bad()) {} else |_| {}
+}
+export fn c() void {
+    var x: ?i32 = 1234;
+    while (x) |_| : (bad()) {}
+}
+fn bad() anyerror!void {
+    return error.Bad;
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:2:24: error: error is ignored. consider using `try`, `catch`, or `if`
+// tmp.zig:6:25: error: error is ignored. consider using `try`, `catch`, or `if`
+// tmp.zig:10:25: error: error is ignored. consider using `try`, `catch`, or `if`
diff --git a/test/cases/compile_errors/stage1/obj/ignored_return_value.zig b/test/cases/compile_errors/stage1/obj/ignored_return_value.zig
new file mode 100644
index 0000000000000000000000000000000000000000..b918523b372f9967965a7f41aa7611569063eb67
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/ignored_return_value.zig
@@ -0,0 +1,10 @@
+export fn foo() void {
+    bar();
+}
+fn bar() i32 { return 0; }
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:2:8: error: expression value is ignored
diff --git a/test/cases/compile_errors/stage1/obj/ignored_statement_value.zig b/test/cases/compile_errors/stage1/obj/ignored_statement_value.zig
new file mode 100644
index 0000000000000000000000000000000000000000..a0e540a92b08239192950a1ba2a1abeda95ae37e
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/ignored_statement_value.zig
@@ -0,0 +1,9 @@
+export fn foo() void {
+    1;
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:2:5: error: expression value is ignored
diff --git a/test/cases/compile_errors/stage1/obj/illegal_comparison_of_types.zig b/test/cases/compile_errors/stage1/obj/illegal_comparison_of_types.zig
new file mode 100644
index 0000000000000000000000000000000000000000..d04eaec3b52c0f4c53864a3c80e63edc5c440579
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/illegal_comparison_of_types.zig
@@ -0,0 +1,20 @@
+fn bad_eql_1(a: []u8, b: []u8) bool {
+    return a == b;
+}
+const EnumWithData = union(enum) {
+    One: void,
+    Two: i32,
+};
+fn bad_eql_2(a: *const EnumWithData, b: *const EnumWithData) bool {
+    return a.* == b.*;
+}
+
+export fn entry1() usize { return @sizeOf(@TypeOf(bad_eql_1)); }
+export fn entry2() usize { return @sizeOf(@TypeOf(bad_eql_2)); }
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:2:14: error: operator not allowed for type '[]u8'
+// tmp.zig:9:16: error: operator not allowed for type 'EnumWithData'
diff --git a/test/cases/compile_errors/stage1/obj/implicit_cast_between_C_pointer_and_Zig_pointer-bad_const-align-child.zig b/test/cases/compile_errors/stage1/obj/implicit_cast_between_C_pointer_and_Zig_pointer-bad_const-align-child.zig
new file mode 100644
index 0000000000000000000000000000000000000000..6ff155b591ba476f582fff263cedb3b89e010f52
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/implicit_cast_between_C_pointer_and_Zig_pointer-bad_const-align-child.zig
@@ -0,0 +1,42 @@
+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;
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:3:27: error: cast increases pointer alignment
+// tmp.zig:8:18: error: cast discards const qualifier
+// tmp.zig:13:19: error: expected type '*u32', found '[*c]u8'
+// tmp.zig:13:19: note: pointer type child 'u8' cannot cast into pointer type child 'u32'
+// tmp.zig:18:22: error: cast increases pointer alignment
+// tmp.zig:23:21: error: cast discards const qualifier
+// tmp.zig:28:22: error: expected type '[*c]u32', found '*u8'
diff --git a/test/cases/compile_errors/stage1/obj/implicit_cast_const_array_to_mutable_slice.zig b/test/cases/compile_errors/stage1/obj/implicit_cast_const_array_to_mutable_slice.zig
new file mode 100644
index 0000000000000000000000000000000000000000..3f22cbed6b471071702ba6cc43b25bd03a591893
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/implicit_cast_const_array_to_mutable_slice.zig
@@ -0,0 +1,12 @@
+export fn entry() void {
+    const buffer: [1]u8 = [_]u8{8};
+    const sliceA: []u8 = &buffer;
+    _ = sliceA;
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:3:27: error: cannot cast pointer to array literal to slice type '[]u8'
+// tmp.zig:3:27: note: cast discards const qualifier
diff --git a/test/cases/compile_errors/stage1/obj/implicit_cast_from_array_to_mutable_slice.zig b/test/cases/compile_errors/stage1/obj/implicit_cast_from_array_to_mutable_slice.zig
new file mode 100644
index 0000000000000000000000000000000000000000..012555928c1dd29cdc42a963052c675c15092854
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/implicit_cast_from_array_to_mutable_slice.zig
@@ -0,0 +1,11 @@
+var global_array: [10]i32 = undefined;
+fn foo(param: []i32) void {_ = param;}
+export fn entry() void {
+    foo(global_array);
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:4:9: error: expected type '[]i32', found '[10]i32'
diff --git a/test/cases/compile_errors/stage1/obj/implicit_cast_from_f64_to_f32.zig b/test/cases/compile_errors/stage1/obj/implicit_cast_from_f64_to_f32.zig
new file mode 100644
index 0000000000000000000000000000000000000000..f18a46b7f51c2be13c0792ee3ff5dda84700da0f
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/implicit_cast_from_f64_to_f32.zig
@@ -0,0 +1,10 @@
+var x: f64 = 1.0;
+var y: f32 = x;
+
+export fn entry() usize { return @sizeOf(@TypeOf(y)); }
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:2:14: error: expected type 'f32', found 'f64'
diff --git a/test/cases/compile_errors/stage1/obj/implicit_cast_of_error_set_not_a_subset.zig b/test/cases/compile_errors/stage1/obj/implicit_cast_of_error_set_not_a_subset.zig
new file mode 100644
index 0000000000000000000000000000000000000000..5958a4163930319e654571e75eab2d4d84d0afeb
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/implicit_cast_of_error_set_not_a_subset.zig
@@ -0,0 +1,16 @@
+const Set1 = error{A, B};
+const Set2 = error{A, C};
+export fn entry() void {
+    foo(Set1.B);
+}
+fn foo(set1: Set1) void {
+    var x: Set2 = set1;
+    _ = x;
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:7:19: error: expected type 'Set2', found 'Set1'
+// tmp.zig:1:23: note: 'error.B' not a member of destination error set
diff --git a/test/cases/compile_errors/stage1/obj/implicit_casting_C_pointers_which_would_mess_up_null_semantics.zig b/test/cases/compile_errors/stage1/obj/implicit_casting_C_pointers_which_would_mess_up_null_semantics.zig
new file mode 100644
index 0000000000000000000000000000000000000000..760bab41da07b3bbb9a510692ab35141d798a38f
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/implicit_casting_C_pointers_which_would_mess_up_null_semantics.zig
@@ -0,0 +1,26 @@
+export fn entry() void {
+    var slice: []const u8 = "aoeu";
+    const opt_many_ptr: [*]const u8 = slice.ptr;
+    var ptr_opt_many_ptr = &opt_many_ptr;
+    var c_ptr: [*c]const [*c]const u8 = ptr_opt_many_ptr;
+    ptr_opt_many_ptr = c_ptr;
+}
+export fn entry2() void {
+    var buf: [4]u8 = "aoeu".*;
+    var slice: []u8 = &buf;
+    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;
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:6:24: error: expected type '*const [*]const u8', found '[*c]const [*c]const u8'
+// tmp.zig:6:24: note: pointer type child '[*c]const u8' cannot cast into pointer type child '[*]const u8'
+// tmp.zig:6:24: note: '[*c]const u8' could have null values which are illegal in type '[*]const u8'
+// tmp.zig:13:35: error: expected type '[*c][*c]const u8', found '*[*]u8'
+// tmp.zig:13:35: note: pointer type child '[*]u8' cannot cast into pointer type child '[*c]const u8'
+// tmp.zig:13:35: note: mutable '[*c]const u8' allows illegal null values stored to type '[*]u8'
diff --git a/test/cases/compile_errors/stage1/obj/implicit_casting_null_c_pointer_to_zig_pointer.zig b/test/cases/compile_errors/stage1/obj/implicit_casting_null_c_pointer_to_zig_pointer.zig
new file mode 100644
index 0000000000000000000000000000000000000000..0bd38d868b9bdf2c4f86bff0dec84d06b32b6ee3
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/implicit_casting_null_c_pointer_to_zig_pointer.zig
@@ -0,0 +1,11 @@
+comptime {
+    var c_ptr: [*c]u8 = 0;
+    var zig_ptr: *u8 = c_ptr;
+    _ = zig_ptr;
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:3:24: error: null pointer casted to type '*u8'
diff --git a/test/cases/compile_errors/stage1/obj/implicit_casting_too_big_integers_to_C_pointers.zig b/test/cases/compile_errors/stage1/obj/implicit_casting_too_big_integers_to_C_pointers.zig
new file mode 100644
index 0000000000000000000000000000000000000000..f142540ff6a13d2143962f9c8fa91249d3b17139
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/implicit_casting_too_big_integers_to_C_pointers.zig
@@ -0,0 +1,16 @@
+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;
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:2:33: error: integer value 18446744073709551617 cannot be coerced to type 'usize'
+// tmp.zig:7:23: error: integer type 'u65' too big for implicit @intToPtr to type '[*c]u8'
diff --git a/test/cases/compile_errors/stage1/obj/implicit_casting_undefined_c_pointer_to_zig_pointer.zig b/test/cases/compile_errors/stage1/obj/implicit_casting_undefined_c_pointer_to_zig_pointer.zig
new file mode 100644
index 0000000000000000000000000000000000000000..5554146fa57dd3278dcb1ed933220dd098bf9943
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/implicit_casting_undefined_c_pointer_to_zig_pointer.zig
@@ -0,0 +1,11 @@
+comptime {
+    var c_ptr: [*c]u8 = undefined;
+    var zig_ptr: *u8 = c_ptr;
+    _ = zig_ptr;
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:3:24: error: use of undefined value here causes undefined behavior
diff --git a/test/cases/compile_errors/stage1/obj/implicit_dependency_on_libc.zig b/test/cases/compile_errors/stage1/obj/implicit_dependency_on_libc.zig
new file mode 100644
index 0000000000000000000000000000000000000000..f069f785517177e26570acbf6665a8d46add25e5
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/implicit_dependency_on_libc.zig
@@ -0,0 +1,11 @@
+extern "c" fn exit(u8) void;
+export fn entry() void {
+    exit(0);
+}
+
+// error
+// backend=stage1
+// target=native-linux
+// is_test=1
+//
+// tmp.zig:3:5: error: dependency on libc must be explicitly specified in the build command
diff --git a/test/cases/compile_errors/stage1/obj/implicit_semicolon-block_expr.zig b/test/cases/compile_errors/stage1/obj/implicit_semicolon-block_expr.zig
new file mode 100644
index 0000000000000000000000000000000000000000..a57da8ac0bcd7f39226eda704706f9def164a95f
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/implicit_semicolon-block_expr.zig
@@ -0,0 +1,12 @@
+export fn entry() void {
+    _ = {};
+    var good = {};
+    _ = {}
+    var bad = {};
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:4:11: error: expected ';' after statement
diff --git a/test/cases/compile_errors/stage1/obj/implicit_semicolon-block_statement.zig b/test/cases/compile_errors/stage1/obj/implicit_semicolon-block_statement.zig
new file mode 100644
index 0000000000000000000000000000000000000000..2d9d850e75d68c19d3b2b949d0440323241e54e6
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/implicit_semicolon-block_statement.zig
@@ -0,0 +1,12 @@
+export fn entry() void {
+    {}
+    var good = {};
+    ({})
+    var bad = {};
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:4:9: error: expected ';' after statement
diff --git a/test/cases/compile_errors/stage1/obj/implicit_semicolon-comptime_expression.zig b/test/cases/compile_errors/stage1/obj/implicit_semicolon-comptime_expression.zig
new file mode 100644
index 0000000000000000000000000000000000000000..b4cd4de849d90921b1484950ffc05a1715c876bb
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/implicit_semicolon-comptime_expression.zig
@@ -0,0 +1,12 @@
+export fn entry() void {
+    _ = comptime {};
+    var good = {};
+    _ = comptime {}
+    var bad = {};
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:4:20: error: expected ';' after statement
diff --git a/test/cases/compile_errors/stage1/obj/implicit_semicolon-comptime_statement.zig b/test/cases/compile_errors/stage1/obj/implicit_semicolon-comptime_statement.zig
new file mode 100644
index 0000000000000000000000000000000000000000..3b83ef92eba02aca1fed39d6f949390bc34756cd
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/implicit_semicolon-comptime_statement.zig
@@ -0,0 +1,12 @@
+export fn entry() void {
+    comptime {}
+    var good = {};
+    comptime ({})
+    var bad = {};
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:4:18: error: expected ';' after statement
diff --git a/test/cases/compile_errors/stage1/obj/implicit_semicolon-defer.zig b/test/cases/compile_errors/stage1/obj/implicit_semicolon-defer.zig
new file mode 100644
index 0000000000000000000000000000000000000000..0ded4fcf262b0ae5651cdb52b799dd45f16b4cb8
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/implicit_semicolon-defer.zig
@@ -0,0 +1,12 @@
+export fn entry() void {
+    defer {}
+    var good = {};
+    defer ({})
+    var bad = {};
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:4:15: error: expected ';' after statement
diff --git a/test/cases/compile_errors/stage1/obj/implicit_semicolon-for_expression.zig b/test/cases/compile_errors/stage1/obj/implicit_semicolon-for_expression.zig
new file mode 100644
index 0000000000000000000000000000000000000000..964a48d30b9d48d9c5ebcfc60db500ad481d7c0a
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/implicit_semicolon-for_expression.zig
@@ -0,0 +1,12 @@
+export fn entry() void {
+    _ = for(foo()) |_| {};
+    var good = {};
+    _ = for(foo()) |_| {}
+    var bad = {};
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:4:26: error: expected ';' after statement
diff --git a/test/cases/compile_errors/stage1/obj/implicit_semicolon-for_statement.zig b/test/cases/compile_errors/stage1/obj/implicit_semicolon-for_statement.zig
new file mode 100644
index 0000000000000000000000000000000000000000..1320e4cc465d2a4926073206c206cb704f114086
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/implicit_semicolon-for_statement.zig
@@ -0,0 +1,12 @@
+export fn entry() void {
+    for(foo()) |_| {}
+    var good = {};
+    for(foo()) |_| ({})
+    var bad = {};
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:4:24: error: expected ';' or 'else' after statement
diff --git a/test/cases/compile_errors/stage1/obj/implicit_semicolon-if-else-if-else_expression.zig b/test/cases/compile_errors/stage1/obj/implicit_semicolon-if-else-if-else_expression.zig
new file mode 100644
index 0000000000000000000000000000000000000000..40b1a33d7842ec87537984df767d7dbd299c4fb2
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/implicit_semicolon-if-else-if-else_expression.zig
@@ -0,0 +1,12 @@
+export fn entry() void {
+    _ = if(true) {} else if(true) {} else {};
+    var good = {};
+    _ = if(true) {} else if(true) {} else {}
+    var bad = {};
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:4:45: error: expected ';' after statement
diff --git a/test/cases/compile_errors/stage1/obj/implicit_semicolon-if-else-if-else_statement.zig b/test/cases/compile_errors/stage1/obj/implicit_semicolon-if-else-if-else_statement.zig
new file mode 100644
index 0000000000000000000000000000000000000000..8444fe654d528f156f3ef6218c4d6df6ee8440cd
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/implicit_semicolon-if-else-if-else_statement.zig
@@ -0,0 +1,12 @@
+export fn entry() void {
+    if(true) {} else if(true) {} else {}
+    var good = {};
+    if(true) ({}) else if(true) ({}) else ({})
+    var bad = {};
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:4:47: error: expected ';' after statement
diff --git a/test/cases/compile_errors/stage1/obj/implicit_semicolon-if-else-if_expression.zig b/test/cases/compile_errors/stage1/obj/implicit_semicolon-if-else-if_expression.zig
new file mode 100644
index 0000000000000000000000000000000000000000..7466d646915b29987f3c79d9e1c7e6b1c3e252dc
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/implicit_semicolon-if-else-if_expression.zig
@@ -0,0 +1,12 @@
+export fn entry() void {
+    _ = if(true) {} else if(true) {};
+    var good = {};
+    _ = if(true) {} else if(true) {}
+    var bad = {};
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:4:37: error: expected ';' after statement
diff --git a/test/cases/compile_errors/stage1/obj/implicit_semicolon-if-else-if_statement.zig b/test/cases/compile_errors/stage1/obj/implicit_semicolon-if-else-if_statement.zig
new file mode 100644
index 0000000000000000000000000000000000000000..34e116b3f7840cf552e37ae0e064ef7527e2b51d
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/implicit_semicolon-if-else-if_statement.zig
@@ -0,0 +1,12 @@
+export fn entry() void {
+    if(true) {} else if(true) {}
+    var good = {};
+    if(true) ({}) else if(true) ({})
+    var bad = {};
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:4:37: error: expected ';' or 'else' after statement
diff --git a/test/cases/compile_errors/stage1/obj/implicit_semicolon-if-else_expression.zig b/test/cases/compile_errors/stage1/obj/implicit_semicolon-if-else_expression.zig
new file mode 100644
index 0000000000000000000000000000000000000000..3c1e0add62bc1519a6ed4e83ea7f96c7896dcf58
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/implicit_semicolon-if-else_expression.zig
@@ -0,0 +1,12 @@
+export fn entry() void {
+    _ = if(true) {} else {};
+    var good = {};
+    _ = if(true) {} else {}
+    var bad = {};
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:4:28: error: expected ';' after statement
diff --git a/test/cases/compile_errors/stage1/obj/implicit_semicolon-if-else_statement.zig b/test/cases/compile_errors/stage1/obj/implicit_semicolon-if-else_statement.zig
new file mode 100644
index 0000000000000000000000000000000000000000..e9c52fb6bb36f96388e9cd9f14904a6e31b36354
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/implicit_semicolon-if-else_statement.zig
@@ -0,0 +1,12 @@
+export fn entry() void {
+    if(true) {} else {}
+    var good = {};
+    if(true) ({}) else ({})
+    var bad = {};
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:4:28: error: expected ';' after statement
diff --git a/test/cases/compile_errors/stage1/obj/implicit_semicolon-if_expression.zig b/test/cases/compile_errors/stage1/obj/implicit_semicolon-if_expression.zig
new file mode 100644
index 0000000000000000000000000000000000000000..2082588e0e9ab0a99fd4d42a3887f7172eda5bd8
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/implicit_semicolon-if_expression.zig
@@ -0,0 +1,12 @@
+export fn entry() void {
+    _ = if(true) {};
+    var good = {};
+    _ = if(true) {}
+    var bad = {};
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:4:20: error: expected ';' after statement
diff --git a/test/cases/compile_errors/stage1/obj/implicit_semicolon-if_statement.zig b/test/cases/compile_errors/stage1/obj/implicit_semicolon-if_statement.zig
new file mode 100644
index 0000000000000000000000000000000000000000..26cefd0237836ea9434f7e2675a93ab86b02f16c
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/implicit_semicolon-if_statement.zig
@@ -0,0 +1,12 @@
+export fn entry() void {
+    if(true) {}
+    var good = {};
+    if(true) ({})
+    var bad = {};
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:4:18: error: expected ';' or 'else' after statement
diff --git a/test/cases/compile_errors/stage1/obj/implicit_semicolon-test_expression.zig b/test/cases/compile_errors/stage1/obj/implicit_semicolon-test_expression.zig
new file mode 100644
index 0000000000000000000000000000000000000000..c31f3520c1b57738f6e1613f0a05baa65d7dc45f
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/implicit_semicolon-test_expression.zig
@@ -0,0 +1,12 @@
+export fn entry() void {
+    _ = if (foo()) |_| {};
+    var good = {};
+    _ = if (foo()) |_| {}
+    var bad = {};
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:4:26: error: expected ';' after statement
diff --git a/test/cases/compile_errors/stage1/obj/implicit_semicolon-test_statement.zig b/test/cases/compile_errors/stage1/obj/implicit_semicolon-test_statement.zig
new file mode 100644
index 0000000000000000000000000000000000000000..8abb1cbcb1ee34fc719e8b5b02e34c1efbb13b7b
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/implicit_semicolon-test_statement.zig
@@ -0,0 +1,12 @@
+export fn entry() void {
+    if (foo()) |_| {}
+    var good = {};
+    if (foo()) |_| ({})
+    var bad = {};
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:4:24: error: expected ';' or 'else' after statement
diff --git a/test/cases/compile_errors/stage1/obj/implicit_semicolon-while-continue_expression.zig b/test/cases/compile_errors/stage1/obj/implicit_semicolon-while-continue_expression.zig
new file mode 100644
index 0000000000000000000000000000000000000000..4d3219eb66b8f67129d3485ff6f620eadd86af5f
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/implicit_semicolon-while-continue_expression.zig
@@ -0,0 +1,12 @@
+export fn entry() void {
+    _ = while(true):({}) {};
+    var good = {};
+    _ = while(true):({}) {}
+    var bad = {};
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:4:28: error: expected ';' after statement
diff --git a/test/cases/compile_errors/stage1/obj/implicit_semicolon-while-continue_statement.zig b/test/cases/compile_errors/stage1/obj/implicit_semicolon-while-continue_statement.zig
new file mode 100644
index 0000000000000000000000000000000000000000..c0b3370357204bb007ae7d3e15e621be46b00d2a
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/implicit_semicolon-while-continue_statement.zig
@@ -0,0 +1,12 @@
+export fn entry() void {
+    while(true):({}) {}
+    var good = {};
+    while(true):({}) ({})
+    var bad = {};
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:4:26: error: expected ';' or 'else' after statement
diff --git a/test/cases/compile_errors/stage1/obj/implicit_semicolon-while_expression.zig b/test/cases/compile_errors/stage1/obj/implicit_semicolon-while_expression.zig
new file mode 100644
index 0000000000000000000000000000000000000000..39f49319d5044ae5cdb1f90534783ca30c711203
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/implicit_semicolon-while_expression.zig
@@ -0,0 +1,12 @@
+export fn entry() void {
+    _ = while(true) {};
+    var good = {};
+    _ = while(true) {}
+    var bad = {};
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:4:23: error: expected ';' after statement
diff --git a/test/cases/compile_errors/stage1/obj/implicit_semicolon-while_statement.zig b/test/cases/compile_errors/stage1/obj/implicit_semicolon-while_statement.zig
new file mode 100644
index 0000000000000000000000000000000000000000..6c253ecf56374e9fa886a1c87f7f167555d991e0
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/implicit_semicolon-while_statement.zig
@@ -0,0 +1,12 @@
+export fn entry() void {
+    while(true) {}
+    var good = {};
+    while(true) 1
+    var bad = {};
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:4:18: error: expected ';' or 'else' after statement
diff --git a/test/cases/compile_errors/stage1/obj/implicitly_casting_enum_to_tag_type.zig b/test/cases/compile_errors/stage1/obj/implicitly_casting_enum_to_tag_type.zig
new file mode 100644
index 0000000000000000000000000000000000000000..a40615f99b09a5cd0a92372454c33244967c7e29
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/implicitly_casting_enum_to_tag_type.zig
@@ -0,0 +1,17 @@
+const Small = enum(u2) {
+    One,
+    Two,
+    Three,
+    Four,
+};
+
+export fn entry() void {
+    var x: u2 = Small.Two;
+    _ = x;
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:9:22: error: expected type 'u2', found 'Small'
diff --git a/test/cases/compile_errors/stage1/obj/implicitly_increasing_pointer_alignment.zig b/test/cases/compile_errors/stage1/obj/implicitly_increasing_pointer_alignment.zig
new file mode 100644
index 0000000000000000000000000000000000000000..3743eef0b2fceebbf3c4e5149b8a2cd3fc642b5e
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/implicitly_increasing_pointer_alignment.zig
@@ -0,0 +1,19 @@
+const Foo = packed struct {
+    a: u8,
+    b: u32,
+};
+
+export fn entry() void {
+    var foo = Foo { .a = 1, .b = 10 };
+    bar(&foo.b);
+}
+
+fn bar(x: *u32) void {
+    x.* += 1;
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:8:13: error: expected type '*u32', found '*align(1) u32'
diff --git a/test/cases/compile_errors/stage1/obj/implicitly_increasing_slice_alignment.zig b/test/cases/compile_errors/stage1/obj/implicitly_increasing_slice_alignment.zig
new file mode 100644
index 0000000000000000000000000000000000000000..2e5c201b5dac591e401bdd68358a7dceeeeff877
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/implicitly_increasing_slice_alignment.zig
@@ -0,0 +1,22 @@
+const Foo = packed struct {
+    a: u8,
+    b: u32,
+};
+
+export fn entry() void {
+    var foo = Foo { .a = 1, .b = 10 };
+    foo.b += 1;
+    bar(@as(*[1]u32, &foo.b)[0..]);
+}
+
+fn bar(x: []u32) void {
+    x[0] += 1;
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:9:26: error: cast increases pointer alignment
+// tmp.zig:9:26: note: '*align(1) u32' has alignment 1
+// tmp.zig:9:26: note: '*[1]u32' has alignment 4
diff --git a/test/cases/compile_errors/stage1/obj/import_outside_package_path.zig b/test/cases/compile_errors/stage1/obj/import_outside_package_path.zig
new file mode 100644
index 0000000000000000000000000000000000000000..5a712c2e0116dfb3ebce9c1b9db79859941897d2
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/import_outside_package_path.zig
@@ -0,0 +1,9 @@
+comptime{
+    _ = @import("../a.zig");
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:2:9: error: import of file outside package path: '../a.zig'
diff --git a/test/cases/compile_errors/stage1/obj/incompatible_sentinels.zig b/test/cases/compile_errors/stage1/obj/incompatible_sentinels.zig
new file mode 100644
index 0000000000000000000000000000000000000000..a292ae3d7c9700713c4037ef3333560cda91d672
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/incompatible_sentinels.zig
@@ -0,0 +1,29 @@
+// 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.
+export fn entry1(ptr: [*:255]u8) [*:0]u8 {
+    return ptr;
+}
+export fn entry2(ptr: [*]u8) [*:0]u8 {
+    return ptr;
+}
+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;
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:4:12: error: expected type '[*:0]u8', found '[*:255]u8'
+// tmp.zig:4:12: note: destination pointer requires a terminating '0' sentinel, but source pointer has a terminating '255' sentinel
+// tmp.zig:7:12: error: expected type '[*:0]u8', found '[*]u8'
+// tmp.zig:7:12: note: destination pointer requires a terminating '0' sentinel
+// tmp.zig:10:35: error: expected type '[2:255]u8', found '[2:0]u8'
+// tmp.zig:10:35: note: destination array requires a terminating '255' sentinel, but source array has a terminating '0' sentinel
+// tmp.zig:14:31: error: expected type '[2:0]u8', found '[2]u8'
+// tmp.zig:14:31: note: destination array requires a terminating '0' sentinel
diff --git a/test/cases/compile_errors/stage1/obj/incorrect_return_type.zig b/test/cases/compile_errors/stage1/obj/incorrect_return_type.zig
new file mode 100644
index 0000000000000000000000000000000000000000..b25e2a8ea46a8cfd0768cd782cd047f93d442c02
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/incorrect_return_type.zig
@@ -0,0 +1,21 @@
+ pub export fn entry() void{
+     _ = foo();
+ }
+ const A = struct {
+     a: u32,
+ };
+ fn foo() A {
+     return bar();
+ }
+ const B = struct {
+     a: u32,
+ };
+ fn bar() B {
+     unreachable;
+ }
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:8:16: error: expected type 'A', found 'B'
diff --git a/test/cases/compile_errors/stage1/obj/increase_pointer_alignment_in_ptrCast.zig b/test/cases/compile_errors/stage1/obj/increase_pointer_alignment_in_ptrCast.zig
new file mode 100644
index 0000000000000000000000000000000000000000..f3f67ca4c657f43eba8741833e83ad469610f3c9
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/increase_pointer_alignment_in_ptrCast.zig
@@ -0,0 +1,13 @@
+export fn entry() u32 {
+    var bytes: [4]u8 = [_]u8{0x01, 0x02, 0x03, 0x04};
+    const ptr = @ptrCast(*u32, &bytes[0]);
+    return ptr.*;
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:3:17: error: cast increases pointer alignment
+// tmp.zig:3:38: note: '*u8' has alignment 1
+// tmp.zig:3:26: note: '*u32' has alignment 4
diff --git a/test/cases/compile_errors/stage1/obj/indexing_a_undefined_slice_at_comptime.zig b/test/cases/compile_errors/stage1/obj/indexing_a_undefined_slice_at_comptime.zig
new file mode 100644
index 0000000000000000000000000000000000000000..70b0c68658578c3d677a82cabe80c492eac2453a
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/indexing_a_undefined_slice_at_comptime.zig
@@ -0,0 +1,10 @@
+comptime {
+    var slice: []u8 = undefined;
+    slice[0] = 2;
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:3:10: error: index 0 outside slice of size 0
diff --git a/test/cases/compile_errors/stage1/obj/indexing_an_array_of_size_zero.zig b/test/cases/compile_errors/stage1/obj/indexing_an_array_of_size_zero.zig
new file mode 100644
index 0000000000000000000000000000000000000000..dfb2e7c1c314a1202f7f3348218b3b0064ed27d6
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/indexing_an_array_of_size_zero.zig
@@ -0,0 +1,11 @@
+const array = [_]u8{};
+export fn foo() void {
+    const pointer = &array[0];
+    _ = pointer;
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:3:27: error: accessing a zero length array is not allowed
diff --git a/test/cases/compile_errors/stage1/obj/indexing_an_array_of_size_zero_with_runtime_index.zig b/test/cases/compile_errors/stage1/obj/indexing_an_array_of_size_zero_with_runtime_index.zig
new file mode 100644
index 0000000000000000000000000000000000000000..f50931312e6e50e0f1dfe40463f2fe6b53c6bab1
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/indexing_an_array_of_size_zero_with_runtime_index.zig
@@ -0,0 +1,12 @@
+const array = [_]u8{};
+export fn foo() void {
+    var index: usize = 0;
+    const pointer = &array[index];
+    _ = pointer;
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:4:27: error: accessing a zero length array is not allowed
diff --git a/test/cases/compile_errors/stage1/obj/indexing_single-item_pointer.zig b/test/cases/compile_errors/stage1/obj/indexing_single-item_pointer.zig
new file mode 100644
index 0000000000000000000000000000000000000000..bc7951ec963c0076ca7fdb19816ce4c72ff28368
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/indexing_single-item_pointer.zig
@@ -0,0 +1,9 @@
+export fn entry(ptr: *i32) i32 {
+    return ptr[1];
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:2:15: error: index of single-item pointer
diff --git a/test/cases/compile_errors/stage1/obj/indirect_recursion_of_async_functions_detected.zig b/test/cases/compile_errors/stage1/obj/indirect_recursion_of_async_functions_detected.zig
new file mode 100644
index 0000000000000000000000000000000000000000..d845dc7930a73e4c85f24b57f9c6432a64bae4d3
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/indirect_recursion_of_async_functions_detected.zig
@@ -0,0 +1,36 @@
+var frame: ?anyframe = null;
+
+export fn a() void {
+    _ = async rangeSum(10);
+    while (frame) |f| resume f;
+}
+
+fn rangeSum(x: i32) i32 {
+    suspend {
+        frame = @frame();
+    }
+    frame = null;
+
+    if (x == 0) return 0;
+    var child = rangeSumIndirect(x - 1);
+    return child + 1;
+}
+
+fn rangeSumIndirect(x: i32) i32 {
+    suspend {
+        frame = @frame();
+    }
+    frame = null;
+
+    if (x == 0) return 0;
+    var child = rangeSum(x - 1);
+    return child + 1;
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:8:1: error: '@Frame(rangeSum)' depends on itself
+// tmp.zig:15:33: note: when analyzing type '@Frame(rangeSum)' here
+// tmp.zig:26:25: note: when analyzing type '@Frame(rangeSumIndirect)' here
diff --git a/test/cases/compile_errors/stage1/obj/indirect_struct_loop.zig b/test/cases/compile_errors/stage1/obj/indirect_struct_loop.zig
new file mode 100644
index 0000000000000000000000000000000000000000..12214923d089e642631c4b8c169153eccd23b5e1
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/indirect_struct_loop.zig
@@ -0,0 +1,10 @@
+const A = struct { b : B, };
+const B = struct { c : C, };
+const C = struct { a : A, };
+export fn entry() usize { return @sizeOf(A); }
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:1:11: error: struct 'A' depends on itself
diff --git a/test/cases/compile_errors/stage1/obj/inferred_array_size_invalid_here.zig b/test/cases/compile_errors/stage1/obj/inferred_array_size_invalid_here.zig
new file mode 100644
index 0000000000000000000000000000000000000000..2b2d944eab15d5a6cff927d91cb2c8ffc679dbc1
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/inferred_array_size_invalid_here.zig
@@ -0,0 +1,16 @@
+export fn entry() void {
+    const x = [_]u8;
+    _ = x;
+}
+export fn entry2() void {
+    const S = struct { a: *const [_]u8 };
+    var a = .{ S{} };
+    _ = a;
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:2:16: error: unable to infer array size
+// tmp.zig:6:35: error: unable to infer array size
diff --git a/test/cases/compile_errors/stage1/obj/inferring_error_set_of_function_pointer.zig b/test/cases/compile_errors/stage1/obj/inferring_error_set_of_function_pointer.zig
new file mode 100644
index 0000000000000000000000000000000000000000..b91242322d46db9edca71c412c9d46de7176d604
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/inferring_error_set_of_function_pointer.zig
@@ -0,0 +1,9 @@
+comptime {
+    const z: ?fn()!void = null;
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:2:19: error: function prototype may not have inferred error set
diff --git a/test/cases/compile_errors/stage1/obj/initializing_array_with_struct_syntax.zig b/test/cases/compile_errors/stage1/obj/initializing_array_with_struct_syntax.zig
new file mode 100644
index 0000000000000000000000000000000000000000..2884c6193e53fccb46f4fe6bf3bbc91561a2b3b4
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/initializing_array_with_struct_syntax.zig
@@ -0,0 +1,10 @@
+export fn entry() void {
+    const x = [_]u8{ .y = 2 };
+    _ = x;
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:2:15: error: initializing array with struct syntax
diff --git a/test/cases/compile_errors/stage1/obj/instantiating_an_undefined_value_for_an_invalid_struct_that_contains_itself.zig b/test/cases/compile_errors/stage1/obj/instantiating_an_undefined_value_for_an_invalid_struct_that_contains_itself.zig
new file mode 100644
index 0000000000000000000000000000000000000000..dd6909b1c22a2db543f7f1390dfc96a1fc3186b0
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/instantiating_an_undefined_value_for_an_invalid_struct_that_contains_itself.zig
@@ -0,0 +1,15 @@
+const Foo = struct {
+    x: Foo,
+};
+
+var foo: Foo = undefined;
+
+export fn entry() usize {
+    return @sizeOf(@TypeOf(foo.x));
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:1:13: error: struct 'Foo' depends on itself
diff --git a/test/cases/compile_errors/stage1/obj/intToPtr_with_misaligned_address.zig b/test/cases/compile_errors/stage1/obj/intToPtr_with_misaligned_address.zig
new file mode 100644
index 0000000000000000000000000000000000000000..16b6bf565e0d20f69b490bc66d81fc2e17e5106b
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/intToPtr_with_misaligned_address.zig
@@ -0,0 +1,10 @@
+pub fn main() void {
+    var y = @intToPtr([*]align(4) u8, 5);
+    _ = y;
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:2:13: error: pointer type '[*]align(4) u8' requires aligned address
diff --git a/test/cases/compile_errors/stage1/obj/int_to_err_global_invalid_number.zig b/test/cases/compile_errors/stage1/obj/int_to_err_global_invalid_number.zig
new file mode 100644
index 0000000000000000000000000000000000000000..5c078a751cc9d89c0ac97b969bc653afb6d0bc56
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/int_to_err_global_invalid_number.zig
@@ -0,0 +1,15 @@
+const Set1 = error{
+    A,
+    B,
+};
+comptime {
+    var x: u16 = 3;
+    var y = @intToError(x);
+    _ = y;
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:7:13: error: integer value 3 represents no error
diff --git a/test/cases/compile_errors/stage1/obj/int_to_err_non_global_invalid_number.zig b/test/cases/compile_errors/stage1/obj/int_to_err_non_global_invalid_number.zig
new file mode 100644
index 0000000000000000000000000000000000000000..8c1e547746efb84b01daaa858b437ea861076bbd
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/int_to_err_non_global_invalid_number.zig
@@ -0,0 +1,19 @@
+const Set1 = error{
+    A,
+    B,
+};
+const Set2 = error{
+    A,
+    C,
+};
+comptime {
+    var x = @errorToInt(Set1.B);
+    var y = @errSetCast(Set2, @intToError(x));
+    _ = y;
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:11:13: error: error.B not a member of error set 'Set2'
diff --git a/test/cases/compile_errors/stage1/obj/int_to_ptr_of_0_bits.zig b/test/cases/compile_errors/stage1/obj/int_to_ptr_of_0_bits.zig
new file mode 100644
index 0000000000000000000000000000000000000000..7b65cdf836eb711121f72c81f20697d8d4dc413c
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/int_to_ptr_of_0_bits.zig
@@ -0,0 +1,11 @@
+export fn foo() void {
+    var x: usize = 0x1000;
+    var y: *void = @intToPtr(*void, x);
+    _ = y;
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:3:30: error: type '*void' has 0 bits and cannot store information
diff --git a/test/cases/compile_errors/stage1/obj/integer_cast_truncates_bits.zig b/test/cases/compile_errors/stage1/obj/integer_cast_truncates_bits.zig
new file mode 100644
index 0000000000000000000000000000000000000000..e8ef41862430fc667c6e63c74298519c4caa5a94
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/integer_cast_truncates_bits.zig
@@ -0,0 +1,31 @@
+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;
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:3:18: error: cast from 'u16' to 'u8' truncates bits
+// tmp.zig:8:22: error: integer value 300 cannot be coerced to type 'u8'
+// tmp.zig:13:20: error: expected type 'u8', found 'u16'
+// tmp.zig:13:20: note: unsigned 8-bit int cannot represent all possible unsigned 16-bit values
+// tmp.zig:18:25: error: expected type 'u64', found 'i8'
+// tmp.zig:18:25: note: unsigned 64-bit int cannot represent all possible signed 8-bit values
diff --git a/test/cases/compile_errors/stage1/obj/integer_overflow_error.zig b/test/cases/compile_errors/stage1/obj/integer_overflow_error.zig
new file mode 100644
index 0000000000000000000000000000000000000000..117d77ed938c8a4d0d7b5986fc50bf38999b26ba
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/integer_overflow_error.zig
@@ -0,0 +1,8 @@
+const x : u8 = 300;
+export fn entry() usize { return @sizeOf(@TypeOf(x)); }
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:1:16: error: integer value 300 cannot be coerced to type 'u8'
diff --git a/test/cases/compile_errors/stage1/obj/integer_underflow_error.zig b/test/cases/compile_errors/stage1/obj/integer_underflow_error.zig
new file mode 100644
index 0000000000000000000000000000000000000000..15bd4c472bd3e9979908188e28bf7d7054f1ad26
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/integer_underflow_error.zig
@@ -0,0 +1,9 @@
+export fn entry() void {
+    _ = @intToPtr(*anyopaque, ~@as(usize, @import("std").math.maxInt(usize)) - 1);
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// :2:78: error: operation caused overflow
diff --git a/test/cases/compile_errors/stage1/obj/invalid_break_expression.zig b/test/cases/compile_errors/stage1/obj/invalid_break_expression.zig
new file mode 100644
index 0000000000000000000000000000000000000000..efb76a34f7b7d5b434a4376e892d6874ce8bb413
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/invalid_break_expression.zig
@@ -0,0 +1,9 @@
+export fn f() void {
+    break;
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:2:5: error: break expression outside loop
diff --git a/test/cases/compile_errors/stage1/obj/invalid_builtin_fn.zig b/test/cases/compile_errors/stage1/obj/invalid_builtin_fn.zig
new file mode 100644
index 0000000000000000000000000000000000000000..8f0e3633bb35a07a91e65d3242470c4ed655d0c8
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/invalid_builtin_fn.zig
@@ -0,0 +1,9 @@
+fn f() @bogus(foo) {
+}
+export fn entry() void { _ = f(); }
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:1:8: error: invalid builtin function: '@bogus'
diff --git a/test/cases/compile_errors/stage1/obj/invalid_cast_from_integral_type_to_enum.zig b/test/cases/compile_errors/stage1/obj/invalid_cast_from_integral_type_to_enum.zig
new file mode 100644
index 0000000000000000000000000000000000000000..81dbd88e3b1b24a2a4019cb4bf9b90a879f50916
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/invalid_cast_from_integral_type_to_enum.zig
@@ -0,0 +1,17 @@
+const E = enum(usize) { One, Two };
+
+export fn entry() void {
+    foo(1);
+}
+
+fn foo(x: usize) void {
+    switch (x) {
+        E.One => {},
+    }
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:9:10: error: expected type 'usize', found 'E'
diff --git a/test/cases/compile_errors/stage1/obj/invalid_comparison_for_function_pointers.zig b/test/cases/compile_errors/stage1/obj/invalid_comparison_for_function_pointers.zig
new file mode 100644
index 0000000000000000000000000000000000000000..6d64b6cdaf938620f99f05c5be8e77ee5239d19c
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/invalid_comparison_for_function_pointers.zig
@@ -0,0 +1,10 @@
+fn foo() void {}
+const invalid = foo > foo;
+
+export fn entry() usize { return @sizeOf(@TypeOf(invalid)); }
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:2:21: error: operator not allowed for type 'fn() void'
diff --git a/test/cases/compile_errors/stage1/obj/invalid_continue_expression.zig b/test/cases/compile_errors/stage1/obj/invalid_continue_expression.zig
new file mode 100644
index 0000000000000000000000000000000000000000..00f3c5a3d56f4b7d8c67112e670c62f5da41a3b2
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/invalid_continue_expression.zig
@@ -0,0 +1,9 @@
+export fn f() void {
+    continue;
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:2:5: error: continue expression outside loop
diff --git a/test/cases/compile_errors/stage1/obj/invalid_deref_on_switch_target.zig b/test/cases/compile_errors/stage1/obj/invalid_deref_on_switch_target.zig
new file mode 100644
index 0000000000000000000000000000000000000000..966a881543304a501d5a9f5b0db62d93e9caa65d
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/invalid_deref_on_switch_target.zig
@@ -0,0 +1,17 @@
+comptime {
+    var tile = Tile.Empty;
+    switch (tile.*) {
+        Tile.Empty => {},
+        Tile.Filled => {},
+    }
+}
+const Tile = enum {
+    Empty,
+    Filled,
+};
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:3:17: error: attempt to dereference non-pointer type 'Tile'
diff --git a/test/cases/compile_errors/stage1/obj/invalid_empty_unicode_escape.zig b/test/cases/compile_errors/stage1/obj/invalid_empty_unicode_escape.zig
new file mode 100644
index 0000000000000000000000000000000000000000..57dd16a63def4ef8e2197786f4d0f7d05d8b3f0d
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/invalid_empty_unicode_escape.zig
@@ -0,0 +1,9 @@
+export fn entry() void {
+    const a = '\u{}';
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:2:19: error: empty unicode escape sequence
diff --git a/test/cases/compile_errors/stage1/obj/invalid_exponent_in_float_literal-1.zig b/test/cases/compile_errors/stage1/obj/invalid_exponent_in_float_literal-1.zig
new file mode 100644
index 0000000000000000000000000000000000000000..431401c53421868fcb5e7087b57e2a5fd57cee58
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/invalid_exponent_in_float_literal-1.zig
@@ -0,0 +1,11 @@
+fn main() void {
+    var bad: f128 = 0x1.0p1ab1;
+    _ = bad;
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:2:21: error: expected expression, found 'invalid bytes'
+// tmp.zig:2:28: note: invalid byte: 'a'
diff --git a/test/cases/compile_errors/stage1/obj/invalid_exponent_in_float_literal-2.zig b/test/cases/compile_errors/stage1/obj/invalid_exponent_in_float_literal-2.zig
new file mode 100644
index 0000000000000000000000000000000000000000..088b43546c64a1aa67af3d734f22dbcc9267dae2
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/invalid_exponent_in_float_literal-2.zig
@@ -0,0 +1,11 @@
+fn main() void {
+    var bad: f128 = 0x1.0p50F;
+    _ = bad;
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:2:21: error: expected expression, found 'invalid bytes'
+// tmp.zig:2:29: note: invalid byte: 'F'
diff --git a/test/cases/compile_errors/stage1/obj/invalid_field_access_in_comptime.zig b/test/cases/compile_errors/stage1/obj/invalid_field_access_in_comptime.zig
new file mode 100644
index 0000000000000000000000000000000000000000..2630a704ed49224a36ae7972196dc8f7a416a573
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/invalid_field_access_in_comptime.zig
@@ -0,0 +1,7 @@
+comptime { var x = doesnt_exist.whatever; _ = x; }
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:1:20: error: use of undeclared identifier 'doesnt_exist'
diff --git a/test/cases/compile_errors/stage1/obj/invalid_field_in_struct_value_expression.zig b/test/cases/compile_errors/stage1/obj/invalid_field_in_struct_value_expression.zig
new file mode 100644
index 0000000000000000000000000000000000000000..fae0a90b518cc0c701edbd144cb6d7077b472beb
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/invalid_field_in_struct_value_expression.zig
@@ -0,0 +1,19 @@
+const A = struct {
+    x : i32,
+    y : i32,
+    z : i32,
+};
+export fn f() void {
+    const a = A {
+        .z = 4,
+        .y = 2,
+        .foo = 42,
+    };
+    _ = a;
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:10:9: error: no member named 'foo' in struct 'A'
diff --git a/test/cases/compile_errors/stage1/obj/invalid_float_literal.zig b/test/cases/compile_errors/stage1/obj/invalid_float_literal.zig
new file mode 100644
index 0000000000000000000000000000000000000000..709609a027a5ebf4464aa21f4f29a351d121d70b
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/invalid_float_literal.zig
@@ -0,0 +1,13 @@
+const std = @import("std");
+
+pub fn main() void {
+    var bad_float :f32 = 0.0;
+    bad_float = bad_float + .20;
+    std.debug.assert(bad_float < 1.0);
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:5:29: error: expected expression, found '.'
diff --git a/test/cases/compile_errors/stage1/obj/invalid_legacy_unicode_escape.zig b/test/cases/compile_errors/stage1/obj/invalid_legacy_unicode_escape.zig
new file mode 100644
index 0000000000000000000000000000000000000000..b81a814a604ac77c001f133b611b539bb1a55ec0
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/invalid_legacy_unicode_escape.zig
@@ -0,0 +1,10 @@
+export fn entry() void {
+    const a = '\U1234';
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:2:15: error: expected expression, found 'invalid bytes'
+// tmp.zig:2:18: note: invalid byte: '1'
diff --git a/test/cases/compile_errors/stage1/obj/invalid_maybe_type.zig b/test/cases/compile_errors/stage1/obj/invalid_maybe_type.zig
new file mode 100644
index 0000000000000000000000000000000000000000..cb075c36b7139b2fce5fcc688d646e848971fa16
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/invalid_maybe_type.zig
@@ -0,0 +1,9 @@
+export fn f() void {
+    if (true) |x| { _ = x; }
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:2:9: error: expected optional type, found 'bool'
diff --git a/test/cases/compile_errors/stage1/obj/invalid_member_of_builtin_enum.zig b/test/cases/compile_errors/stage1/obj/invalid_member_of_builtin_enum.zig
new file mode 100644
index 0000000000000000000000000000000000000000..166ebfc78260858195378552ce4464c49967c7b0
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/invalid_member_of_builtin_enum.zig
@@ -0,0 +1,11 @@
+const builtin = @import("std").builtin;
+export fn entry() void {
+    const foo = builtin.Mode.x86;
+    _ = foo;
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:3:29: error: container 'std.builtin.Mode' has no member called 'x86'
diff --git a/test/cases/compile_errors/stage1/obj/invalid_multiple_dereferences.zig b/test/cases/compile_errors/stage1/obj/invalid_multiple_dereferences.zig
new file mode 100644
index 0000000000000000000000000000000000000000..f8a0b8013f0ccbaa8e1519cf013932b0ce607a18
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/invalid_multiple_dereferences.zig
@@ -0,0 +1,19 @@
+export fn a() void {
+    var box = Box{ .field = 0 };
+    box.*.field = 1;
+}
+export fn b() void {
+    var box = Box{ .field = 0 };
+    var boxPtr = &box;
+    boxPtr.*.*.field = 1;
+}
+pub const Box = struct {
+    field: i32,
+};
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:3:8: error: attempt to dereference non-pointer type 'Box'
+// tmp.zig:8:13: error: attempt to dereference non-pointer type 'Box'
diff --git a/test/cases/compile_errors/stage1/obj/invalid_optional_type_in_extern_struct.zig b/test/cases/compile_errors/stage1/obj/invalid_optional_type_in_extern_struct.zig
new file mode 100644
index 0000000000000000000000000000000000000000..dc2e2690b8cf539a80c86089f2ee34c029c888ca
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/invalid_optional_type_in_extern_struct.zig
@@ -0,0 +1,10 @@
+const stroo = extern struct {
+    moo: ?[*c]u8,
+};
+export fn testf(fluff: *stroo) void { _ = fluff; }
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:2:5: error: extern structs cannot contain fields of type '?[*c]u8'
diff --git a/test/cases/compile_errors/stage1/obj/invalid_pointer_for_var_type.zig b/test/cases/compile_errors/stage1/obj/invalid_pointer_for_var_type.zig
new file mode 100644
index 0000000000000000000000000000000000000000..caf8c707975612901866ee4d53836b491436258d
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/invalid_pointer_for_var_type.zig
@@ -0,0 +1,13 @@
+extern fn ext() usize;
+var bytes: [ext()]u8 = undefined;
+export fn f() void {
+    for (bytes) |*b, i| {
+        b.* = @as(u8, i);
+    }
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:2:13: error: unable to evaluate constant expression
diff --git a/test/cases/compile_errors/stage1/obj/invalid_pointer_syntax.zig b/test/cases/compile_errors/stage1/obj/invalid_pointer_syntax.zig
new file mode 100644
index 0000000000000000000000000000000000000000..a4c823bde1a755b70782643ab988ff2a9db6bfb7
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/invalid_pointer_syntax.zig
@@ -0,0 +1,9 @@
+export fn foo() void {
+    var guid: *:0 const u8 = undefined;
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:2:16: error: expected type expression, found ':'
diff --git a/test/cases/compile_errors/stage1/obj/invalid_shift_amount_error.zig b/test/cases/compile_errors/stage1/obj/invalid_shift_amount_error.zig
new file mode 100644
index 0000000000000000000000000000000000000000..7c84f2db38d98bdd31b22600e299233499810bf9
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/invalid_shift_amount_error.zig
@@ -0,0 +1,11 @@
+const x : u8 = 2;
+fn f() u16 {
+    return x << 8;
+}
+export fn entry() u16 { return f(); }
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:3:17: error: integer value 8 cannot be coerced to type 'u3'
diff --git a/test/cases/compile_errors/stage1/obj/invalid_struct_field.zig b/test/cases/compile_errors/stage1/obj/invalid_struct_field.zig
new file mode 100644
index 0000000000000000000000000000000000000000..6264125bca531e2e83e0c9b908842441e11ddf95
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/invalid_struct_field.zig
@@ -0,0 +1,19 @@
+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;
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:4:6: error: no member named 'foo' in struct 'A'
+// tmp.zig:10:16: error: no member named 'bar' in struct 'A'
diff --git a/test/cases/compile_errors/stage1/obj/invalid_suspend_in_exported_function.zig b/test/cases/compile_errors/stage1/obj/invalid_suspend_in_exported_function.zig
new file mode 100644
index 0000000000000000000000000000000000000000..cfcbfba889dfd57b1260ee14df08d354f4973de4
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/invalid_suspend_in_exported_function.zig
@@ -0,0 +1,15 @@
+export fn entry() void {
+    var frame = async func();
+    var result = await frame;
+    _ = result;
+}
+fn func() void {
+    suspend {}
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:1:1: error: function with calling convention 'C' cannot be async
+// tmp.zig:3:18: note: await here is a suspend point
diff --git a/test/cases/compile_errors/stage1/obj/invalid_type.zig b/test/cases/compile_errors/stage1/obj/invalid_type.zig
new file mode 100644
index 0000000000000000000000000000000000000000..8a2952e5f2c32346811eb3a50dd399b7046a0a52
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/invalid_type.zig
@@ -0,0 +1,8 @@
+fn a() bogus {}
+export fn entry() void { _ = a(); }
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:1:8: error: use of undeclared identifier 'bogus'
diff --git a/test/cases/compile_errors/stage1/obj/invalid_type_used_in_array_type.zig b/test/cases/compile_errors/stage1/obj/invalid_type_used_in_array_type.zig
new file mode 100644
index 0000000000000000000000000000000000000000..3a7bc4272c04807cdd437948bc6b2af9021e4362
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/invalid_type_used_in_array_type.zig
@@ -0,0 +1,14 @@
+const Item = struct {
+    field: SomeNonexistentType,
+};
+var items: [100]Item = undefined;
+export fn entry() void {
+    const a = items[0];
+    _ = a;
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:2:12: error: use of undeclared identifier 'SomeNonexistentType'
diff --git a/test/cases/compile_errors/stage1/obj/invalid_underscore_placement_in_float_literal-1.zig b/test/cases/compile_errors/stage1/obj/invalid_underscore_placement_in_float_literal-1.zig
new file mode 100644
index 0000000000000000000000000000000000000000..a3e2827f3141bd39c163dffcf77ec5061d782301
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/invalid_underscore_placement_in_float_literal-1.zig
@@ -0,0 +1,11 @@
+fn main() void {
+    var bad: f128 = 0._0;
+    _ = bad;
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:2:21: error: expected expression, found 'invalid bytes'
+// tmp.zig:2:23: note: invalid byte: '_'
diff --git a/test/cases/compile_errors/stage1/obj/invalid_underscore_placement_in_float_literal-10.zig b/test/cases/compile_errors/stage1/obj/invalid_underscore_placement_in_float_literal-10.zig
new file mode 100644
index 0000000000000000000000000000000000000000..7d33244483322d15183a2388740db14d4147dbdd
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/invalid_underscore_placement_in_float_literal-10.zig
@@ -0,0 +1,11 @@
+fn main() void {
+    var bad: f128 = 1.0__0e-1;
+    _ = bad;
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:2:21: error: expected expression, found 'invalid bytes'
+// tmp.zig:2:25: note: invalid byte: '_'
diff --git a/test/cases/compile_errors/stage1/obj/invalid_underscore_placement_in_float_literal-11.zig b/test/cases/compile_errors/stage1/obj/invalid_underscore_placement_in_float_literal-11.zig
new file mode 100644
index 0000000000000000000000000000000000000000..fa4f5b8975f619a123e2c9a297d9a09c5587b981
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/invalid_underscore_placement_in_float_literal-11.zig
@@ -0,0 +1,11 @@
+fn main() void {
+    var bad: f128 = 1.0e-1__0;
+    _ = bad;
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:2:21: error: expected expression, found 'invalid bytes'
+// tmp.zig:2:28: note: invalid byte: '_'
diff --git a/test/cases/compile_errors/stage1/obj/invalid_underscore_placement_in_float_literal-12.zig b/test/cases/compile_errors/stage1/obj/invalid_underscore_placement_in_float_literal-12.zig
new file mode 100644
index 0000000000000000000000000000000000000000..2d36187711738ac775525c2818d8469fb62d0ba7
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/invalid_underscore_placement_in_float_literal-12.zig
@@ -0,0 +1,11 @@
+fn main() void {
+    var bad: f128 = 0_x0.0;
+    _ = bad;
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:2:21: error: expected expression, found 'invalid bytes'
+// tmp.zig:2:23: note: invalid byte: 'x'
diff --git a/test/cases/compile_errors/stage1/obj/invalid_underscore_placement_in_float_literal-13.zig b/test/cases/compile_errors/stage1/obj/invalid_underscore_placement_in_float_literal-13.zig
new file mode 100644
index 0000000000000000000000000000000000000000..21b044121c9cfcbbf1ac2b1cfdeeb5a1f9140d2d
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/invalid_underscore_placement_in_float_literal-13.zig
@@ -0,0 +1,11 @@
+fn main() void {
+    var bad: f128 = 0x_0.0;
+    _ = bad;
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:2:21: error: expected expression, found 'invalid bytes'
+// tmp.zig:2:23: note: invalid byte: '_'
diff --git a/test/cases/compile_errors/stage1/obj/invalid_underscore_placement_in_float_literal-14.zig b/test/cases/compile_errors/stage1/obj/invalid_underscore_placement_in_float_literal-14.zig
new file mode 100644
index 0000000000000000000000000000000000000000..adb0727eba7f1822d8916a7c81a6f04042d9fb1c
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/invalid_underscore_placement_in_float_literal-14.zig
@@ -0,0 +1,11 @@
+fn main() void {
+    var bad: f128 = 0x0.0_p1;
+    _ = bad;
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:2:21: error: expected expression, found 'invalid bytes'
+// tmp.zig:2:27: note: invalid byte: 'p'
diff --git a/test/cases/compile_errors/stage1/obj/invalid_underscore_placement_in_float_literal-2.zig b/test/cases/compile_errors/stage1/obj/invalid_underscore_placement_in_float_literal-2.zig
new file mode 100644
index 0000000000000000000000000000000000000000..16618c6a18b18f49ded416ae2cf0bc0ab8438a9d
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/invalid_underscore_placement_in_float_literal-2.zig
@@ -0,0 +1,11 @@
+fn main() void {
+    var bad: f128 = 0_.0;
+    _ = bad;
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:2:21: error: expected expression, found 'invalid bytes'
+// tmp.zig:2:23: note: invalid byte: '.'
diff --git a/test/cases/compile_errors/stage1/obj/invalid_underscore_placement_in_float_literal-3.zig b/test/cases/compile_errors/stage1/obj/invalid_underscore_placement_in_float_literal-3.zig
new file mode 100644
index 0000000000000000000000000000000000000000..09e9e20b4b607af0e83801e7404de60619ef4af6
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/invalid_underscore_placement_in_float_literal-3.zig
@@ -0,0 +1,11 @@
+fn main() void {
+    var bad: f128 = 0.0_;
+    _ = bad;
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:2:21: error: expected expression, found 'invalid bytes'
+// tmp.zig:2:25: note: invalid byte: ';'
diff --git a/test/cases/compile_errors/stage1/obj/invalid_underscore_placement_in_float_literal-4.zig b/test/cases/compile_errors/stage1/obj/invalid_underscore_placement_in_float_literal-4.zig
new file mode 100644
index 0000000000000000000000000000000000000000..278ee35f5f2130fbf8a4490b3730645e24d639c1
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/invalid_underscore_placement_in_float_literal-4.zig
@@ -0,0 +1,11 @@
+fn main() void {
+    var bad: f128 = 1.0e_1;
+    _ = bad;
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:2:21: error: expected expression, found 'invalid bytes'
+// tmp.zig:2:25: note: invalid byte: '_'
diff --git a/test/cases/compile_errors/stage1/obj/invalid_underscore_placement_in_float_literal-5.zig b/test/cases/compile_errors/stage1/obj/invalid_underscore_placement_in_float_literal-5.zig
new file mode 100644
index 0000000000000000000000000000000000000000..4912c15e504e4874775def6e859f278c1b628e65
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/invalid_underscore_placement_in_float_literal-5.zig
@@ -0,0 +1,11 @@
+fn main() void {
+    var bad: f128 = 1.0e+_1;
+    _ = bad;
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:2:21: error: expected expression, found 'invalid bytes'
+// tmp.zig:2:26: note: invalid byte: '_'
diff --git a/test/cases/compile_errors/stage1/obj/invalid_underscore_placement_in_float_literal-6.zig b/test/cases/compile_errors/stage1/obj/invalid_underscore_placement_in_float_literal-6.zig
new file mode 100644
index 0000000000000000000000000000000000000000..3386c860b93278e6322434bf58d5b2ed756a3220
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/invalid_underscore_placement_in_float_literal-6.zig
@@ -0,0 +1,11 @@
+fn main() void {
+    var bad: f128 = 1.0e-_1;
+    _ = bad;
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:2:21: error: expected expression, found 'invalid bytes'
+// tmp.zig:2:26: note: invalid byte: '_'
diff --git a/test/cases/compile_errors/stage1/obj/invalid_underscore_placement_in_float_literal-7.zig b/test/cases/compile_errors/stage1/obj/invalid_underscore_placement_in_float_literal-7.zig
new file mode 100644
index 0000000000000000000000000000000000000000..c0e57424a948fa2b50b2ed88f4d00223386f5a40
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/invalid_underscore_placement_in_float_literal-7.zig
@@ -0,0 +1,11 @@
+fn main() void {
+    var bad: f128 = 1.0e-1_;
+    _ = bad;
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:2:21: error: expected expression, found 'invalid bytes'
+// tmp.zig:2:28: note: invalid byte: ';'
diff --git a/test/cases/compile_errors/stage1/obj/invalid_underscore_placement_in_float_literal-9.zig b/test/cases/compile_errors/stage1/obj/invalid_underscore_placement_in_float_literal-9.zig
new file mode 100644
index 0000000000000000000000000000000000000000..f7475332c1540149e921c03079cabb056ef5fc11
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/invalid_underscore_placement_in_float_literal-9.zig
@@ -0,0 +1,11 @@
+fn main() void {
+    var bad: f128 = 1__0.0e-1;
+    _ = bad;
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:2:21: error: expected expression, found 'invalid bytes'
+// tmp.zig:2:23: note: invalid byte: '_'
diff --git a/test/cases/compile_errors/stage1/obj/invalid_underscore_placement_in_int_literal-1.zig b/test/cases/compile_errors/stage1/obj/invalid_underscore_placement_in_int_literal-1.zig
new file mode 100644
index 0000000000000000000000000000000000000000..9cea337db46ceb33d12386fb64c57aa4f3a64635
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/invalid_underscore_placement_in_int_literal-1.zig
@@ -0,0 +1,11 @@
+fn main() void {
+    var bad: u128 = 0010_;
+    _ = bad;
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:2:21: error: expected expression, found 'invalid bytes'
+// tmp.zig:2:26: note: invalid byte: ';'
diff --git a/test/cases/compile_errors/stage1/obj/invalid_underscore_placement_in_int_literal-2.zig b/test/cases/compile_errors/stage1/obj/invalid_underscore_placement_in_int_literal-2.zig
new file mode 100644
index 0000000000000000000000000000000000000000..5f02479f2e7d6b68de0a8323ffa1f91ccd934b2a
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/invalid_underscore_placement_in_int_literal-2.zig
@@ -0,0 +1,11 @@
+fn main() void {
+    var bad: u128 = 0b0010_;
+    _ = bad;
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:2:21: error: expected expression, found 'invalid bytes'
+// tmp.zig:2:28: note: invalid byte: ';'
diff --git a/test/cases/compile_errors/stage1/obj/invalid_underscore_placement_in_int_literal-3.zig b/test/cases/compile_errors/stage1/obj/invalid_underscore_placement_in_int_literal-3.zig
new file mode 100644
index 0000000000000000000000000000000000000000..aed4cb90687f9394dfbf14664baa502ce0bf465d
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/invalid_underscore_placement_in_int_literal-3.zig
@@ -0,0 +1,11 @@
+fn main() void {
+    var bad: u128 = 0o0010_;
+    _ = bad;
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:2:21: error: expected expression, found 'invalid bytes'
+// tmp.zig:2:28: note: invalid byte: ';'
diff --git a/test/cases/compile_errors/stage1/obj/invalid_underscore_placement_in_int_literal-4.zig b/test/cases/compile_errors/stage1/obj/invalid_underscore_placement_in_int_literal-4.zig
new file mode 100644
index 0000000000000000000000000000000000000000..dce2771048c9baf8e2c1d452cb331e6fa3927267
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/invalid_underscore_placement_in_int_literal-4.zig
@@ -0,0 +1,11 @@
+fn main() void {
+    var bad: u128 = 0x0010_;
+    _ = bad;
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:2:21: error: expected expression, found 'invalid bytes'
+// tmp.zig:2:28: note: invalid byte: ';'
diff --git a/test/cases/compile_errors/stage1/obj/invalid_union_field_access_in_comptime.zig b/test/cases/compile_errors/stage1/obj/invalid_union_field_access_in_comptime.zig
new file mode 100644
index 0000000000000000000000000000000000000000..6d55f3b04fb3c0dcfde90f94d70023ae81a053c5
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/invalid_union_field_access_in_comptime.zig
@@ -0,0 +1,15 @@
+const Foo = union {
+    Bar: u8,
+    Baz: void,
+};
+comptime {
+    var foo = Foo {.Baz = {}};
+    const bar_val = foo.Bar;
+    _ = bar_val;
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:7:24: error: accessing union field 'Bar' while field 'Baz' is set
diff --git a/test/cases/compile_errors/stage1/obj/issue_2032_compile_diagnostic_string_for_top_level_decl_type.zig b/test/cases/compile_errors/stage1/obj/issue_2032_compile_diagnostic_string_for_top_level_decl_type.zig
new file mode 100644
index 0000000000000000000000000000000000000000..c742cb9b7756546712193dc0f72db5e307b3ed6a
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/issue_2032_compile_diagnostic_string_for_top_level_decl_type.zig
@@ -0,0 +1,10 @@
+export fn entry() void {
+    var foo: u32 = @This(){};
+    _ = foo;
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:2:27: error: type 'u32' does not support array initialization
diff --git a/test/cases/compile_errors/stage1/obj/issue_2687_coerce_from_undefined_array_pointer_to_slice.zig b/test/cases/compile_errors/stage1/obj/issue_2687_coerce_from_undefined_array_pointer_to_slice.zig
new file mode 100644
index 0000000000000000000000000000000000000000..21fbb6b4fe94a065781e911e13b83359e0125bb4
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/issue_2687_coerce_from_undefined_array_pointer_to_slice.zig
@@ -0,0 +1,27 @@
+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;
+    }
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:3:19: error: use of undefined value here causes undefined behavior
+// tmp.zig:9:23: error: use of undefined value here causes undefined behavior
+// tmp.zig:16:23: error: use of undefined value here causes undefined behavior
diff --git a/test/cases/compile_errors/stage1/obj/issue_3818_bitcast_from_parray-slice_to_u16.zig b/test/cases/compile_errors/stage1/obj/issue_3818_bitcast_from_parray-slice_to_u16.zig
new file mode 100644
index 0000000000000000000000000000000000000000..cdc1def677920f15211808b80741d89965f5f960
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/issue_3818_bitcast_from_parray-slice_to_u16.zig
@@ -0,0 +1,17 @@
+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;
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:3:42: error: unable to @bitCast from pointer type '*[2]u8'
+// tmp.zig:8:32: error: destination type 'u16' has size 2 but source type '[]const u8' has size 16
diff --git a/test/cases/compile_errors/stage1/obj/issue_4207_coerce_from_non-terminated-slice_to_terminated-pointer.zig b/test/cases/compile_errors/stage1/obj/issue_4207_coerce_from_non-terminated-slice_to_terminated-pointer.zig
new file mode 100644
index 0000000000000000000000000000000000000000..d53f7731a091272165cdd221ecc5e3be024764b3
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/issue_4207_coerce_from_non-terminated-slice_to_terminated-pointer.zig
@@ -0,0 +1,11 @@
+export fn foo() [*:0]const u8 {
+    var buffer: [64]u8 = undefined;
+    return buffer[0..];
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// :3:18: error: expected type '[*:0]const u8', found '*[64]u8'
+// :3:18: note: destination pointer requires a terminating '0' sentinel
diff --git a/test/cases/compile_errors/stage1/obj/issue_5221_invalid_struct_init_type_referenced_by_typeInfo_and_passed_into_function.zig b/test/cases/compile_errors/stage1/obj/issue_5221_invalid_struct_init_type_referenced_by_typeInfo_and_passed_into_function.zig
new file mode 100644
index 0000000000000000000000000000000000000000..a622ceb44e0abf38d9131ed19eed8a4b9895cf73
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/issue_5221_invalid_struct_init_type_referenced_by_typeInfo_and_passed_into_function.zig
@@ -0,0 +1,16 @@
+fn ignore(comptime param: anytype) void {_ = param;}
+
+export fn foo() void {
+    const MyStruct = struct {
+        wrong_type: []u8 = "foo",
+    };
+
+    comptime ignore(@typeInfo(MyStruct).Struct.fields[0]);
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// :5:28: error: cannot cast pointer to array literal to slice type '[]u8'
+// :5:28: note: cast discards const qualifier
diff --git a/test/cases/compile_errors/stage1/obj/issue_5618_coercion_of_optional_anyopaque_to_anyopaque_must_fail.zig b/test/cases/compile_errors/stage1/obj/issue_5618_coercion_of_optional_anyopaque_to_anyopaque_must_fail.zig
new file mode 100644
index 0000000000000000000000000000000000000000..9ba991083865b84cbe56ebfcc6fd8503b2ce5bc6
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/issue_5618_coercion_of_optional_anyopaque_to_anyopaque_must_fail.zig
@@ -0,0 +1,11 @@
+export fn foo() void {
+    var u: ?*anyopaque = null;
+    var v: *anyopaque = undefined;
+    v = u;
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:4:9: error: cannot convert optional to payload type. consider using `.?`, `orelse`, or `if`. expected type '*anyopaque', found '?*anyopaque'
diff --git a/test/cases/compile_errors/stage1/obj/issue_7810-comptime_slice-len_increment_beyond_bounds.zig b/test/cases/compile_errors/stage1/obj/issue_7810-comptime_slice-len_increment_beyond_bounds.zig
new file mode 100644
index 0000000000000000000000000000000000000000..c8b2f0b09e9310836c7c7e0766c9f99f20f36e9e
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/issue_7810-comptime_slice-len_increment_beyond_bounds.zig
@@ -0,0 +1,14 @@
+export fn foo_slice_len_increment_beyond_bounds() void {
+    comptime {
+        var buf_storage: [8]u8 = undefined;
+        var buf: []const u8 = buf_storage[0..];
+        buf.len += 1;
+        buf[8] = 42;
+    }
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// :6:12: error: out of bounds slice
diff --git a/test/cases/compile_errors/stage1/obj/issue_9346_return_outside_of_function_scope.zig b/test/cases/compile_errors/stage1/obj/issue_9346_return_outside_of_function_scope.zig
new file mode 100644
index 0000000000000000000000000000000000000000..d12bff2b49c542ef7b07e4832e606c23c247c616
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/issue_9346_return_outside_of_function_scope.zig
@@ -0,0 +1,7 @@
+pub const empty = return 1;
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:1:19: error: 'return' outside function scope
diff --git a/test/cases/compile_errors/stage1/obj/labeled_break_not_found.zig b/test/cases/compile_errors/stage1/obj/labeled_break_not_found.zig
new file mode 100644
index 0000000000000000000000000000000000000000..754e1864b096a6c76fcbdb3359c2dba8452da8c2
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/labeled_break_not_found.zig
@@ -0,0 +1,13 @@
+export fn entry() void {
+    blah: while (true) {
+        while (true) {
+            break :outer;
+        }
+    }
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:4:20: error: label not found: 'outer'
diff --git a/test/cases/compile_errors/stage1/obj/labeled_continue_not_found.zig b/test/cases/compile_errors/stage1/obj/labeled_continue_not_found.zig
new file mode 100644
index 0000000000000000000000000000000000000000..b112e9b3557ffc9b463a1d6a3221151820e37490
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/labeled_continue_not_found.zig
@@ -0,0 +1,14 @@
+export fn entry() void {
+    var i: usize = 0;
+    blah: while (i < 10) : (i += 1) {
+        while (true) {
+            continue :outer;
+        }
+    }
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:5:23: error: label not found: 'outer'
diff --git a/test/cases/compile_errors/stage1/obj/lazy_pointer_with_undefined_element_type.zig b/test/cases/compile_errors/stage1/obj/lazy_pointer_with_undefined_element_type.zig
new file mode 100644
index 0000000000000000000000000000000000000000..733a3ca2dd89d1b97050473303a5d90cd7747c8e
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/lazy_pointer_with_undefined_element_type.zig
@@ -0,0 +1,12 @@
+export fn foo() void {
+    comptime var T: type = undefined;
+    const S = struct { x: *T };
+    const I = @typeInfo(S);
+    _ = I;
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// :3:28: error: use of undefined value here causes undefined behavior
diff --git a/test/cases/compile_errors/stage1/obj/libc_headers_note.zig b/test/cases/compile_errors/stage1/obj/libc_headers_note.zig
new file mode 100644
index 0000000000000000000000000000000000000000..c8d9a9cbf3aff757f4b5ce532beb1ef430f37c72
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/libc_headers_note.zig
@@ -0,0 +1,12 @@
+const c = @cImport(@cInclude("stdio.h"));
+export fn entry() void {
+    _ = c.printf("hello, world!\n");
+}
+
+// error
+// backend=stage1
+// is_test=1
+// target=native-linux
+//
+// tmp.zig:1:11: error: C import failed
+// tmp.zig:1:11: note: libc headers not available; compilation does not link against libc
diff --git a/test/cases/compile_errors/stage1/obj/load_too_many_bytes_from_comptime_reinterpreted_pointer.zig b/test/cases/compile_errors/stage1/obj/load_too_many_bytes_from_comptime_reinterpreted_pointer.zig
new file mode 100644
index 0000000000000000000000000000000000000000..b275dbbeedbef7f25a3ec42a3c9a3e3c757542bc
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/load_too_many_bytes_from_comptime_reinterpreted_pointer.zig
@@ -0,0 +1,13 @@
+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;
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:5:28: error: attempt to read 8 bytes from pointer to f32 which is 4 bytes
diff --git a/test/cases/compile_errors/stage1/obj/load_vector_pointer_with_unknown_runtime_index.zig b/test/cases/compile_errors/stage1/obj/load_vector_pointer_with_unknown_runtime_index.zig
new file mode 100644
index 0000000000000000000000000000000000000000..8d703b09e6c6c9a1a370badaade02aeebc252abe
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/load_vector_pointer_with_unknown_runtime_index.zig
@@ -0,0 +1,17 @@
+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.*;
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:10:12: error: unable to determine vector element index of type '*align(16:0:4:?) i32
diff --git a/test/cases/compile_errors/stage1/obj/local_shadows_global_that_occurs_later.zig b/test/cases/compile_errors/stage1/obj/local_shadows_global_that_occurs_later.zig
new file mode 100644
index 0000000000000000000000000000000000000000..4b9b58871ff0e689880772d357e433597f16275e
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/local_shadows_global_that_occurs_later.zig
@@ -0,0 +1,12 @@
+pub fn main() void {
+    var foo = true;
+    _ = foo;
+}
+fn foo() void {}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:2:9: error: local shadows declaration of 'foo'
+// tmp.zig:5:1: note: declared here
diff --git a/test/cases/compile_errors/stage1/obj/local_variable_redeclaration.zig b/test/cases/compile_errors/stage1/obj/local_variable_redeclaration.zig
new file mode 100644
index 0000000000000000000000000000000000000000..79eba0d4288233f7dd4f4d2ceba0f8b076d2b8eb
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/local_variable_redeclaration.zig
@@ -0,0 +1,11 @@
+export fn f() void {
+    const a : i32 = 0;
+    var a = 0;
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:3:9: error: redeclaration of local constant 'a'
+// tmp.zig:2:11: note: previous declaration here
diff --git a/test/cases/compile_errors/stage1/obj/local_variable_redeclares_parameter.zig b/test/cases/compile_errors/stage1/obj/local_variable_redeclares_parameter.zig
new file mode 100644
index 0000000000000000000000000000000000000000..854ef080c526909f13f0fc442303b6fc579a3bcd
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/local_variable_redeclares_parameter.zig
@@ -0,0 +1,11 @@
+fn f(a : i32) void {
+    const a = 0;
+}
+export fn entry() void { f(1); }
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:2:11: error: redeclaration of function parameter 'a'
+// tmp.zig:1:6: note: previous declaration here
diff --git a/test/cases/compile_errors/stage1/obj/local_variable_shadowing_global.zig b/test/cases/compile_errors/stage1/obj/local_variable_shadowing_global.zig
new file mode 100644
index 0000000000000000000000000000000000000000..3f1af3a4cb891aab5048a4f5218f62489a557d8d
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/local_variable_shadowing_global.zig
@@ -0,0 +1,14 @@
+const Foo = struct {};
+const Bar = struct {};
+
+export fn entry() void {
+    var Bar : i32 = undefined;
+    _ = Bar;
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:5:9: error: local shadows declaration of 'Bar'
+// tmp.zig:2:1: note: declared here
diff --git a/test/cases/compile_errors/stage1/obj/locally_shadowing_a_primitive_type.zig b/test/cases/compile_errors/stage1/obj/locally_shadowing_a_primitive_type.zig
new file mode 100644
index 0000000000000000000000000000000000000000..e66a2082ea87fbf27a9338a7a5c7cfcda12e13c5
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/locally_shadowing_a_primitive_type.zig
@@ -0,0 +1,12 @@
+export fn foo() void {
+    const u8 = u16;
+    const a: u8 = 300;
+    _ = a;
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:2:11: error: name shadows primitive 'u8'
+// tmp.zig:2:11: note: consider using @"u8" to disambiguate
diff --git a/test/cases/compile_errors/stage1/obj/main_function_with_bogus_args_type.zig b/test/cases/compile_errors/stage1/obj/main_function_with_bogus_args_type.zig
new file mode 100644
index 0000000000000000000000000000000000000000..5808ab90ecc7b10d2587e6186a9ab28ecc6ff88b
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/main_function_with_bogus_args_type.zig
@@ -0,0 +1,7 @@
+pub fn main(args: [][]bogus) !void {_ = args;}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:1:23: error: use of undeclared identifier 'bogus'
diff --git a/test/cases/compile_errors/stage1/obj/method_call_with_first_arg_type_primitive.zig b/test/cases/compile_errors/stage1/obj/method_call_with_first_arg_type_primitive.zig
new file mode 100644
index 0000000000000000000000000000000000000000..316be2d899f08ce8e1bb12e4e0dfc8550ddec941
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/method_call_with_first_arg_type_primitive.zig
@@ -0,0 +1,21 @@
+const Foo = struct {
+    x: i32,
+
+    fn init(x: i32) Foo {
+        return Foo {
+            .x = x,
+        };
+    }
+};
+
+export fn f() void {
+    const derp = Foo.init(3);
+
+    derp.init();
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:14:5: error: expected type 'i32', found 'Foo'
diff --git a/test/cases/compile_errors/stage1/obj/method_call_with_first_arg_type_wrong_container.zig b/test/cases/compile_errors/stage1/obj/method_call_with_first_arg_type_wrong_container.zig
new file mode 100644
index 0000000000000000000000000000000000000000..04ab89fb6ca76262d9b51f8b311196270071c296
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/method_call_with_first_arg_type_wrong_container.zig
@@ -0,0 +1,30 @@
+pub const List = struct {
+    len: usize,
+    allocator: *Allocator,
+
+    pub fn init(allocator: *Allocator) List {
+        return List {
+            .len = 0,
+            .allocator = allocator,
+        };
+    }
+};
+
+pub var global_allocator = Allocator {
+    .field = 1234,
+};
+
+pub const Allocator = struct {
+    field: i32,
+};
+
+export fn foo() void {
+    var x = List.init(&global_allocator);
+    x.init();
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:23:5: error: expected type '*Allocator', found '*List'
diff --git a/test/cases/compile_errors/stage1/obj/missing_boolean_switch_value.zig b/test/cases/compile_errors/stage1/obj/missing_boolean_switch_value.zig
new file mode 100644
index 0000000000000000000000000000000000000000..2e9d4b48ce3f0ced8088ab957f22e995fc170054
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/missing_boolean_switch_value.zig
@@ -0,0 +1,19 @@
+comptime {
+    const x = switch (true) {
+        true => false,
+    };
+    _ = x;
+}
+comptime {
+    const x = switch (true) {
+        false => true,
+    };
+    _ = x;
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:2:15: error: switch must handle all possibilities
+// tmp.zig:8:15: error: switch must handle all possibilities
diff --git a/test/cases/compile_errors/stage1/obj/missing_const_in_slice_with_nested_array_type.zig b/test/cases/compile_errors/stage1/obj/missing_const_in_slice_with_nested_array_type.zig
new file mode 100644
index 0000000000000000000000000000000000000000..af9d690d438316d9e3da093387302760c64aa9e7
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/missing_const_in_slice_with_nested_array_type.zig
@@ -0,0 +1,18 @@
+const Geo3DTex2D = struct { vertices: [][2]f32 };
+pub fn getGeo3DTex2D() Geo3DTex2D {
+    return Geo3DTex2D{
+        .vertices = [_][2]f32{
+            [_]f32{ -0.5, -0.5},
+        },
+    };
+}
+export fn entry() void {
+    var geo_data = getGeo3DTex2D();
+    _ = geo_data;
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:4:30: error: array literal requires address-of operator (&) to coerce to slice type '[][2]f32'
diff --git a/test/cases/compile_errors/stage1/obj/missing_else_clause.zig b/test/cases/compile_errors/stage1/obj/missing_else_clause.zig
new file mode 100644
index 0000000000000000000000000000000000000000..f331933437f2579377b6f3b29d607fa68787d5af
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/missing_else_clause.zig
@@ -0,0 +1,16 @@
+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); }
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:2:21: error: expected type 'i32', found 'void'
+// tmp.zig:6:15: error: incompatible types: 'i32' and 'void'
diff --git a/test/cases/compile_errors/stage1/obj/missing_field_in_struct_value_expression.zig b/test/cases/compile_errors/stage1/obj/missing_field_in_struct_value_expression.zig
new file mode 100644
index 0000000000000000000000000000000000000000..9eb4246c8f76fa40b7901040d43e321514a5b375
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/missing_field_in_struct_value_expression.zig
@@ -0,0 +1,20 @@
+const A = struct {
+    x : i32,
+    y : i32,
+    z : i32,
+};
+export fn f() void {
+    // we want the error on the '{' not the 'A' because
+    // the A could be a complicated expression
+    const a = A {
+        .z = 4,
+        .y = 2,
+    };
+    _ = a;
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:9:17: error: missing field: 'x'
diff --git a/test/cases/compile_errors/stage1/obj/missing_function_call_param.zig b/test/cases/compile_errors/stage1/obj/missing_function_call_param.zig
new file mode 100644
index 0000000000000000000000000000000000000000..9e08ed7140c6a50a6a19e79a42b1357a714958a4
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/missing_function_call_param.zig
@@ -0,0 +1,31 @@
+const Foo = struct {
+    a: i32,
+    b: i32,
+
+    fn member_a(foo: *const Foo) i32 {
+        return foo.a;
+    }
+    fn member_b(foo: *const Foo) i32 {
+        return foo.b;
+    }
+};
+
+const member_fn_type = @TypeOf(Foo.member_a);
+const members = [_]member_fn_type {
+    Foo.member_a,
+    Foo.member_b,
+};
+
+fn f(foo: *const Foo, index: usize) void {
+    const result = members[index]();
+    _ = foo;
+    _ = result;
+}
+
+export fn entry() usize { return @sizeOf(@TypeOf(f)); }
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:20:34: error: expected 1 argument(s), found 0
diff --git a/test/cases/compile_errors/stage1/obj/missing_function_name.zig b/test/cases/compile_errors/stage1/obj/missing_function_name.zig
new file mode 100644
index 0000000000000000000000000000000000000000..cd9a3ca7ee96c625ea7b43a0867a29d9fedd4bb7
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/missing_function_name.zig
@@ -0,0 +1,8 @@
+fn () void {}
+export fn entry() usize { return @sizeOf(@TypeOf(f)); }
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:1:1: error: missing function name
diff --git a/test/cases/compile_errors/stage1/obj/missing_param_name.zig b/test/cases/compile_errors/stage1/obj/missing_param_name.zig
new file mode 100644
index 0000000000000000000000000000000000000000..febb16d2cacc7adfb10ebc908e775c15128e2606
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/missing_param_name.zig
@@ -0,0 +1,8 @@
+fn f(i32) void {}
+export fn entry() usize { return @sizeOf(@TypeOf(f)); }
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:1:6: error: missing parameter name
diff --git a/test/cases/compile_errors/stage1/obj/missing_parameter_name_of_generic_function.zig b/test/cases/compile_errors/stage1/obj/missing_parameter_name_of_generic_function.zig
new file mode 100644
index 0000000000000000000000000000000000000000..041c0c4a47726ba9a806587c8b3fd7d1ae91cc1d
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/missing_parameter_name_of_generic_function.zig
@@ -0,0 +1,11 @@
+fn dump(anytype) void {}
+export fn entry() void {
+    var a: u8 = 9;
+    dump(a);
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:1:9: error: missing parameter name
diff --git a/test/cases/compile_errors/stage1/obj/missing_result_type_for_phi_node.zig b/test/cases/compile_errors/stage1/obj/missing_result_type_for_phi_node.zig
new file mode 100644
index 0000000000000000000000000000000000000000..33bc1d0d9c907934d0ba055d91b128e31bec9265
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/missing_result_type_for_phi_node.zig
@@ -0,0 +1,12 @@
+fn foo() !void {
+    return anyerror.Foo;
+}
+export fn entry() void {
+    foo() catch 0;
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:5:17: error: integer value 0 cannot be coerced to type 'void'
diff --git a/test/cases/compile_errors/stage1/obj/misspelled_type_with_pointer_only_reference.zig b/test/cases/compile_errors/stage1/obj/misspelled_type_with_pointer_only_reference.zig
new file mode 100644
index 0000000000000000000000000000000000000000..8e2055a829912c9d3b4d55c24f09027d3407f94e
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/misspelled_type_with_pointer_only_reference.zig
@@ -0,0 +1,37 @@
+const JasonHM = u8;
+const JasonList = *JsonNode;
+
+const JsonOA = union(enum) {
+    JSONArray: JsonList,
+    JSONObject: JasonHM,
+};
+
+const JsonType = union(enum) {
+    JSONNull: void,
+    JSONInteger: isize,
+    JSONDouble: f64,
+    JSONBool: bool,
+    JSONString: []u8,
+    JSONArray: void,
+    JSONObject: void,
+};
+
+pub const JsonNode = struct {
+    kind: JsonType,
+    jobject: ?JsonOA,
+};
+
+fn foo() 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)); }
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:5:16: error: use of undeclared identifier 'JsonList'
diff --git a/test/cases/compile_errors/stage1/obj/mod_assign_on_undefined_value.zig b/test/cases/compile_errors/stage1/obj/mod_assign_on_undefined_value.zig
new file mode 100644
index 0000000000000000000000000000000000000000..c127e256e8bd23f73517ed1dd5be34c20580a324
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/mod_assign_on_undefined_value.zig
@@ -0,0 +1,10 @@
+comptime {
+    var a: i64 = undefined;
+    a %= a;
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:3:5: error: use of undefined value here causes undefined behavior
diff --git a/test/cases/compile_errors/stage1/obj/mod_on_undefined_value.zig b/test/cases/compile_errors/stage1/obj/mod_on_undefined_value.zig
new file mode 100644
index 0000000000000000000000000000000000000000..8bd7774a4638148af6666ccca95c504195423e28
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/mod_on_undefined_value.zig
@@ -0,0 +1,10 @@
+comptime {
+    var a: i64 = undefined;
+    _ = a % a;
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:3:9: error: use of undefined value here causes undefined behavior
diff --git a/test/cases/compile_errors/stage1/obj/mul_overflow_in_function_evaluation.zig b/test/cases/compile_errors/stage1/obj/mul_overflow_in_function_evaluation.zig
new file mode 100644
index 0000000000000000000000000000000000000000..8209b33f94145dd11431f295f7c7fea999ad9316
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/mul_overflow_in_function_evaluation.zig
@@ -0,0 +1,12 @@
+const y = mul(300, 6000);
+fn mul(a: u16, b: u16) u16 {
+    return a * b;
+}
+
+export fn entry() usize { return @sizeOf(@TypeOf(y)); }
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:3:14: error: operation caused overflow
diff --git a/test/cases/compile_errors/stage1/obj/mult_assign_on_undefined_value.zig b/test/cases/compile_errors/stage1/obj/mult_assign_on_undefined_value.zig
new file mode 100644
index 0000000000000000000000000000000000000000..04040b975643bdefbc4045ab94a96991527f1871
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/mult_assign_on_undefined_value.zig
@@ -0,0 +1,10 @@
+comptime {
+    var a: i64 = undefined;
+    a *= a;
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:3:5: error: use of undefined value here causes undefined behavior
diff --git a/test/cases/compile_errors/stage1/obj/mult_on_undefined_value.zig b/test/cases/compile_errors/stage1/obj/mult_on_undefined_value.zig
new file mode 100644
index 0000000000000000000000000000000000000000..0dcd2b02f2d08afdee284ca4571bd5847ae97f74
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/mult_on_undefined_value.zig
@@ -0,0 +1,10 @@
+comptime {
+    var a: i64 = undefined;
+    _ = a * a;
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:3:9: error: use of undefined value here causes undefined behavior
diff --git a/test/cases/compile_errors/stage1/obj/mult_wrap_assign_on_undefined_value.zig b/test/cases/compile_errors/stage1/obj/mult_wrap_assign_on_undefined_value.zig
new file mode 100644
index 0000000000000000000000000000000000000000..db54af9f0b53687ac4e8c863efd40d61878b1080
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/mult_wrap_assign_on_undefined_value.zig
@@ -0,0 +1,10 @@
+comptime {
+    var a: i64 = undefined;
+    a *%= a;
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:3:5: error: use of undefined value here causes undefined behavior
diff --git a/test/cases/compile_errors/stage1/obj/mult_wrap_on_undefined_value.zig b/test/cases/compile_errors/stage1/obj/mult_wrap_on_undefined_value.zig
new file mode 100644
index 0000000000000000000000000000000000000000..9ad09f7e9306fc682e2a346f413040281999a378
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/mult_wrap_on_undefined_value.zig
@@ -0,0 +1,10 @@
+comptime {
+    var a: i64 = undefined;
+    _ = a *% a;
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:3:9: error: use of undefined value here causes undefined behavior
diff --git a/test/cases/compile_errors/stage1/obj/multiple_function_definitions.zig b/test/cases/compile_errors/stage1/obj/multiple_function_definitions.zig
new file mode 100644
index 0000000000000000000000000000000000000000..baa4a43048fccc340dd41de0f735a992fb1160aa
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/multiple_function_definitions.zig
@@ -0,0 +1,10 @@
+fn a() void {}
+fn a() void {}
+export fn entry() void { a(); }
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:2:1: error: redeclaration of 'a'
+// tmp.zig:1:1: note: other declaration here
diff --git a/test/cases/compile_errors/stage1/obj/negate_on_undefined_value.zig b/test/cases/compile_errors/stage1/obj/negate_on_undefined_value.zig
new file mode 100644
index 0000000000000000000000000000000000000000..f8d5f6128d48743bcacdcd267550e05d9903e203
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/negate_on_undefined_value.zig
@@ -0,0 +1,10 @@
+comptime {
+    var a: i64 = undefined;
+    _ = -a;
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:3:10: error: use of undefined value here causes undefined behavior
diff --git a/test/cases/compile_errors/stage1/obj/negate_wrap_on_undefined_value.zig b/test/cases/compile_errors/stage1/obj/negate_wrap_on_undefined_value.zig
new file mode 100644
index 0000000000000000000000000000000000000000..4ca32956de7e8bb4de3c877b8246bdd017d44394
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/negate_wrap_on_undefined_value.zig
@@ -0,0 +1,10 @@
+comptime {
+    var a: i64 = undefined;
+    _ = -%a;
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:3:11: error: use of undefined value here causes undefined behavior
diff --git a/test/cases/compile_errors/stage1/obj/negation_overflow_in_function_evaluation.zig b/test/cases/compile_errors/stage1/obj/negation_overflow_in_function_evaluation.zig
new file mode 100644
index 0000000000000000000000000000000000000000..f83e0de6ae33c50986f0ef06f063b4bd353ee35f
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/negation_overflow_in_function_evaluation.zig
@@ -0,0 +1,12 @@
+const y = neg(-128);
+fn neg(x: i8) i8 {
+    return -x;
+}
+
+export fn entry() usize { return @sizeOf(@TypeOf(y)); }
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:3:12: error: negation caused overflow
diff --git a/test/cases/compile_errors/stage1/obj/nested_error_set_mismatch.zig b/test/cases/compile_errors/stage1/obj/nested_error_set_mismatch.zig
new file mode 100644
index 0000000000000000000000000000000000000000..cd037635bc4cc8b5ccd35d8671645be45e8a2695
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/nested_error_set_mismatch.zig
@@ -0,0 +1,20 @@
+const NextError = error{NextError};
+const OtherError = error{OutOfMemory};
+
+export fn entry() void {
+    const a: ?NextError!i32 = foo();
+    _ = a;
+}
+
+fn foo() ?OtherError!i32 {
+    return null;
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:5:34: error: expected type '?NextError!i32', found '?OtherError!i32'
+// tmp.zig:5:34: note: optional type child 'OtherError!i32' cannot cast into optional type child 'NextError!i32'
+// tmp.zig:5:34: note: error set 'OtherError' cannot cast into error set 'NextError'
+// tmp.zig:2:26: note: 'error.OutOfMemory' not a member of destination error set
diff --git a/test/cases/compile_errors/stage1/obj/no_else_prong_on_switch_on_global_error_set.zig b/test/cases/compile_errors/stage1/obj/no_else_prong_on_switch_on_global_error_set.zig
new file mode 100644
index 0000000000000000000000000000000000000000..39f4399cafcb6c11ca997f115329ebb5fc8891b4
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/no_else_prong_on_switch_on_global_error_set.zig
@@ -0,0 +1,14 @@
+export fn entry() void {
+    foo(error.A);
+}
+fn foo(a: anyerror) void {
+    switch (a) {
+        error.A => {},
+    }
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:5:5: error: else prong required when switching on type 'anyerror'
diff --git a/test/cases/compile_errors/stage1/obj/noalias_on_non_pointer_param.zig b/test/cases/compile_errors/stage1/obj/noalias_on_non_pointer_param.zig
new file mode 100644
index 0000000000000000000000000000000000000000..ca84aca73f65615812281bf10695672c6cd61207
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/noalias_on_non_pointer_param.zig
@@ -0,0 +1,8 @@
+fn f(noalias x: i32) void { _ = x; }
+export fn entry() void { f(1234); }
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:1:6: error: noalias on non-pointer parameter
diff --git a/test/cases/compile_errors/stage1/obj/non-async_function_pointer_eventually_is_inferred_to_become_async.zig b/test/cases/compile_errors/stage1/obj/non-async_function_pointer_eventually_is_inferred_to_become_async.zig
new file mode 100644
index 0000000000000000000000000000000000000000..e18b4200289d80343d38cee2da9101f81916c0f5
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/non-async_function_pointer_eventually_is_inferred_to_become_async.zig
@@ -0,0 +1,15 @@
+export fn a() void {
+    var non_async_fn: fn () void = undefined;
+    non_async_fn = func;
+}
+fn func() void {
+    suspend {}
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:5:1: error: 'func' cannot be async
+// tmp.zig:3:20: note: required to be non-async here
+// tmp.zig:6:5: note: suspends here
diff --git a/test/cases/compile_errors/stage1/obj/non-const_expression_function_call_with_struct_return_value_outside_function.zig b/test/cases/compile_errors/stage1/obj/non-const_expression_function_call_with_struct_return_value_outside_function.zig
new file mode 100644
index 0000000000000000000000000000000000000000..25e33d1435425bb78f249de714ae593ce47d71e5
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/non-const_expression_function_call_with_struct_return_value_outside_function.zig
@@ -0,0 +1,17 @@
+const Foo = struct {
+    x: i32,
+};
+const a = get_it();
+fn get_it() Foo {
+    global_side_effect = true;
+    return Foo {.x = 13};
+}
+var global_side_effect = false;
+
+export fn entry() usize { return @sizeOf(@TypeOf(a)); }
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:6:26: error: unable to evaluate constant expression
diff --git a/test/cases/compile_errors/stage1/obj/non-const_expression_in_struct_literal_outside_function.zig b/test/cases/compile_errors/stage1/obj/non-const_expression_in_struct_literal_outside_function.zig
new file mode 100644
index 0000000000000000000000000000000000000000..46b94f1f96994ad0d1193ba9431c0d0fe13c0cb2
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/non-const_expression_in_struct_literal_outside_function.zig
@@ -0,0 +1,13 @@
+const Foo = struct {
+    x: i32,
+};
+const a = Foo {.x = get_it()};
+extern fn get_it() i32;
+
+export fn entry() usize { return @sizeOf(@TypeOf(a)); }
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:4:21: error: unable to evaluate constant expression
diff --git a/test/cases/compile_errors/stage1/obj/non-const_switch_number_literal.zig b/test/cases/compile_errors/stage1/obj/non-const_switch_number_literal.zig
new file mode 100644
index 0000000000000000000000000000000000000000..005db548ed7bbce6cbcedb79491ce64aa288d57a
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/non-const_switch_number_literal.zig
@@ -0,0 +1,17 @@
+export fn foo() void {
+    const x = switch (bar()) {
+        1, 2 => 1,
+        3, 4 => 2,
+        else => 3,
+    };
+    _ = x;
+}
+fn bar() i32 {
+    return 2;
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:5:17: error: cannot store runtime value in type 'comptime_int'
diff --git a/test/cases/compile_errors/stage1/obj/non-const_variables_of_things_that_require_const_variables.zig b/test/cases/compile_errors/stage1/obj/non-const_variables_of_things_that_require_const_variables.zig
new file mode 100644
index 0000000000000000000000000000000000000000..73ef29aa5472a7f619dfa18039665ec9c62ccc3e
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/non-const_variables_of_things_that_require_const_variables.zig
@@ -0,0 +1,51 @@
+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;
+}
+const Opaque = opaque {};
+const Foo = struct {
+    fn bar(self: *const Foo) void {_ = self;}
+};
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:2:4: error: variable of type '*const comptime_int' must be const or comptime
+// tmp.zig:6:4: error: variable of type '@Type(.Undefined)' must be const or comptime
+// tmp.zig:10:4: error: variable of type 'comptime_int' must be const or comptime
+// tmp.zig:10: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 'comptime_float' must be const or comptime
+// tmp.zig:14:4: note: to modify this variable at runtime, it must be given an explicit fixed-size number type
+// tmp.zig:18:4: error: variable of type '@Type(.Null)' must be const or comptime
+// tmp.zig:22:4: error: variable of type 'Opaque' not allowed
+// tmp.zig:26:4: error: variable of type 'type' must be const or comptime
+// tmp.zig:30:4: error: variable of type '(bound fn(*const Foo) void)' must be const or comptime
diff --git a/test/cases/compile_errors/stage1/obj/non-enum_tag_type_passed_to_union.zig b/test/cases/compile_errors/stage1/obj/non-enum_tag_type_passed_to_union.zig
new file mode 100644
index 0000000000000000000000000000000000000000..e188a3f819fd55ac18a82e8ed4b37d36e236898b
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/non-enum_tag_type_passed_to_union.zig
@@ -0,0 +1,13 @@
+const Foo = union(u32) {
+    A: i32,
+};
+export fn entry() void {
+    const x = @typeInfo(Foo).Union.tag_type.?;
+    _ = x;
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:1:19: error: expected enum tag type, found 'u32'
diff --git a/test/cases/compile_errors/stage1/obj/non-extern_function_with_var_args.zig b/test/cases/compile_errors/stage1/obj/non-extern_function_with_var_args.zig
new file mode 100644
index 0000000000000000000000000000000000000000..9e5463d451c92e4a36dfb568df084b9570cd7968
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/non-extern_function_with_var_args.zig
@@ -0,0 +1,10 @@
+fn foo(args: ...) void {}
+export fn entry() void {
+    foo();
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:1:14: error: expected type expression, found '...'
diff --git a/test/cases/compile_errors/stage1/obj/non-inline_for_loop_on_a_type_that_requires_comptime.zig b/test/cases/compile_errors/stage1/obj/non-inline_for_loop_on_a_type_that_requires_comptime.zig
new file mode 100644
index 0000000000000000000000000000000000000000..d2b4e28ea6d2afb7855ac2f1c035e253c2c07812
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/non-inline_for_loop_on_a_type_that_requires_comptime.zig
@@ -0,0 +1,14 @@
+const Foo = struct {
+    name: []const u8,
+    T: type,
+};
+export fn entry() void {
+    const xx: [2]Foo = undefined;
+    for (xx) |f| { _ = f;}
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:7:5: error: values of type 'Foo' must be comptime known, but index value is runtime known
diff --git a/test/cases/compile_errors/stage1/obj/non-integer_tag_type_to_automatic_union_enum.zig b/test/cases/compile_errors/stage1/obj/non-integer_tag_type_to_automatic_union_enum.zig
new file mode 100644
index 0000000000000000000000000000000000000000..41d5e1416353753c2d97c8c3e34b93c43d03b008
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/non-integer_tag_type_to_automatic_union_enum.zig
@@ -0,0 +1,13 @@
+const Foo = union(enum(f32)) {
+    A: i32,
+};
+export fn entry() void {
+    const x = @typeInfo(Foo).Union.tag_type.?;
+    _ = x;
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:1:24: error: expected integer tag type, found 'f32'
diff --git a/test/cases/compile_errors/stage1/obj/non-pure_function_returns_type.zig b/test/cases/compile_errors/stage1/obj/non-pure_function_returns_type.zig
new file mode 100644
index 0000000000000000000000000000000000000000..9d1c642273a5268eb34867626a7095a176a08a1a
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/non-pure_function_returns_type.zig
@@ -0,0 +1,24 @@
+var a: u32 = 0;
+pub fn List(comptime T: type) type {
+    a += 1;
+    return SmallList(T, 8);
+}
+
+pub fn SmallList(comptime T: type, comptime STATIC_SIZE: usize) type {
+    return struct {
+        items: []T,
+        length: usize,
+        prealloc_items: [STATIC_SIZE]T,
+    };
+}
+
+export fn function_with_return_type_type() void {
+    var list: List(i32) = undefined;
+    list.length = 10;
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:3:7: error: unable to evaluate constant expression
diff --git a/test/cases/compile_errors/stage1/obj/non_async_function_pointer_passed_to_asyncCall.zig b/test/cases/compile_errors/stage1/obj/non_async_function_pointer_passed_to_asyncCall.zig
new file mode 100644
index 0000000000000000000000000000000000000000..d8ab4087e0a32dd2971c7bc51e3b662d30281bb0
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/non_async_function_pointer_passed_to_asyncCall.zig
@@ -0,0 +1,12 @@
+export fn entry() void {
+    var ptr = afunc;
+    var bytes: [100]u8 align(16) = undefined;
+    _ = @asyncCall(&bytes, {}, ptr, .{});
+}
+fn afunc() void { }
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:4:32: error: expected async function, found 'fn() void'
diff --git a/test/cases/compile_errors/stage1/obj/non_compile_time_array_concatenation.zig b/test/cases/compile_errors/stage1/obj/non_compile_time_array_concatenation.zig
new file mode 100644
index 0000000000000000000000000000000000000000..e70e6daf324fe492660e3da37d4d4655820b2705
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/non_compile_time_array_concatenation.zig
@@ -0,0 +1,11 @@
+fn f() []u8 {
+    return s ++ "foo";
+}
+var s: [10]u8 = undefined;
+export fn entry() usize { return @sizeOf(@TypeOf(f)); }
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:2:12: error: unable to evaluate constant expression
diff --git a/test/cases/compile_errors/stage1/obj/non_constant_expression_in_array_size.zig b/test/cases/compile_errors/stage1/obj/non_constant_expression_in_array_size.zig
new file mode 100644
index 0000000000000000000000000000000000000000..a0cb8e8ce15cbe6eb7f23917a2ce84d9293853de
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/non_constant_expression_in_array_size.zig
@@ -0,0 +1,14 @@
+const Foo = struct {
+    y: [get()]u8,
+};
+var global_var: usize = 1;
+fn get() usize { return global_var; }
+
+export fn entry() usize { return @sizeOf(@TypeOf(Foo)); }
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:5:25: error: cannot store runtime value in compile time variable
+// tmp.zig:2:12: note: called from here
diff --git a/test/cases/compile_errors/stage1/obj/non_error_sets_used_in_merge_error_sets_operator.zig b/test/cases/compile_errors/stage1/obj/non_error_sets_used_in_merge_error_sets_operator.zig
new file mode 100644
index 0000000000000000000000000000000000000000..fc3431820c528574b508a57f984c9807edcb9d7d
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/non_error_sets_used_in_merge_error_sets_operator.zig
@@ -0,0 +1,17 @@
+export fn foo() void {
+    const Errors = u8 || u16;
+    _ = Errors;
+}
+export fn bar() void {
+    const Errors = error{} || u16;
+    _ = Errors;
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// 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:6:31: error: expected error set type, found type 'u16'
+// tmp.zig:6:28: note: `||` merges error sets; `or` performs boolean OR
diff --git a/test/cases/compile_errors/stage1/obj/non_float_passed_to_floatToInt.zig b/test/cases/compile_errors/stage1/obj/non_float_passed_to_floatToInt.zig
new file mode 100644
index 0000000000000000000000000000000000000000..c91025906a66cfaf91b1cb91072cbe9adbd49f75
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/non_float_passed_to_floatToInt.zig
@@ -0,0 +1,10 @@
+export fn entry() void {
+    const x = @floatToInt(i32, @as(i32, 54));
+    _ = x;
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:2:32: error: expected float type, found 'i32'
diff --git a/test/cases/compile_errors/stage1/obj/non_int_passed_to_intToFloat.zig b/test/cases/compile_errors/stage1/obj/non_int_passed_to_intToFloat.zig
new file mode 100644
index 0000000000000000000000000000000000000000..8f6acca51e083db32fbbb0a7bf1e90a1a974f069
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/non_int_passed_to_intToFloat.zig
@@ -0,0 +1,10 @@
+export fn entry() void {
+    const x = @intToFloat(f32, 1.1);
+    _ = x;
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:2:32: error: expected int type, found 'comptime_float'
diff --git a/test/cases/compile_errors/stage1/obj/non_pointer_given_to_ptrToInt.zig b/test/cases/compile_errors/stage1/obj/non_pointer_given_to_ptrToInt.zig
new file mode 100644
index 0000000000000000000000000000000000000000..7824c0f7964f68a586301350a515afc5cd4ac5c7
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/non_pointer_given_to_ptrToInt.zig
@@ -0,0 +1,9 @@
+export fn entry(x: i32) usize {
+    return @ptrToInt(x);
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:2:22: error: expected pointer, found 'i32'
diff --git a/test/cases/compile_errors/stage1/obj/normal_string_with_newline.zig b/test/cases/compile_errors/stage1/obj/normal_string_with_newline.zig
new file mode 100644
index 0000000000000000000000000000000000000000..f6c1d1b1b9b1a47bd26f4f544a35c5b8df64078f
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/normal_string_with_newline.zig
@@ -0,0 +1,9 @@
+const foo = "a
+b";
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:1:13: error: expected expression, found 'invalid bytes'
+// tmp.zig:1:15: note: invalid byte: '\n'
diff --git a/test/cases/compile_errors/stage1/obj/offsetOf-bad_field_name.zig b/test/cases/compile_errors/stage1/obj/offsetOf-bad_field_name.zig
new file mode 100644
index 0000000000000000000000000000000000000000..de5b82c22c6c68a7f8d835e421266f5327948859
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/offsetOf-bad_field_name.zig
@@ -0,0 +1,12 @@
+const Foo = struct {
+    derp: i32,
+};
+export fn foo() usize {
+    return @offsetOf(Foo, "a",);
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:5:27: error: struct 'Foo' has no field 'a'
diff --git a/test/cases/compile_errors/stage1/obj/offsetOf-non_struct.zig b/test/cases/compile_errors/stage1/obj/offsetOf-non_struct.zig
new file mode 100644
index 0000000000000000000000000000000000000000..15275b827b2fedb3a8c28f17d1957b38d8f013f5
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/offsetOf-non_struct.zig
@@ -0,0 +1,10 @@
+const Foo = i32;
+export fn foo() usize {
+    return @offsetOf(Foo, "a",);
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:3:22: error: expected struct type, found 'i32'
diff --git a/test/cases/compile_errors/stage1/obj/only_equality_binary_operator_allowed_for_error_sets.zig b/test/cases/compile_errors/stage1/obj/only_equality_binary_operator_allowed_for_error_sets.zig
new file mode 100644
index 0000000000000000000000000000000000000000..ff9c4d18a29ccbe9350b203f18ad284e572b9622
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/only_equality_binary_operator_allowed_for_error_sets.zig
@@ -0,0 +1,10 @@
+comptime {
+    const z = error.A > error.B;
+    _ = z;
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:2:23: error: operator not allowed for errors
diff --git a/test/cases/compile_errors/stage1/obj/opaque_type_with_field.zig b/test/cases/compile_errors/stage1/obj/opaque_type_with_field.zig
new file mode 100644
index 0000000000000000000000000000000000000000..0b87091de945bdf3b94fd987de5496ca4336d839
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/opaque_type_with_field.zig
@@ -0,0 +1,11 @@
+const Opaque = opaque { foo: i32 };
+export fn entry() void {
+    const foo: ?*Opaque = null;
+    _ = foo;
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:1:25: error: opaque types cannot have fields
diff --git a/test/cases/compile_errors/stage1/obj/optional_pointer_to_void_in_extern_struct.zig b/test/cases/compile_errors/stage1/obj/optional_pointer_to_void_in_extern_struct.zig
new file mode 100644
index 0000000000000000000000000000000000000000..552f672ad667b49a7320c60951c59bd77cea699c
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/optional_pointer_to_void_in_extern_struct.zig
@@ -0,0 +1,14 @@
+const Foo = extern struct {
+    x: ?*const void,
+};
+const Bar = extern struct {
+    foo: Foo,
+    y: i32,
+};
+export fn entry(bar: *Bar) void {_ = bar;}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:2:5: error: extern structs cannot contain fields of type '?*const void'
diff --git a/test/cases/compile_errors/stage1/obj/or_on_undefined_value.zig b/test/cases/compile_errors/stage1/obj/or_on_undefined_value.zig
new file mode 100644
index 0000000000000000000000000000000000000000..11e6c41deaa52764da050eea129327b3e530550e
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/or_on_undefined_value.zig
@@ -0,0 +1,10 @@
+comptime {
+    var a: bool = undefined;
+    _ = a or a;
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:3:9: error: use of undefined value here causes undefined behavior
diff --git a/test/cases/compile_errors/stage1/obj/orelse_on_undefined_value.zig b/test/cases/compile_errors/stage1/obj/orelse_on_undefined_value.zig
new file mode 100644
index 0000000000000000000000000000000000000000..3042c208eb3fbe2ad65e0ccb95d087147a78cfda
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/orelse_on_undefined_value.zig
@@ -0,0 +1,10 @@
+comptime {
+    var a: ?bool = undefined;
+    _ = a orelse false;
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:3:11: error: use of undefined value here causes undefined behavior
diff --git a/test/cases/compile_errors/stage1/obj/out_of_range_comptime_int_passed_to_floatToInt.zig b/test/cases/compile_errors/stage1/obj/out_of_range_comptime_int_passed_to_floatToInt.zig
new file mode 100644
index 0000000000000000000000000000000000000000..1a1dd541c91517a3289bb1b4a9d22bd339cef0ea
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/out_of_range_comptime_int_passed_to_floatToInt.zig
@@ -0,0 +1,10 @@
+export fn entry() void {
+    const x = @floatToInt(i8, 200);
+    _ = x;
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:2:31: error: integer value 200 cannot be coerced to type 'i8'
diff --git a/test/cases/compile_errors/stage1/obj/overflow_in_enum_value_allocation.zig b/test/cases/compile_errors/stage1/obj/overflow_in_enum_value_allocation.zig
new file mode 100644
index 0000000000000000000000000000000000000000..c5dc5c1dcf8f697da9504f335a5da40150a4fbc1
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/overflow_in_enum_value_allocation.zig
@@ -0,0 +1,14 @@
+const Moo = enum(u8) {
+    Last = 255,
+    Over,
+};
+pub fn main() void {
+  var y = Moo.Last;
+  _ = y;
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:3:5: error: enumeration value 256 too large for type 'u8'
diff --git a/test/cases/compile_errors/stage1/obj/packed_union_given_enum_tag_type.zig b/test/cases/compile_errors/stage1/obj/packed_union_given_enum_tag_type.zig
new file mode 100644
index 0000000000000000000000000000000000000000..fceb7af65c7c643273d0b490ef1884042296505e
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/packed_union_given_enum_tag_type.zig
@@ -0,0 +1,20 @@
+const Letter = enum {
+    A,
+    B,
+    C,
+};
+const Payload = packed union(Letter) {
+    A: i32,
+    B: f64,
+    C: bool,
+};
+export fn entry() void {
+    var a = Payload { .A = 1234 };
+    _ = a;
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:6:30: error: packed union does not support enum tag type
diff --git a/test/cases/compile_errors/stage1/obj/packed_union_with_automatic_layout_field.zig b/test/cases/compile_errors/stage1/obj/packed_union_with_automatic_layout_field.zig
new file mode 100644
index 0000000000000000000000000000000000000000..99ad6ca306aaeb666ef9b62cc4fb31c2f045486b
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/packed_union_with_automatic_layout_field.zig
@@ -0,0 +1,18 @@
+const Foo = struct {
+    a: u32,
+    b: f32,
+};
+const Payload = packed union {
+    A: Foo,
+    B: bool,
+};
+export fn entry() void {
+    var a = Payload { .B = true };
+    _ = a;
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:6:5: error: non-packed, non-extern struct 'Foo' not allowed in packed union; no guaranteed in-memory representation
diff --git a/test/cases/compile_errors/stage1/obj/panic_called_at_compile_time.zig b/test/cases/compile_errors/stage1/obj/panic_called_at_compile_time.zig
new file mode 100644
index 0000000000000000000000000000000000000000..7c169329130519f2c34c03d7040771a2f730b93f
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/panic_called_at_compile_time.zig
@@ -0,0 +1,11 @@
+export fn entry() void {
+    comptime {
+        @panic("aoeu",);
+    }
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:3:9: error: encountered @panic at compile-time
diff --git a/test/cases/compile_errors/stage1/obj/parameter_redeclaration.zig b/test/cases/compile_errors/stage1/obj/parameter_redeclaration.zig
new file mode 100644
index 0000000000000000000000000000000000000000..528eee8374400973c1e1b7dac9927050f2d32bf9
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/parameter_redeclaration.zig
@@ -0,0 +1,10 @@
+fn f(a : i32, a : i32) void {
+}
+export fn entry() void { f(1, 2); }
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:1:15: error: redeclaration of function parameter 'a'
+// tmp.zig:1:6: note: previous declaration here
diff --git a/test/cases/compile_errors/stage1/obj/parameter_shadowing_global.zig b/test/cases/compile_errors/stage1/obj/parameter_shadowing_global.zig
new file mode 100644
index 0000000000000000000000000000000000000000..ce417d7188a1ced348d7a53380acbf285ddb7f11
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/parameter_shadowing_global.zig
@@ -0,0 +1,12 @@
+const Foo = struct {};
+fn f(Foo: i32) void {}
+export fn entry() void {
+    f(1234);
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:2:6: error: local shadows declaration of 'Foo'
+// tmp.zig:1:1: note: declared here
diff --git a/test/cases/compile_errors/stage1/obj/pass_const_ptr_to_mutable_ptr_fn.zig b/test/cases/compile_errors/stage1/obj/pass_const_ptr_to_mutable_ptr_fn.zig
new file mode 100644
index 0000000000000000000000000000000000000000..3209bb73217fce1ed8f6c180ab99a703f5e22420
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/pass_const_ptr_to_mutable_ptr_fn.zig
@@ -0,0 +1,17 @@
+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;
+}
+
+export fn entry() usize { return @sizeOf(@TypeOf(foo)); }
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:4:19: error: expected type '*[]const u8', found '*const []const u8'
diff --git a/test/cases/compile_errors/stage1/obj/passing_a_not-aligned-enough_pointer_to_cmpxchg.zig b/test/cases/compile_errors/stage1/obj/passing_a_not-aligned-enough_pointer_to_cmpxchg.zig
new file mode 100644
index 0000000000000000000000000000000000000000..c1725f1ee85fa9d7236c598ce30e54fd06d73578
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/passing_a_not-aligned-enough_pointer_to_cmpxchg.zig
@@ -0,0 +1,12 @@
+const AtomicOrder = @import("std").builtin.AtomicOrder;
+export fn entry() bool {
+    var x: i32 align(1) = 1234;
+    while (!@cmpxchgWeak(i32, &x, 1234, 5678, AtomicOrder.SeqCst, AtomicOrder.SeqCst)) {}
+    return x == 5678;
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:4:32: error: expected type '*i32', found '*align(1) i32'
diff --git a/test/cases/compile_errors/stage1/obj/passing_an_under-aligned_function_pointer.zig b/test/cases/compile_errors/stage1/obj/passing_an_under-aligned_function_pointer.zig
new file mode 100644
index 0000000000000000000000000000000000000000..d67bd42a72909fc074b84ed9de4f197ae388b93f
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/passing_an_under-aligned_function_pointer.zig
@@ -0,0 +1,13 @@
+export fn entry() void {
+    testImplicitlyDecreaseFnAlign(alignedSmall, 1234);
+}
+fn testImplicitlyDecreaseFnAlign(ptr: fn () align(8) i32, answer: i32) void {
+    if (ptr() != answer) unreachable;
+}
+fn alignedSmall() align(4) i32 { return 1234; }
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:2:35: error: expected type 'fn() align(8) i32', found 'fn() align(4) i32'
diff --git a/test/cases/compile_errors/stage1/obj/peer_cast_then_implicit_cast_const_pointer_to_mutable_C_pointer.zig b/test/cases/compile_errors/stage1/obj/peer_cast_then_implicit_cast_const_pointer_to_mutable_C_pointer.zig
new file mode 100644
index 0000000000000000000000000000000000000000..7d18e760c3045f33062f812bbc86328ec736dfc8
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/peer_cast_then_implicit_cast_const_pointer_to_mutable_C_pointer.zig
@@ -0,0 +1,11 @@
+export fn func() void {
+    var strValue: [*c]u8 = undefined;
+    strValue = strValue orelse "";
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:3:32: error: expected type '[*c]u8', found '*const [0:0]u8'
+// tmp.zig:3:32: note: cast discards const qualifier
diff --git a/test/cases/compile_errors/stage1/obj/pointer_arithmetic_on_pointer-to-array.zig b/test/cases/compile_errors/stage1/obj/pointer_arithmetic_on_pointer-to-array.zig
new file mode 100644
index 0000000000000000000000000000000000000000..6542aa69687b243b695ff0344045f0f79097d16e
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/pointer_arithmetic_on_pointer-to-array.zig
@@ -0,0 +1,12 @@
+export fn foo() void {
+    var x: [10]u8 = undefined;
+    var y = &x;
+    var z = y + 1;
+    _ = z;
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:4:17: error: integer value 1 cannot be coerced to type '*[10]u8'
diff --git a/test/cases/compile_errors/stage1/obj/pointer_attributes_checked_when_coercing_pointer_to_anon_literal.zig b/test/cases/compile_errors/stage1/obj/pointer_attributes_checked_when_coercing_pointer_to_anon_literal.zig
new file mode 100644
index 0000000000000000000000000000000000000000..8456c8afcb245ed30253136af8c48fc1d22a8029
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/pointer_attributes_checked_when_coercing_pointer_to_anon_literal.zig
@@ -0,0 +1,24 @@
+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;
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:2:31: error: cannot cast pointer to array literal to slice type '[][]const u8'
+// tmp.zig:2:31: note: cast discards const qualifier
+// tmp.zig:6:33: error: cannot cast pointer to array literal to '*[2][]const u8'
+// tmp.zig:6:33: note: cast discards const qualifier
+// tmp.zig:11:21: error: expected type '*S', found '*const struct:11:21'
+// tmp.zig:11:21: note: cast discards const qualifier
diff --git a/test/cases/compile_errors/stage1/obj/pointer_to_noreturn.zig b/test/cases/compile_errors/stage1/obj/pointer_to_noreturn.zig
new file mode 100644
index 0000000000000000000000000000000000000000..5afcaacaad100e896435d3ae415b11a0b27de036
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/pointer_to_noreturn.zig
@@ -0,0 +1,8 @@
+fn a() *noreturn {}
+export fn entry() void { _ = a(); }
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:1:9: error: pointer to noreturn not allowed
diff --git a/test/cases/compile_errors/stage1/obj/popCount-non-integer.zig b/test/cases/compile_errors/stage1/obj/popCount-non-integer.zig
new file mode 100644
index 0000000000000000000000000000000000000000..a58a98faa336f69afd3229e41055310ef973df47
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/popCount-non-integer.zig
@@ -0,0 +1,9 @@
+export fn entry(x: f32) u32 {
+    return @popCount(f32, x);
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:2:22: error: expected integer type, found 'f32'
diff --git a/test/cases/compile_errors/stage1/obj/prevent_bad_implicit_casting_of_anyframe_types.zig b/test/cases/compile_errors/stage1/obj/prevent_bad_implicit_casting_of_anyframe_types.zig
new file mode 100644
index 0000000000000000000000000000000000000000..2e21d45c124d65f15c316631a4c2202cb42d6c4b
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/prevent_bad_implicit_casting_of_anyframe_types.zig
@@ -0,0 +1,24 @@
+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 {}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:3:28: error: expected type 'anyframe->i32', found 'anyframe'
+// tmp.zig:8:28: error: expected type 'anyframe->i32', found 'i32'
+// tmp.zig:13:29: error: expected type 'anyframe->i32', found '*@Frame(func)'
diff --git a/test/cases/compile_errors/stage1/obj/primitives_take_precedence_over_declarations.zig b/test/cases/compile_errors/stage1/obj/primitives_take_precedence_over_declarations.zig
new file mode 100644
index 0000000000000000000000000000000000000000..6f6107e88c9829ab12c192c029d9d6d6aed356f8
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/primitives_take_precedence_over_declarations.zig
@@ -0,0 +1,11 @@
+const @"u8" = u16;
+export fn entry() void {
+    const a: u8 = 300;
+    _ = a;
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:3:19: error: integer value 300 cannot be coerced to type 'u8'
diff --git a/test/cases/compile_errors/stage1/obj/ptrCast_a_0_bit_type_to_a_non-_0_bit_type.zig b/test/cases/compile_errors/stage1/obj/ptrCast_a_0_bit_type_to_a_non-_0_bit_type.zig
new file mode 100644
index 0000000000000000000000000000000000000000..2fc30d4a325a242083d2dc90810f6a0b2fd6e847
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/ptrCast_a_0_bit_type_to_a_non-_0_bit_type.zig
@@ -0,0 +1,13 @@
+export fn entry() bool {
+    var x: u0 = 0;
+    const p = @ptrCast(?*u0, &x);
+    return p == null;
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:3:15: error: '*u0' and '?*u0' do not have the same in-memory representation
+// tmp.zig:3:31: note: '*u0' has no in-memory bits
+// tmp.zig:3:24: note: '?*u0' has in-memory bits
diff --git a/test/cases/compile_errors/stage1/obj/ptrCast_discards_const_qualifier.zig b/test/cases/compile_errors/stage1/obj/ptrCast_discards_const_qualifier.zig
new file mode 100644
index 0000000000000000000000000000000000000000..1a90ff73f8836bd8ce77ab6cacd4a63c84a490c3
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/ptrCast_discards_const_qualifier.zig
@@ -0,0 +1,11 @@
+export fn entry() void {
+    const x: i32 = 1234;
+    const y = @ptrCast(*i32, &x);
+    _ = y;
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:3:15: error: cast discards const qualifier
diff --git a/test/cases/compile_errors/stage1/obj/ptrToInt_0_to_non_optional_pointer.zig b/test/cases/compile_errors/stage1/obj/ptrToInt_0_to_non_optional_pointer.zig
new file mode 100644
index 0000000000000000000000000000000000000000..b8a5d1b0aa48ce8e293fd60d4509875bc82ba817
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/ptrToInt_0_to_non_optional_pointer.zig
@@ -0,0 +1,10 @@
+export fn entry() void {
+    var b = @intToPtr(*i32, 0);
+    _ = b;
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:2:13: error: pointer type '*i32' does not allow address zero
diff --git a/test/cases/compile_errors/stage1/obj/ptrToInt_on_void.zig b/test/cases/compile_errors/stage1/obj/ptrToInt_on_void.zig
new file mode 100644
index 0000000000000000000000000000000000000000..5012be65e076eb0a161fe8e90515df84d17231ca
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/ptrToInt_on_void.zig
@@ -0,0 +1,9 @@
+export fn entry() bool {
+    return @ptrToInt(&{}) == @ptrToInt(&{});
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:2:23: error: pointer to size 0 type has no address
diff --git a/test/cases/compile_errors/stage1/obj/ptrcast_to_non-pointer.zig b/test/cases/compile_errors/stage1/obj/ptrcast_to_non-pointer.zig
new file mode 100644
index 0000000000000000000000000000000000000000..7e9e9a99b719b2ff978802aec36a08a2e30138bd
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/ptrcast_to_non-pointer.zig
@@ -0,0 +1,9 @@
+export fn entry(a: *i32) usize {
+    return @ptrCast(usize, a);
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:2:21: error: expected pointer, found 'usize'
diff --git a/test/cases/compile_errors/stage1/obj/range_operator_in_switch_used_on_error_set.zig b/test/cases/compile_errors/stage1/obj/range_operator_in_switch_used_on_error_set.zig
new file mode 100644
index 0000000000000000000000000000000000000000..8108f429792605faa1b8aa85737004b6e71494bb
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/range_operator_in_switch_used_on_error_set.zig
@@ -0,0 +1,19 @@
+export fn entry() void {
+    try foo(452) catch |err| switch (err) {
+        error.A ... error.B => {},
+        else => {},
+    };
+}
+fn foo(x: i32) !void {
+    switch (x) {
+        0 ... 10 => return error.Foo,
+        11 ... 20 => return error.Bar,
+        else => {},
+    }
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:3:17: error: operator not allowed for errors
diff --git a/test/cases/compile_errors/stage1/obj/reading_past_end_of_pointer_casted_array.zig b/test/cases/compile_errors/stage1/obj/reading_past_end_of_pointer_casted_array.zig
new file mode 100644
index 0000000000000000000000000000000000000000..cece3345c3f17abc3525eeed0733d57d1006ea21
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/reading_past_end_of_pointer_casted_array.zig
@@ -0,0 +1,13 @@
+comptime {
+    const array: [4]u8 = "aoeu".*;
+    const sub_array = array[1..];
+    const int_ptr = @ptrCast(*const u24, sub_array);
+    const deref = int_ptr.*;
+    _ = deref;
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:5:26: error: attempt to read 4 bytes from [4]u8 at index 1 which is 3 bytes
diff --git a/test/cases/compile_errors/stage1/obj/recursive_inferred_error_set.zig b/test/cases/compile_errors/stage1/obj/recursive_inferred_error_set.zig
new file mode 100644
index 0000000000000000000000000000000000000000..89a2a54cfae3a8b2f56aaefca83ccfefbe21c570
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/recursive_inferred_error_set.zig
@@ -0,0 +1,12 @@
+export fn entry() void {
+    foo() catch unreachable;
+}
+fn foo() !void {
+    try foo();
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// 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
diff --git a/test/cases/compile_errors/stage1/obj/redefinition_of_enums.zig b/test/cases/compile_errors/stage1/obj/redefinition_of_enums.zig
new file mode 100644
index 0000000000000000000000000000000000000000..a95eb88935a25fc36e4939019c826e96622dbdb3
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/redefinition_of_enums.zig
@@ -0,0 +1,9 @@
+const A = enum {x};
+const A = enum {x};
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:2:1: error: redeclaration of 'A'
+// tmp.zig:1:1: note: other declaration here
diff --git a/test/cases/compile_errors/stage1/obj/redefinition_of_global_variables.zig b/test/cases/compile_errors/stage1/obj/redefinition_of_global_variables.zig
new file mode 100644
index 0000000000000000000000000000000000000000..3651946ffefa9fb3c97a39763158b3d11a9f6e6a
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/redefinition_of_global_variables.zig
@@ -0,0 +1,9 @@
+var a : i32 = 1;
+var a : i32 = 2;
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:2:1: error: redeclaration of 'a'
+// tmp.zig:1:1: note: other declaration here
diff --git a/test/cases/compile_errors/stage1/obj/redefinition_of_struct.zig b/test/cases/compile_errors/stage1/obj/redefinition_of_struct.zig
new file mode 100644
index 0000000000000000000000000000000000000000..8367a05e43729ca57acd871dd2451a7a91eb5f3a
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/redefinition_of_struct.zig
@@ -0,0 +1,9 @@
+const A = struct { x : i32, };
+const A = struct { y : i32, };
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:2:1: error: redeclaration of 'A'
+// tmp.zig:1:1: note: other declaration here
diff --git a/test/cases/compile_errors/stage1/obj/refer_to_the_type_of_a_generic_function.zig b/test/cases/compile_errors/stage1/obj/refer_to_the_type_of_a_generic_function.zig
new file mode 100644
index 0000000000000000000000000000000000000000..99ab1da8a3c5c8969af94af66b36f82606f5974e
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/refer_to_the_type_of_a_generic_function.zig
@@ -0,0 +1,11 @@
+export fn entry() void {
+    const Func = fn (type) void;
+    const f: Func = undefined;
+    f(i32);
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:4:5: error: use of undefined value here causes undefined behavior
diff --git a/test/cases/compile_errors/stage1/obj/referring_to_a_struct_that_is_invalid.zig b/test/cases/compile_errors/stage1/obj/referring_to_a_struct_that_is_invalid.zig
new file mode 100644
index 0000000000000000000000000000000000000000..433650cddbb2913b6548105972d3526238eea913
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/referring_to_a_struct_that_is_invalid.zig
@@ -0,0 +1,17 @@
+const UsbDeviceRequest = struct {
+    Type: u8,
+};
+
+export fn foo() void {
+    comptime assert(@sizeOf(UsbDeviceRequest) == 0x8);
+}
+
+fn assert(ok: bool) void {
+    if (!ok) unreachable;
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:10:14: error: reached unreachable code
diff --git a/test/cases/compile_errors/stage1/obj/regression_test_2980_base_type_u32_is_not_type_checked_properly_when_assigning_a_value_within_a_struct.zig b/test/cases/compile_errors/stage1/obj/regression_test_2980_base_type_u32_is_not_type_checked_properly_when_assigning_a_value_within_a_struct.zig
new file mode 100644
index 0000000000000000000000000000000000000000..8be44fbe054f85087c7731c351b1817ff7392ab0
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/regression_test_2980_base_type_u32_is_not_type_checked_properly_when_assigning_a_value_within_a_struct.zig
@@ -0,0 +1,21 @@
+const Foo = struct {
+    ptr: ?*usize,
+    uval: u32,
+};
+fn get_uval(x: u32) !u32 {
+    _ = x;
+    return error.NotFound;
+}
+export fn entry() void {
+    const afoo = Foo{
+        .ptr = null,
+        .uval = get_uval(42),
+    };
+    _ = afoo;
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:12:25: error: cannot convert error union to payload type. consider using `try`, `catch`, or `if`. expected type 'u32', found '@typeInfo(@typeInfo(@TypeOf(get_uval)).Fn.return_type.?).ErrorUnion.error_set!u32'
diff --git a/test/cases/compile_errors/stage1/obj/reify_type.Fn_with_is_generic_true.zig b/test/cases/compile_errors/stage1/obj/reify_type.Fn_with_is_generic_true.zig
new file mode 100644
index 0000000000000000000000000000000000000000..f2849b5eb486fc09843e554ceaf891dbd47e4f04
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/reify_type.Fn_with_is_generic_true.zig
@@ -0,0 +1,17 @@
+const Foo = @Type(.{
+    .Fn = .{
+        .calling_convention = .Unspecified,
+        .alignment = 0,
+        .is_generic = true,
+        .is_var_args = false,
+        .return_type = u0,
+        .args = &.{},
+    },
+});
+comptime { _ = Foo; }
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:1:20: error: Type.Fn.is_generic must be false for @Type
diff --git a/test/cases/compile_errors/stage1/obj/reify_type.Fn_with_is_var_args_true_and_non-C_callconv.zig b/test/cases/compile_errors/stage1/obj/reify_type.Fn_with_is_var_args_true_and_non-C_callconv.zig
new file mode 100644
index 0000000000000000000000000000000000000000..4d449e9eb9e78b92c65f361b19640c805d3dbdc0
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/reify_type.Fn_with_is_var_args_true_and_non-C_callconv.zig
@@ -0,0 +1,17 @@
+const Foo = @Type(.{
+    .Fn = .{
+        .calling_convention = .Unspecified,
+        .alignment = 0,
+        .is_generic = false,
+        .is_var_args = true,
+        .return_type = u0,
+        .args = &.{},
+    },
+});
+comptime { _ = Foo; }
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:1:20: error: varargs functions must have C calling convention
diff --git a/test/cases/compile_errors/stage1/obj/reify_type.Fn_with_return_type_null.zig b/test/cases/compile_errors/stage1/obj/reify_type.Fn_with_return_type_null.zig
new file mode 100644
index 0000000000000000000000000000000000000000..98cbc37d41d44d86bd7e571fb7cab8fee07cbca2
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/reify_type.Fn_with_return_type_null.zig
@@ -0,0 +1,17 @@
+const Foo = @Type(.{
+    .Fn = .{
+        .calling_convention = .Unspecified,
+        .alignment = 0,
+        .is_generic = false,
+        .is_var_args = false,
+        .return_type = null,
+        .args = &.{},
+    },
+});
+comptime { _ = Foo; }
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:1:20: error: Type.Fn.return_type must be non-null for @Type
diff --git a/test/cases/compile_errors/stage1/obj/reify_type.Pointer_with_invalid_address_space.zig b/test/cases/compile_errors/stage1/obj/reify_type.Pointer_with_invalid_address_space.zig
new file mode 100644
index 0000000000000000000000000000000000000000..1ca97ce2505eba7d621ace7737485dc70434c79e
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/reify_type.Pointer_with_invalid_address_space.zig
@@ -0,0 +1,18 @@
+export fn entry() void {
+    _ = @Type(.{ .Pointer = .{
+        .size = .One,
+        .is_const = false,
+        .is_volatile = false,
+        .alignment = 1,
+        .address_space = .gs,
+        .child = u8,
+        .is_allowzero = false,
+        .sentinel = null,
+    }});
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:2:16: error: address space 'gs' not available in stage 1 compiler, must be .generic
diff --git a/test/cases/compile_errors/stage1/obj/reify_type_for_exhaustive_enum_with_non-integer_tag_type.zig b/test/cases/compile_errors/stage1/obj/reify_type_for_exhaustive_enum_with_non-integer_tag_type.zig
new file mode 100644
index 0000000000000000000000000000000000000000..56d05578be1173d6504127707635c88fc9be0982
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/reify_type_for_exhaustive_enum_with_non-integer_tag_type.zig
@@ -0,0 +1,18 @@
+const Tag = @Type(.{
+    .Enum = .{
+        .layout = .Auto,
+        .tag_type = bool,
+        .fields = &.{},
+        .decls = &.{},
+        .is_exhaustive = false,
+    },
+});
+export fn entry() void {
+    _ = @intToEnum(Tag, 0);
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:1:20: error: Type.Enum.tag_type must be an integer type, not 'bool'
diff --git a/test/cases/compile_errors/stage1/obj/reify_type_for_exhaustive_enum_with_undefined_tag_type.zig b/test/cases/compile_errors/stage1/obj/reify_type_for_exhaustive_enum_with_undefined_tag_type.zig
new file mode 100644
index 0000000000000000000000000000000000000000..e6454d2ee5a8e71acca500edc3af9278d18db9f6
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/reify_type_for_exhaustive_enum_with_undefined_tag_type.zig
@@ -0,0 +1,18 @@
+const Tag = @Type(.{
+    .Enum = .{
+        .layout = .Auto,
+        .tag_type = undefined,
+        .fields = &.{},
+        .decls = &.{},
+        .is_exhaustive = false,
+    },
+});
+export fn entry() void {
+    _ = @intToEnum(Tag, 0);
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:1:20: error: use of undefined value here causes undefined behavior
diff --git a/test/cases/compile_errors/stage1/obj/reify_type_for_exhaustive_enum_with_zero_fields.zig b/test/cases/compile_errors/stage1/obj/reify_type_for_exhaustive_enum_with_zero_fields.zig
new file mode 100644
index 0000000000000000000000000000000000000000..d3ce70c1b0ab286279f79727d6db6cf41a2e929f
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/reify_type_for_exhaustive_enum_with_zero_fields.zig
@@ -0,0 +1,18 @@
+const Tag = @Type(.{
+    .Enum = .{
+        .layout = .Auto,
+        .tag_type = u1,
+        .fields = &.{},
+        .decls = &.{},
+        .is_exhaustive = true,
+    },
+});
+export fn entry() void {
+    _ = @intToEnum(Tag, 0);
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:1:20: error: enums must have 1 or more fields
diff --git a/test/cases/compile_errors/stage1/obj/reify_type_for_tagged_union_with_extra_enum_field.zig b/test/cases/compile_errors/stage1/obj/reify_type_for_tagged_union_with_extra_enum_field.zig
new file mode 100644
index 0000000000000000000000000000000000000000..0c56cb91ea3f20c2a2febf2e06583a097b2456ae
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/reify_type_for_tagged_union_with_extra_enum_field.zig
@@ -0,0 +1,34 @@
+const Tag = @Type(.{
+    .Enum = .{
+        .layout = .Auto,
+        .tag_type = u2,
+        .fields = &.{
+            .{ .name = "signed", .value = 0 },
+            .{ .name = "unsigned", .value = 1 },
+            .{ .name = "arst", .value = 2 },
+        },
+        .decls = &.{},
+        .is_exhaustive = true,
+    },
+});
+const Tagged = @Type(.{
+    .Union = .{
+        .layout = .Auto,
+        .tag_type = Tag,
+        .fields = &.{
+            .{ .name = "signed", .field_type = i32, .alignment = @alignOf(i32) },
+            .{ .name = "unsigned", .field_type = u32, .alignment = @alignOf(u32) },
+        },
+        .decls = &.{},
+    },
+});
+export fn entry() void {
+    var tagged = Tagged{ .signed = -1 };
+    tagged = .{ .unsigned = 1 };
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:14:23: error: enum field missing: 'arst'
diff --git a/test/cases/compile_errors/stage1/obj/reify_type_for_tagged_union_with_extra_union_field.zig b/test/cases/compile_errors/stage1/obj/reify_type_for_tagged_union_with_extra_union_field.zig
new file mode 100644
index 0000000000000000000000000000000000000000..63cf1f178e26db73e4563c161b8ecfdd7655f164
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/reify_type_for_tagged_union_with_extra_union_field.zig
@@ -0,0 +1,35 @@
+const Tag = @Type(.{
+    .Enum = .{
+        .layout = .Auto,
+        .tag_type = u1,
+        .fields = &.{
+            .{ .name = "signed", .value = 0 },
+            .{ .name = "unsigned", .value = 1 },
+        },
+        .decls = &.{},
+        .is_exhaustive = true,
+    },
+});
+const Tagged = @Type(.{
+    .Union = .{
+        .layout = .Auto,
+        .tag_type = Tag,
+        .fields = &.{
+            .{ .name = "signed", .field_type = i32, .alignment = @alignOf(i32) },
+            .{ .name = "unsigned", .field_type = u32, .alignment = @alignOf(u32) },
+            .{ .name = "arst", .field_type = f32, .alignment = @alignOf(f32) },
+        },
+        .decls = &.{},
+    },
+});
+export fn entry() void {
+    var tagged = Tagged{ .signed = -1 };
+    tagged = .{ .unsigned = 1 };
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:13:23: error: enum field not found: 'arst'
+// tmp.zig:1:20: note: enum declared here
diff --git a/test/cases/compile_errors/stage1/obj/reify_type_for_union_with_opaque_field.zig b/test/cases/compile_errors/stage1/obj/reify_type_for_union_with_opaque_field.zig
new file mode 100644
index 0000000000000000000000000000000000000000..d3f4f6da4b80e3b69643f5b215ab8f8c224904b0
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/reify_type_for_union_with_opaque_field.zig
@@ -0,0 +1,19 @@
+const Untagged = @Type(.{
+    .Union = .{
+        .layout = .Auto,
+        .tag_type = null,
+        .fields = &.{
+            .{ .name = "foo", .field_type = opaque {}, .alignment = 1 },
+        },
+        .decls = &.{},
+    },
+});
+export fn entry() void {
+    _ = Untagged{};
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:1:25: error: opaque types have unknown size and therefore cannot be directly embedded in unions
diff --git a/test/cases/compile_errors/stage1/obj/reify_type_for_union_with_zero_fields.zig b/test/cases/compile_errors/stage1/obj/reify_type_for_union_with_zero_fields.zig
new file mode 100644
index 0000000000000000000000000000000000000000..578f902697597d364a9fdd242afd66890d004ec5
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/reify_type_for_union_with_zero_fields.zig
@@ -0,0 +1,17 @@
+const Untagged = @Type(.{
+    .Union = .{
+        .layout = .Auto,
+        .tag_type = null,
+        .fields = &.{},
+        .decls = &.{},
+    },
+});
+export fn entry() void {
+    _ = Untagged{};
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:1:25: error: unions must have 1 or more fields
diff --git a/test/cases/compile_errors/stage1/obj/reify_type_union_payload_is_undefined.zig b/test/cases/compile_errors/stage1/obj/reify_type_union_payload_is_undefined.zig
new file mode 100644
index 0000000000000000000000000000000000000000..47be31c71142271c9022c53aeab4a3e1c8e523b8
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/reify_type_union_payload_is_undefined.zig
@@ -0,0 +1,10 @@
+const Foo = @Type(.{
+    .Struct = undefined,
+});
+comptime { _ = Foo; }
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:1:20: error: use of undefined value here causes undefined behavior
diff --git a/test/cases/compile_errors/stage1/obj/reify_type_with_Type.Int.zig b/test/cases/compile_errors/stage1/obj/reify_type_with_Type.Int.zig
new file mode 100644
index 0000000000000000000000000000000000000000..116bd86e0f229e17e8bf4a8a68c66dbeec1b81ba
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/reify_type_with_Type.Int.zig
@@ -0,0 +1,13 @@
+const builtin = @import("std").builtin;
+export fn entry() void {
+    _ = @Type(builtin.Type.Int{
+        .signedness = .signed,
+        .bits = 8,
+    });
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:3:31: error: expected type 'std.builtin.Type', found 'std.builtin.Type.Int'
diff --git a/test/cases/compile_errors/stage1/obj/reify_type_with_non-constant_expression.zig b/test/cases/compile_errors/stage1/obj/reify_type_with_non-constant_expression.zig
new file mode 100644
index 0000000000000000000000000000000000000000..7eec6b395a81a8972f70c6d6295821bc72d510f4
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/reify_type_with_non-constant_expression.zig
@@ -0,0 +1,11 @@
+const builtin = @import("std").builtin;
+var globalTypeInfo : builtin.Type = undefined;
+export fn entry() void {
+    _ = @Type(globalTypeInfo);
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:4:15: error: unable to evaluate constant expression
diff --git a/test/cases/compile_errors/stage1/obj/reify_type_with_undefined.zig b/test/cases/compile_errors/stage1/obj/reify_type_with_undefined.zig
new file mode 100644
index 0000000000000000000000000000000000000000..1de93ccdf62d041945319c5a8626af4eea39c2f2
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/reify_type_with_undefined.zig
@@ -0,0 +1,20 @@
+comptime {
+    _ = @Type(.{ .Array = .{ .len = 0, .child = u8, .sentinel = undefined } });
+}
+comptime {
+    _ = @Type(.{
+        .Struct = .{
+            .fields = undefined,
+            .decls = undefined,
+            .is_tuple = false,
+            .layout = .Auto,
+        },
+    });
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:2:16: error: use of undefined value here causes undefined behavior
+// tmp.zig:5:16: error: use of undefined value here causes undefined behavior
diff --git a/test/cases/compile_errors/stage1/obj/result_location_incompatibility_mismatching_handle_is_ptr.zig b/test/cases/compile_errors/stage1/obj/result_location_incompatibility_mismatching_handle_is_ptr.zig
new file mode 100644
index 0000000000000000000000000000000000000000..18dd6382fcb6f871f637f3ce749a3d1853531882
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/result_location_incompatibility_mismatching_handle_is_ptr.zig
@@ -0,0 +1,18 @@
+export fn entry() void {
+    var damn = Container{
+        .not_optional = getOptional(),
+    };
+    _ = damn;
+}
+pub fn getOptional() ?i32 {
+    return 0;
+}
+pub const Container = struct {
+    not_optional: i32,
+};
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:3:36: error: cannot convert optional to payload type. consider using `.?`, `orelse`, or `if`. expected type 'i32', found '?i32'
diff --git a/test/cases/compile_errors/stage1/obj/result_location_incompatibility_mismatching_handle_is_ptr_generic_call.zig b/test/cases/compile_errors/stage1/obj/result_location_incompatibility_mismatching_handle_is_ptr_generic_call.zig
new file mode 100644
index 0000000000000000000000000000000000000000..75811c58e1e7d118392426a29410b4fe6f770b9b
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/result_location_incompatibility_mismatching_handle_is_ptr_generic_call.zig
@@ -0,0 +1,18 @@
+export fn entry() void {
+    var damn = Container{
+        .not_optional = getOptional(i32),
+    };
+    _ = damn;
+}
+pub fn getOptional(comptime T: type) ?T {
+    return 0;
+}
+pub const Container = struct {
+    not_optional: i32,
+};
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:3:36: error: cannot convert optional to payload type. consider using `.?`, `orelse`, or `if`. expected type 'i32', found '?i32'
diff --git a/test/cases/compile_errors/stage1/obj/return_from_defer_expression.zig b/test/cases/compile_errors/stage1/obj/return_from_defer_expression.zig
new file mode 100644
index 0000000000000000000000000000000000000000..cbe9542176d01eff318e8eda739dc9e7424e8c11
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/return_from_defer_expression.zig
@@ -0,0 +1,21 @@
+pub fn testTrickyDefer() !void {
+    defer canFail() catch {};
+
+    defer try canFail();
+
+    const a = maybeInt() orelse return;
+}
+
+fn canFail() anyerror!void { }
+
+pub fn maybeInt() ?i32 {
+    return 0;
+}
+
+export fn entry() usize { return @sizeOf(@TypeOf(testTrickyDefer)); }
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:4:11: error: 'try' not allowed inside defer expression
diff --git a/test/cases/compile_errors/stage1/obj/returning_error_from_void_async_function.zig b/test/cases/compile_errors/stage1/obj/returning_error_from_void_async_function.zig
new file mode 100644
index 0000000000000000000000000000000000000000..691c89a3478e21324685d27680ec26c13b0fc5f2
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/returning_error_from_void_async_function.zig
@@ -0,0 +1,12 @@
+export fn entry() void {
+    _ = async amain();
+}
+fn amain() callconv(.Async) void {
+    return error.ShouldBeCompileError;
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:5:17: error: expected type 'void', found 'error{ShouldBeCompileError}'
diff --git a/test/cases/compile_errors/stage1/obj/runtime-known_async_function_called.zig b/test/cases/compile_errors/stage1/obj/runtime-known_async_function_called.zig
new file mode 100644
index 0000000000000000000000000000000000000000..90685ce566297391b6924ec1a56cddc2db28aa9a
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/runtime-known_async_function_called.zig
@@ -0,0 +1,14 @@
+export fn entry() void {
+    _ = async amain();
+}
+fn amain() void {
+    var ptr = afunc;
+    _ = ptr();
+}
+fn afunc() callconv(.Async) void {}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:6:12: error: function is not comptime-known; @asyncCall required
diff --git a/test/cases/compile_errors/stage1/obj/runtime-known_function_called_with_async_keyword.zig b/test/cases/compile_errors/stage1/obj/runtime-known_function_called_with_async_keyword.zig
new file mode 100644
index 0000000000000000000000000000000000000000..c66d0f9cbb557517b1e02bfd271871d2b229243e
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/runtime-known_function_called_with_async_keyword.zig
@@ -0,0 +1,12 @@
+export fn entry() void {
+    var ptr = afunc;
+    _ = async ptr();
+}
+
+fn afunc() callconv(.Async) void { }
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:3:15: error: function is not comptime-known; @asyncCall required
diff --git a/test/cases/compile_errors/stage1/obj/runtime_assignment_to_comptime_struct_type.zig b/test/cases/compile_errors/stage1/obj/runtime_assignment_to_comptime_struct_type.zig
new file mode 100644
index 0000000000000000000000000000000000000000..62b09673eb9479c3fe9fe75f50543a25a3bdd220
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/runtime_assignment_to_comptime_struct_type.zig
@@ -0,0 +1,15 @@
+const Foo = struct {
+    Bar: u8,
+    Baz: type,
+};
+export fn f() void {
+    var x: u8 = 0;
+    const foo = Foo { .Bar = x, .Baz = u8 };
+    _ = foo;
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:7:23: error: unable to evaluate constant expression
diff --git a/test/cases/compile_errors/stage1/obj/runtime_assignment_to_comptime_union_type.zig b/test/cases/compile_errors/stage1/obj/runtime_assignment_to_comptime_union_type.zig
new file mode 100644
index 0000000000000000000000000000000000000000..af13f8b8ce9068c97a8015a39fca9be4cf6b8569
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/runtime_assignment_to_comptime_union_type.zig
@@ -0,0 +1,15 @@
+const Foo = union {
+    Bar: u8,
+    Baz: type,
+};
+export fn f() void {
+    var x: u8 = 0;
+    const foo = Foo { .Bar = x };
+    _ = foo;
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:7:23: error: unable to evaluate constant expression
diff --git a/test/cases/compile_errors/stage1/obj/runtime_cast_to_union_which_has_non-void_fields.zig b/test/cases/compile_errors/stage1/obj/runtime_cast_to_union_which_has_non-void_fields.zig
new file mode 100644
index 0000000000000000000000000000000000000000..d25c815c7e01d6df0b4bda73c3727b2f06ef6e8b
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/runtime_cast_to_union_which_has_non-void_fields.zig
@@ -0,0 +1,20 @@
+const Letter = enum { A, B, C };
+const Value = union(Letter) {
+    A: i32,
+    B,
+    C,
+};
+export fn entry() void {
+    foo(Letter.A);
+}
+fn foo(l: Letter) void {
+    var x: Value = l;
+    _ = x;
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// 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'
diff --git a/test/cases/compile_errors/stage1/obj/runtime_index_into_comptime_type_slice.zig b/test/cases/compile_errors/stage1/obj/runtime_index_into_comptime_type_slice.zig
new file mode 100644
index 0000000000000000000000000000000000000000..379767c7f36801b29114092c460883cdf21e45c1
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/runtime_index_into_comptime_type_slice.zig
@@ -0,0 +1,17 @@
+const Struct = struct {
+    a: u32,
+};
+fn getIndex() usize {
+    return 2;
+}
+export fn entry() void {
+    const index = getIndex();
+    const field = @typeInfo(Struct).Struct.fields[index];
+    _ = field;
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:9:51: error: values of type 'std.builtin.Type.StructField' must be comptime known, but index value is runtime known
diff --git a/test/cases/compile_errors/stage1/obj/saturating_arithmetic_does_not_allow_floats.zig b/test/cases/compile_errors/stage1/obj/saturating_arithmetic_does_not_allow_floats.zig
new file mode 100644
index 0000000000000000000000000000000000000000..7bda134af6106e249610d83810afd6a74f26eff6
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/saturating_arithmetic_does_not_allow_floats.zig
@@ -0,0 +1,9 @@
+export fn a() void {
+    _ = @as(f32, 1.0) +| @as(f32, 1.0);
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// error: invalid operands to binary expression: 'f32' and 'f32'
diff --git a/test/cases/compile_errors/stage1/obj/saturating_shl_assign_does_not_allow_negative_rhs_at_comptime.zig b/test/cases/compile_errors/stage1/obj/saturating_shl_assign_does_not_allow_negative_rhs_at_comptime.zig
new file mode 100644
index 0000000000000000000000000000000000000000..7b94f8e832b9f9f53eaac1e2964c5c523a4bf003
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/saturating_shl_assign_does_not_allow_negative_rhs_at_comptime.zig
@@ -0,0 +1,12 @@
+export fn a() void {
+    comptime {
+      var x = @as(i32, 1);
+      x <<|= @as(i32, -2);
+  }
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// error: shift by negative value -2
diff --git a/test/cases/compile_errors/stage1/obj/saturating_shl_does_not_allow_negative_rhs_at_comptime.zig b/test/cases/compile_errors/stage1/obj/saturating_shl_does_not_allow_negative_rhs_at_comptime.zig
new file mode 100644
index 0000000000000000000000000000000000000000..ac1ce7d3a0e14088a7a15a674a755ef1a15145e6
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/saturating_shl_does_not_allow_negative_rhs_at_comptime.zig
@@ -0,0 +1,9 @@
+export fn a() void {
+    _ = @as(i32, 1) <<| @as(i32, -2);
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// error: shift by negative value -2
diff --git a/test/cases/compile_errors/stage1/obj/setAlignStack_in_inline_function.zig b/test/cases/compile_errors/stage1/obj/setAlignStack_in_inline_function.zig
new file mode 100644
index 0000000000000000000000000000000000000000..8490298aa37c081db7e9a2fd58cb00e8ce877471
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/setAlignStack_in_inline_function.zig
@@ -0,0 +1,12 @@
+export fn entry() void {
+    foo();
+}
+fn foo() callconv(.Inline) void {
+    @setAlignStack(16);
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:5:5: error: @setAlignStack in inline function
diff --git a/test/cases/compile_errors/stage1/obj/setAlignStack_in_naked_function.zig b/test/cases/compile_errors/stage1/obj/setAlignStack_in_naked_function.zig
new file mode 100644
index 0000000000000000000000000000000000000000..b9adc84ed540f1a0c4a1c10bc9b34c3017fc5ae5
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/setAlignStack_in_naked_function.zig
@@ -0,0 +1,9 @@
+export fn entry() callconv(.Naked) void {
+    @setAlignStack(16);
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:2:5: error: @setAlignStack in naked function
diff --git a/test/cases/compile_errors/stage1/obj/setAlignStack_outside_function.zig b/test/cases/compile_errors/stage1/obj/setAlignStack_outside_function.zig
new file mode 100644
index 0000000000000000000000000000000000000000..754756012b4fd77e4dadfeca2175ac923712739a
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/setAlignStack_outside_function.zig
@@ -0,0 +1,9 @@
+comptime {
+    @setAlignStack(16);
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:2:5: error: @setAlignStack outside function
diff --git a/test/cases/compile_errors/stage1/obj/setAlignStack_set_twice.zig b/test/cases/compile_errors/stage1/obj/setAlignStack_set_twice.zig
new file mode 100644
index 0000000000000000000000000000000000000000..244db9d96208061e2cd1540cab696bf5634b3945
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/setAlignStack_set_twice.zig
@@ -0,0 +1,11 @@
+export fn entry() void {
+    @setAlignStack(16);
+    @setAlignStack(16);
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:3:5: error: alignstack set twice
+// tmp.zig:2:5: note: first set here
diff --git a/test/cases/compile_errors/stage1/obj/setAlignStack_too_big.zig b/test/cases/compile_errors/stage1/obj/setAlignStack_too_big.zig
new file mode 100644
index 0000000000000000000000000000000000000000..601631e15840ec7c1360190b0dcbab78734ae679
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/setAlignStack_too_big.zig
@@ -0,0 +1,9 @@
+export fn entry() void {
+    @setAlignStack(511 + 1);
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:2:5: error: attempt to @setAlignStack(512); maximum is 256
diff --git a/test/cases/compile_errors/stage1/obj/setFloatMode_twice_for_same_scope.zig b/test/cases/compile_errors/stage1/obj/setFloatMode_twice_for_same_scope.zig
new file mode 100644
index 0000000000000000000000000000000000000000..41fe6d4d6c4e9d78c5fea3055843a76355d6b061
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/setFloatMode_twice_for_same_scope.zig
@@ -0,0 +1,11 @@
+export fn foo() void {
+    @setFloatMode(@import("std").builtin.FloatMode.Optimized);
+    @setFloatMode(@import("std").builtin.FloatMode.Optimized);
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:3:5: error: float mode set twice for same scope
+// tmp.zig:2:5: note: first set here
diff --git a/test/cases/compile_errors/stage1/obj/setRuntimeSafety_twice_for_same_scope.zig b/test/cases/compile_errors/stage1/obj/setRuntimeSafety_twice_for_same_scope.zig
new file mode 100644
index 0000000000000000000000000000000000000000..03a93b68d55ffb08d1c185a5d5cbf33e5ecbdd50
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/setRuntimeSafety_twice_for_same_scope.zig
@@ -0,0 +1,11 @@
+export fn foo() void {
+    @setRuntimeSafety(false);
+    @setRuntimeSafety(false);
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:3:5: error: runtime safety set twice for same scope
+// tmp.zig:2:5: note: first set here
diff --git a/test/cases/compile_errors/stage1/obj/setting_a_section_on_a_local_variable.zig b/test/cases/compile_errors/stage1/obj/setting_a_section_on_a_local_variable.zig
new file mode 100644
index 0000000000000000000000000000000000000000..90d605dc40215c54d6ac969cc96c1a55c549a2c2
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/setting_a_section_on_a_local_variable.zig
@@ -0,0 +1,10 @@
+export fn entry() i32 {
+    var foo: i32 linksection(".text2") = 1234;
+    return foo;
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:2:30: error: cannot set section of local variable 'foo'
diff --git a/test/cases/compile_errors/stage1/obj/shift_amount_has_to_be_an_integer_type.zig b/test/cases/compile_errors/stage1/obj/shift_amount_has_to_be_an_integer_type.zig
new file mode 100644
index 0000000000000000000000000000000000000000..53794dba1b80a07067305abb27fe5224d30a2710
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/shift_amount_has_to_be_an_integer_type.zig
@@ -0,0 +1,10 @@
+export fn entry() void {
+    const x = 1 << &@as(u8, 10);
+    _ = x;
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:2:21: error: shift amount has to be an integer type, but found '*const u8'
diff --git a/test/cases/compile_errors/stage1/obj/shift_by_negative_comptime_integer.zig b/test/cases/compile_errors/stage1/obj/shift_by_negative_comptime_integer.zig
new file mode 100644
index 0000000000000000000000000000000000000000..3425cf565ebe8e92485bef9f93d44dbd56d3110a
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/shift_by_negative_comptime_integer.zig
@@ -0,0 +1,10 @@
+comptime {
+    var a = 1 >> -1;
+    _ = a;
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:2:18: error: shift by negative value -1
diff --git a/test/cases/compile_errors/stage1/obj/shift_left_assign_on_undefined_value.zig b/test/cases/compile_errors/stage1/obj/shift_left_assign_on_undefined_value.zig
new file mode 100644
index 0000000000000000000000000000000000000000..575bf0ee6b60cd3bc30b6b520773dfaee5fe3b56
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/shift_left_assign_on_undefined_value.zig
@@ -0,0 +1,10 @@
+comptime {
+    var a: i64 = undefined;
+    a >>= 2;
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:3:5: error: use of undefined value here causes undefined behavior
diff --git a/test/cases/compile_errors/stage1/obj/shift_left_on_undefined_value.zig b/test/cases/compile_errors/stage1/obj/shift_left_on_undefined_value.zig
new file mode 100644
index 0000000000000000000000000000000000000000..abd06fbbabebfe422aee08e3ab758b13c028f7da
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/shift_left_on_undefined_value.zig
@@ -0,0 +1,10 @@
+comptime {
+    var a: i64 = undefined;
+    _ = a << 2;
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:3:9: error: use of undefined value here causes undefined behavior
diff --git a/test/cases/compile_errors/stage1/obj/shift_right_assign_on_undefined_value.zig b/test/cases/compile_errors/stage1/obj/shift_right_assign_on_undefined_value.zig
new file mode 100644
index 0000000000000000000000000000000000000000..575bf0ee6b60cd3bc30b6b520773dfaee5fe3b56
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/shift_right_assign_on_undefined_value.zig
@@ -0,0 +1,10 @@
+comptime {
+    var a: i64 = undefined;
+    a >>= 2;
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:3:5: error: use of undefined value here causes undefined behavior
diff --git a/test/cases/compile_errors/stage1/obj/shift_right_on_undefined_value.zig b/test/cases/compile_errors/stage1/obj/shift_right_on_undefined_value.zig
new file mode 100644
index 0000000000000000000000000000000000000000..e24cbe473a09a23618353883e9458d632939918d
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/shift_right_on_undefined_value.zig
@@ -0,0 +1,10 @@
+comptime {
+    var a: i64 = undefined;
+    _ = a >> 2;
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:3:9: error: use of undefined value here causes undefined behavior
diff --git a/test/cases/compile_errors/stage1/obj/shifting_RHS_is_log2_of_LHS_int_bit_width.zig b/test/cases/compile_errors/stage1/obj/shifting_RHS_is_log2_of_LHS_int_bit_width.zig
new file mode 100644
index 0000000000000000000000000000000000000000..d9b9bbfce36755bf318250d73451fc61c6012983
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/shifting_RHS_is_log2_of_LHS_int_bit_width.zig
@@ -0,0 +1,9 @@
+export fn entry(x: u8, y: u8) u8 {
+    return x << y;
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:2:17: error: expected type 'u3', found 'u8'
diff --git a/test/cases/compile_errors/stage1/obj/shifting_without_int_type_or_comptime_known.zig b/test/cases/compile_errors/stage1/obj/shifting_without_int_type_or_comptime_known.zig
new file mode 100644
index 0000000000000000000000000000000000000000..4d875575d016505922129b062d5c922be6786395
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/shifting_without_int_type_or_comptime_known.zig
@@ -0,0 +1,9 @@
+export fn entry(x: u8) u8 {
+    return 0x11 << x;
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:2:17: error: LHS of shift must be a fixed-width integer type, or RHS must be compile-time known
diff --git a/test/cases/compile_errors/stage1/obj/shlExact_shifts_out_1_bits.zig b/test/cases/compile_errors/stage1/obj/shlExact_shifts_out_1_bits.zig
new file mode 100644
index 0000000000000000000000000000000000000000..953c5fec50199c59dd2669b4e8601d026f4d70f8
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/shlExact_shifts_out_1_bits.zig
@@ -0,0 +1,10 @@
+comptime {
+    const x = @shlExact(@as(u8, 0b01010101), 2);
+    _ = x;
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:2:15: error: operation caused overflow
diff --git a/test/cases/compile_errors/stage1/obj/shrExact_shifts_out_1_bits.zig b/test/cases/compile_errors/stage1/obj/shrExact_shifts_out_1_bits.zig
new file mode 100644
index 0000000000000000000000000000000000000000..223db7663042f98a32ff416c5e513d806e6e155a
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/shrExact_shifts_out_1_bits.zig
@@ -0,0 +1,10 @@
+comptime {
+    const x = @shrExact(@as(u8, 0b10101010), 2);
+    _ = x;
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:2:15: error: exact shift shifted out 1 bits
diff --git a/test/cases/compile_errors/stage1/obj/signed_integer_division.zig b/test/cases/compile_errors/stage1/obj/signed_integer_division.zig
new file mode 100644
index 0000000000000000000000000000000000000000..3eebbf2248dbb2acd204d755c00346e2abbbdf6a
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/signed_integer_division.zig
@@ -0,0 +1,9 @@
+export fn foo(a: i32, b: i32) i32 {
+    return a / b;
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:2:14: error: division with 'i32' and 'i32': signed integers must use @divTrunc, @divFloor, or @divExact
diff --git a/test/cases/compile_errors/stage1/obj/signed_integer_remainder_division.zig b/test/cases/compile_errors/stage1/obj/signed_integer_remainder_division.zig
new file mode 100644
index 0000000000000000000000000000000000000000..58776729543830b4850da0851947441810a0a33f
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/signed_integer_remainder_division.zig
@@ -0,0 +1,9 @@
+export fn foo(a: i32, b: i32) i32 {
+    return a % b;
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:2:14: error: remainder division with 'i32' and 'i32': signed integers and floats must use @rem or @mod
diff --git a/test/cases/compile_errors/stage1/obj/sizeOf_bad_type.zig b/test/cases/compile_errors/stage1/obj/sizeOf_bad_type.zig
new file mode 100644
index 0000000000000000000000000000000000000000..f8c397f768620b7a0fb480a2c68c78c3dcf72f75
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/sizeOf_bad_type.zig
@@ -0,0 +1,9 @@
+export fn entry() usize {
+    return @sizeOf(@TypeOf(null));
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:2:20: error: no size available for type '@Type(.Null)'
diff --git a/test/cases/compile_errors/stage1/obj/slice_cannot_have_its_bytes_reinterpreted.zig b/test/cases/compile_errors/stage1/obj/slice_cannot_have_its_bytes_reinterpreted.zig
new file mode 100644
index 0000000000000000000000000000000000000000..8fcf4f505c94690e48ba2a0b6cfe559068423bc4
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/slice_cannot_have_its_bytes_reinterpreted.zig
@@ -0,0 +1,11 @@
+export fn foo() void {
+    const bytes = [1]u8{ 0xfa } ** 16;
+    var value = @ptrCast(*const []const u8, &bytes).*;
+    _ = value;
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// :3:52: error: slice '[]const u8' cannot have its bytes reinterpreted
diff --git a/test/cases/compile_errors/stage1/obj/slice_passed_as_array_init_type.zig b/test/cases/compile_errors/stage1/obj/slice_passed_as_array_init_type.zig
new file mode 100644
index 0000000000000000000000000000000000000000..7ad29b1900b98546ce17377f2b77d71e6e794bec
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/slice_passed_as_array_init_type.zig
@@ -0,0 +1,10 @@
+export fn entry() void {
+    const x = []u8{};
+    _ = x;
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:2:15: error: array literal requires address-of operator (&) to coerce to slice type '[]u8'
diff --git a/test/cases/compile_errors/stage1/obj/slice_passed_as_array_init_type_with_elems.zig b/test/cases/compile_errors/stage1/obj/slice_passed_as_array_init_type_with_elems.zig
new file mode 100644
index 0000000000000000000000000000000000000000..0da4b3fc9de8de87465ca09d7ddb2b6c57b37c34
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/slice_passed_as_array_init_type_with_elems.zig
@@ -0,0 +1,10 @@
+export fn entry() void {
+    const x = []u8{1, 2};
+    _ = x;
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:2:15: error: array literal requires address-of operator (&) to coerce to slice type '[]u8'
diff --git a/test/cases/compile_errors/stage1/obj/slice_sentinel_mismatch-1.zig b/test/cases/compile_errors/stage1/obj/slice_sentinel_mismatch-1.zig
new file mode 100644
index 0000000000000000000000000000000000000000..d0c47097da9b677bab22ff8cfe0f2f5c7d6de733
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/slice_sentinel_mismatch-1.zig
@@ -0,0 +1,10 @@
+export fn entry() void {
+    const y: [:1]const u8 = &[_:2]u8{ 1, 2 };
+    _ = y;
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:2:37: error: expected type '[:1]const u8', found '*const [2:2]u8'
diff --git a/test/cases/compile_errors/stage1/obj/slice_sentinel_mismatch-2.zig b/test/cases/compile_errors/stage1/obj/slice_sentinel_mismatch-2.zig
new file mode 100644
index 0000000000000000000000000000000000000000..5f8d312a3c74dc031861ffb300beb641145e95a8
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/slice_sentinel_mismatch-2.zig
@@ -0,0 +1,12 @@
+fn foo() [:0]u8 {
+    var x: []u8 = undefined;
+    return x;
+}
+comptime { _ = foo; }
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:3:12: error: expected type '[:0]u8', found '[]u8'
+// tmp.zig:3:12: note: destination pointer requires a terminating '0' sentinel
diff --git a/test/cases/compile_errors/stage1/obj/slicing_of_global_undefined_pointer.zig b/test/cases/compile_errors/stage1/obj/slicing_of_global_undefined_pointer.zig
new file mode 100644
index 0000000000000000000000000000000000000000..8bbc0f85ebb7a4249e54f56f16b0710d02004705
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/slicing_of_global_undefined_pointer.zig
@@ -0,0 +1,10 @@
+var buf: *[1]u8 = undefined;
+export fn entry() void {
+    _ = buf[0..1];
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:3:12: error: non-zero length slice of undefined pointer
diff --git a/test/cases/compile_errors/stage1/obj/slicing_single-item_pointer.zig b/test/cases/compile_errors/stage1/obj/slicing_single-item_pointer.zig
new file mode 100644
index 0000000000000000000000000000000000000000..d8c82fa3aff677a450d0505c102816c97c468c22
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/slicing_single-item_pointer.zig
@@ -0,0 +1,10 @@
+export fn entry(ptr: *i32) void {
+    const slice = ptr[0..2];
+    _ = slice;
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:2:22: error: slice of single-item pointer
diff --git a/test/cases/compile_errors/stage1/obj/specify_enum_tag_type_that_is_too_small.zig b/test/cases/compile_errors/stage1/obj/specify_enum_tag_type_that_is_too_small.zig
new file mode 100644
index 0000000000000000000000000000000000000000..dc7077c8f84d0f1b21aabc89d896b3737aad7a79
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/specify_enum_tag_type_that_is_too_small.zig
@@ -0,0 +1,18 @@
+const Small = enum (u2) {
+    One,
+    Two,
+    Three,
+    Four,
+    Five,
+};
+
+export fn entry() void {
+    var x = Small.One;
+    _ = x;
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:6:5: error: enumeration value 4 too large for type 'u2'
diff --git a/test/cases/compile_errors/stage1/obj/specify_non-integer_enum_tag_type.zig b/test/cases/compile_errors/stage1/obj/specify_non-integer_enum_tag_type.zig
new file mode 100644
index 0000000000000000000000000000000000000000..333647e1e392afb22f7596385ceace2d6a01a48c
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/specify_non-integer_enum_tag_type.zig
@@ -0,0 +1,16 @@
+const Small = enum (f32) {
+    One,
+    Two,
+    Three,
+};
+
+export fn entry() void {
+    var x = Small.One;
+    _ = x;
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:1:21: error: expected integer, found 'f32'
diff --git a/test/cases/compile_errors/stage1/obj/src_outside_function.zig b/test/cases/compile_errors/stage1/obj/src_outside_function.zig
new file mode 100644
index 0000000000000000000000000000000000000000..7f8c7ae72fbd6e5f35777c91815591b18d75a32e
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/src_outside_function.zig
@@ -0,0 +1,9 @@
+comptime {
+    @src();
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:2:5: error: @src outside function
diff --git a/test/cases/compile_errors/stage1/obj/std.fmt_error_for_unused_arguments.zig b/test/cases/compile_errors/stage1/obj/std.fmt_error_for_unused_arguments.zig
new file mode 100644
index 0000000000000000000000000000000000000000..21603ab3d314c69482b08fd9c2038ad9d489223f
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/std.fmt_error_for_unused_arguments.zig
@@ -0,0 +1,9 @@
+export fn entry() 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
+// backend=stage1
+// target=native
+//
+// ?:?:?: error: 10 unused arguments in '{d} {d} {d} {d} {d}'
diff --git a/test/cases/compile_errors/stage1/obj/store_vector_pointer_with_unknown_runtime_index.zig b/test/cases/compile_errors/stage1/obj/store_vector_pointer_with_unknown_runtime_index.zig
new file mode 100644
index 0000000000000000000000000000000000000000..57e91631b1173af253233d4621f00069232be958
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/store_vector_pointer_with_unknown_runtime_index.zig
@@ -0,0 +1,16 @@
+export fn entry() void {
+    var v: @import("std").meta.Vector(4, i32) = [_]i32{ 1, 5, 3, undefined };
+
+    var i: u32 = 0;
+    storev(&v[i], 42);
+}
+
+fn storev(ptr: anytype, val: i32) void {
+    ptr.* = val;
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:9:8: error: unable to determine vector element index of type '*align(16:0:4:?) i32
diff --git a/test/cases/compile_errors/stage1/obj/storing_runtime_value_in_compile_time_variable_then_using_it.zig b/test/cases/compile_errors/stage1/obj/storing_runtime_value_in_compile_time_variable_then_using_it.zig
new file mode 100644
index 0000000000000000000000000000000000000000..2d85209358de870aedd0cca812642ce672c1baa7
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/storing_runtime_value_in_compile_time_variable_then_using_it.zig
@@ -0,0 +1,49 @@
+const Mode = @import("std").builtin.Mode;
+
+fn Free(comptime filename: []const u8) TestCase {
+    return TestCase {
+        .filename = filename,
+        .problem_type = ProblemType.Free,
+    };
+}
+
+fn LibC(comptime filename: []const u8) TestCase {
+    return TestCase {
+        .filename = filename,
+        .problem_type = ProblemType.LinkLibC,
+    };
+}
+
+const TestCase = struct {
+    filename: []const u8,
+    problem_type: ProblemType,
+};
+
+const ProblemType = enum {
+    Free,
+    LinkLibC,
+};
+
+export fn entry() void {
+    const tests = [_]TestCase {
+        Free("001"),
+        Free("002"),
+        LibC("078"),
+        Free("116"),
+        Free("117"),
+    };
+
+    for ([_]Mode { Mode.Debug, Mode.ReleaseSafe, Mode.ReleaseFast }) |mode| {
+        _ = mode;
+        inline for (tests) |test_case| {
+            const foo = test_case.filename ++ ".zig";
+            _ = foo;
+        }
+    }
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:38:29: error: cannot store runtime value in compile time variable
diff --git a/test/cases/compile_errors/stage1/obj/struct_depends_on_itself_via_optional_field.zig b/test/cases/compile_errors/stage1/obj/struct_depends_on_itself_via_optional_field.zig
new file mode 100644
index 0000000000000000000000000000000000000000..46086172f77b635fefc79407f275504634848248
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/struct_depends_on_itself_via_optional_field.zig
@@ -0,0 +1,19 @@
+const LhsExpr = struct {
+    rhsExpr: ?AstObject,
+};
+const AstObject = union {
+    lhsExpr: LhsExpr,
+};
+export fn entry() void {
+    const lhsExpr = LhsExpr{ .rhsExpr = null };
+    const obj = AstObject{ .lhsExpr = lhsExpr };
+    _ = obj;
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:1:17: error: struct 'LhsExpr' depends on itself
+// tmp.zig:5:5: note: while checking this field
+// tmp.zig:2:5: note: while checking this field
diff --git a/test/cases/compile_errors/stage1/obj/struct_field_missing_type.zig b/test/cases/compile_errors/stage1/obj/struct_field_missing_type.zig
new file mode 100644
index 0000000000000000000000000000000000000000..175f1c7df771210fc691b14ffda9aa57bc38e516
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/struct_field_missing_type.zig
@@ -0,0 +1,13 @@
+const Letter = struct {
+    A,
+};
+export fn entry() void {
+    var a = Letter { .A = {} };
+    _ = a;
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:2:5: error: struct field missing type
diff --git a/test/cases/compile_errors/stage1/obj/struct_init_syntax_for_array.zig b/test/cases/compile_errors/stage1/obj/struct_init_syntax_for_array.zig
new file mode 100644
index 0000000000000000000000000000000000000000..6362e05114651cc82838d8e9a0295a0bceec3a00
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/struct_init_syntax_for_array.zig
@@ -0,0 +1,10 @@
+const foo = [3]u16{ .x = 1024 };
+comptime {
+    _ = foo;
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:1:13: error: initializing array with struct syntax
diff --git a/test/cases/compile_errors/stage1/obj/struct_with_declarations_unavailable_for_reify_type.zig b/test/cases/compile_errors/stage1/obj/struct_with_declarations_unavailable_for_reify_type.zig
new file mode 100644
index 0000000000000000000000000000000000000000..409020ca257f480a5ccbb16b4fdb8147d3fef35c
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/struct_with_declarations_unavailable_for_reify_type.zig
@@ -0,0 +1,9 @@
+export fn entry() void {
+    _ = @Type(@typeInfo(struct { const foo = 1; }));
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:2:15: error: Type.Struct.decls must be empty for @Type
diff --git a/test/cases/compile_errors/stage1/obj/struct_with_invalid_field.zig b/test/cases/compile_errors/stage1/obj/struct_with_invalid_field.zig
new file mode 100644
index 0000000000000000000000000000000000000000..dcc9d26f65bae996f07fdcde1aab66b1266f593f
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/struct_with_invalid_field.zig
@@ -0,0 +1,30 @@
+const std = @import("std",);
+const Allocator = std.mem.Allocator;
+const ArrayList = std.ArrayList;
+
+const HeaderWeight = enum {
+    H1, H2, H3, H4, H5, H6,
+};
+
+const MdText = ArrayList(u8);
+
+const MdNode = union(enum) {
+    Header: struct {
+        text: MdText,
+        weight: HeaderValue,
+    },
+};
+
+export fn entry() void {
+    const a = MdNode.Header {
+        .text = MdText.init(std.testing.allocator),
+        .weight = HeaderWeight.H1,
+    };
+    _ = a;
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:14:17: error: use of undeclared identifier 'HeaderValue'
diff --git a/test/cases/compile_errors/stage1/obj/sub_assign_on_undefined_value.zig b/test/cases/compile_errors/stage1/obj/sub_assign_on_undefined_value.zig
new file mode 100644
index 0000000000000000000000000000000000000000..74b705a154bfbd141d5e538c8bd09c113700421e
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/sub_assign_on_undefined_value.zig
@@ -0,0 +1,10 @@
+comptime {
+    var a: i64 = undefined;
+    a -= a;
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:3:5: error: use of undefined value here causes undefined behavior
diff --git a/test/cases/compile_errors/stage1/obj/sub_on_undefined_value.zig b/test/cases/compile_errors/stage1/obj/sub_on_undefined_value.zig
new file mode 100644
index 0000000000000000000000000000000000000000..08c590ee3ff3bf66c3e2dbe838bc8ecc215e9f33
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/sub_on_undefined_value.zig
@@ -0,0 +1,10 @@
+comptime {
+    var a: i64 = undefined;
+    _ = a - a;
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:3:9: error: use of undefined value here causes undefined behavior
diff --git a/test/cases/compile_errors/stage1/obj/sub_overflow_in_function_evaluation.zig b/test/cases/compile_errors/stage1/obj/sub_overflow_in_function_evaluation.zig
new file mode 100644
index 0000000000000000000000000000000000000000..dc259e6dcfcac7fc474487a4a65d394ff74f5d2f
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/sub_overflow_in_function_evaluation.zig
@@ -0,0 +1,12 @@
+const y = sub(10, 20);
+fn sub(a: u16, b: u16) u16 {
+    return a - b;
+}
+
+export fn entry() usize { return @sizeOf(@TypeOf(y)); }
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:3:14: error: operation caused overflow
diff --git a/test/cases/compile_errors/stage1/obj/sub_wrap_assign_on_undefined_value.zig b/test/cases/compile_errors/stage1/obj/sub_wrap_assign_on_undefined_value.zig
new file mode 100644
index 0000000000000000000000000000000000000000..41aa1ca14b08c74891486a50150d0a09ad3b1715
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/sub_wrap_assign_on_undefined_value.zig
@@ -0,0 +1,10 @@
+comptime {
+    var a: i64 = undefined;
+    a -%= a;
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:3:5: error: use of undefined value here causes undefined behavior
diff --git a/test/cases/compile_errors/stage1/obj/sub_wrap_on_undefined_value.zig b/test/cases/compile_errors/stage1/obj/sub_wrap_on_undefined_value.zig
new file mode 100644
index 0000000000000000000000000000000000000000..68e4e78512f47387e83c7f20340829bca1003814
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/sub_wrap_on_undefined_value.zig
@@ -0,0 +1,10 @@
+comptime {
+    var a: i64 = undefined;
+    _ = a -% a;
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:3:9: error: use of undefined value here causes undefined behavior
diff --git a/test/cases/compile_errors/stage1/obj/suspend_inside_suspend_block.zig b/test/cases/compile_errors/stage1/obj/suspend_inside_suspend_block.zig
new file mode 100644
index 0000000000000000000000000000000000000000..4adffd2f2574b7f7216e3c2e93151779773978c4
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/suspend_inside_suspend_block.zig
@@ -0,0 +1,16 @@
+export fn entry() void {
+    _ = async foo();
+}
+fn foo() void {
+    suspend {
+        suspend {
+        }
+    }
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:6:9: error: cannot suspend inside suspend block
+// tmp.zig:5:5: note: other suspend block here
diff --git a/test/cases/compile_errors/stage1/obj/switch_expression-duplicate_enumeration_prong.zig b/test/cases/compile_errors/stage1/obj/switch_expression-duplicate_enumeration_prong.zig
new file mode 100644
index 0000000000000000000000000000000000000000..056aebe3dd415d5b069aaa62f1bd7da083120d89
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/switch_expression-duplicate_enumeration_prong.zig
@@ -0,0 +1,24 @@
+const Number = enum {
+    One,
+    Two,
+    Three,
+    Four,
+};
+fn f(n: Number) i32 {
+    switch (n) {
+        Number.One => 1,
+        Number.Two => 2,
+        Number.Three => @as(i32, 3),
+        Number.Four => 4,
+        Number.Two => 2,
+    }
+}
+
+export fn entry() usize { return @sizeOf(@TypeOf(f)); }
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:13:15: error: duplicate switch value
+// tmp.zig:10:15: note: other value here
diff --git a/test/cases/compile_errors/stage1/obj/switch_expression-duplicate_enumeration_prong_when_else_present.zig b/test/cases/compile_errors/stage1/obj/switch_expression-duplicate_enumeration_prong_when_else_present.zig
new file mode 100644
index 0000000000000000000000000000000000000000..4d891c3917f19c9ea21418cea7461c509a803d86
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/switch_expression-duplicate_enumeration_prong_when_else_present.zig
@@ -0,0 +1,25 @@
+const Number = enum {
+    One,
+    Two,
+    Three,
+    Four,
+};
+fn f(n: Number) i32 {
+    switch (n) {
+        Number.One => 1,
+        Number.Two => 2,
+        Number.Three => @as(i32, 3),
+        Number.Four => 4,
+        Number.Two => 2,
+        else => 10,
+    }
+}
+
+export fn entry() usize { return @sizeOf(@TypeOf(f)); }
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:13:15: error: duplicate switch value
+// tmp.zig:10:15: note: other value here
diff --git a/test/cases/compile_errors/stage1/obj/switch_expression-duplicate_or_overlapping_integer_value.zig b/test/cases/compile_errors/stage1/obj/switch_expression-duplicate_or_overlapping_integer_value.zig
new file mode 100644
index 0000000000000000000000000000000000000000..2810bc13e1eefe5ee620fcbc25fd0ea78f2f4254
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/switch_expression-duplicate_or_overlapping_integer_value.zig
@@ -0,0 +1,16 @@
+fn foo(x: u8) u8 {
+    return switch (x) {
+        0 ... 100 => @as(u8, 0),
+        101 ... 200 => 1,
+        201, 203 ... 207 => 2,
+        206 ... 255 => 3,
+    };
+}
+export fn entry() usize { return @sizeOf(@TypeOf(foo)); }
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:6:9: error: duplicate switch value
+// tmp.zig:5:14: note: previous value here
diff --git a/test/cases/compile_errors/stage1/obj/switch_expression-duplicate_type.zig b/test/cases/compile_errors/stage1/obj/switch_expression-duplicate_type.zig
new file mode 100644
index 0000000000000000000000000000000000000000..b84c4622a2e0c55cb74aa8935a91e1b406286c70
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/switch_expression-duplicate_type.zig
@@ -0,0 +1,17 @@
+fn foo(comptime T: type, x: T) u8 {
+    _ = x;
+    return switch (T) {
+        u32 => 0,
+        u64 => 1,
+        u32 => 2,
+        else => 3,
+    };
+}
+export fn entry() usize { return @sizeOf(@TypeOf(foo(u32, 0))); }
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:6:9: error: duplicate switch value
+// tmp.zig:4:9: note: previous value here
diff --git a/test/cases/compile_errors/stage1/obj/switch_expression-duplicate_type_struct_alias.zig b/test/cases/compile_errors/stage1/obj/switch_expression-duplicate_type_struct_alias.zig
new file mode 100644
index 0000000000000000000000000000000000000000..057e674e5a97623c9518c24fc6f93f159738ddad
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/switch_expression-duplicate_type_struct_alias.zig
@@ -0,0 +1,21 @@
+const Test = struct {
+    bar: i32,
+};
+const Test2 = Test;
+fn foo(comptime T: type, x: T) u8 {
+    _ = x;
+    return switch (T) {
+        Test => 0,
+        u64 => 1,
+        Test2 => 2,
+        else => 3,
+    };
+}
+export fn entry() usize { return @sizeOf(@TypeOf(foo(u32, 0))); }
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:10:9: error: duplicate switch value
+// tmp.zig:8:9: note: previous value here
diff --git a/test/cases/compile_errors/stage1/obj/switch_expression-missing_enumeration_prong.zig b/test/cases/compile_errors/stage1/obj/switch_expression-missing_enumeration_prong.zig
new file mode 100644
index 0000000000000000000000000000000000000000..1a13730223b9ee9a1a7f7930f311e64956b1b31d
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/switch_expression-missing_enumeration_prong.zig
@@ -0,0 +1,21 @@
+const Number = enum {
+    One,
+    Two,
+    Three,
+    Four,
+};
+fn f(n: Number) i32 {
+    switch (n) {
+        Number.One => 1,
+        Number.Two => 2,
+        Number.Three => @as(i32, 3),
+    }
+}
+
+export fn entry() usize { return @sizeOf(@TypeOf(f)); }
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:8:5: error: enumeration value 'Number.Four' not handled in switch
diff --git a/test/cases/compile_errors/stage1/obj/switch_expression-multiple_else_prongs.zig b/test/cases/compile_errors/stage1/obj/switch_expression-multiple_else_prongs.zig
new file mode 100644
index 0000000000000000000000000000000000000000..82672220925567bcb41f41d0f38bffb7cafbbae7
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/switch_expression-multiple_else_prongs.zig
@@ -0,0 +1,16 @@
+fn f(x: u32) void {
+    const value: bool = switch (x) {
+        1234 => false,
+        else => true,
+        else => true,
+    };
+}
+export fn entry() void {
+    f(1234);
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:5:9: error: multiple else prongs in switch expression
diff --git a/test/cases/compile_errors/stage1/obj/switch_expression-non_exhaustive_integer_prongs.zig b/test/cases/compile_errors/stage1/obj/switch_expression-non_exhaustive_integer_prongs.zig
new file mode 100644
index 0000000000000000000000000000000000000000..940338edb98e409668a53bb63990a9f10c99b2a2
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/switch_expression-non_exhaustive_integer_prongs.zig
@@ -0,0 +1,12 @@
+fn foo(x: u8) void {
+    switch (x) {
+        0 => {},
+    }
+}
+export fn entry() usize { return @sizeOf(@TypeOf(foo)); }
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:2:5: error: switch must handle all possibilities
diff --git a/test/cases/compile_errors/stage1/obj/switch_expression-switch_on_pointer_type_with_no_else.zig b/test/cases/compile_errors/stage1/obj/switch_expression-switch_on_pointer_type_with_no_else.zig
new file mode 100644
index 0000000000000000000000000000000000000000..6a357beabed5d55f8c18205e08182b340dee5bfd
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/switch_expression-switch_on_pointer_type_with_no_else.zig
@@ -0,0 +1,13 @@
+fn foo(x: *u8) void {
+    switch (x) {
+        &y => {},
+    }
+}
+const y: u8 = 100;
+export fn entry() usize { return @sizeOf(@TypeOf(foo)); }
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:2:5: error: else prong required when switching on type '*u8'
diff --git a/test/cases/compile_errors/stage1/obj/switch_expression-unreachable_else_prong_bool.zig b/test/cases/compile_errors/stage1/obj/switch_expression-unreachable_else_prong_bool.zig
new file mode 100644
index 0000000000000000000000000000000000000000..2ee39f153187e00ed113cbaab9f01cd16e320182
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/switch_expression-unreachable_else_prong_bool.zig
@@ -0,0 +1,14 @@
+fn foo(x: bool) void {
+    switch (x) {
+        true => {},
+        false => {},
+        else => {},
+    }
+}
+export fn entry() usize { return @sizeOf(@TypeOf(foo)); }
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:5:9: error: unreachable else prong, all cases already handled
diff --git a/test/cases/compile_errors/stage1/obj/switch_expression-unreachable_else_prong_enum.zig b/test/cases/compile_errors/stage1/obj/switch_expression-unreachable_else_prong_enum.zig
new file mode 100644
index 0000000000000000000000000000000000000000..bcf840ab97769c77b5521a5d40cca55544db9973
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/switch_expression-unreachable_else_prong_enum.zig
@@ -0,0 +1,24 @@
+const TestEnum = enum{ T1, T2 };
+
+fn err(x: u8) TestEnum {
+    switch (x) {
+        0 => return TestEnum.T1,
+        else => return TestEnum.T2,
+    }
+}
+
+fn foo(x: u8) void {
+    switch (err(x)) {
+        TestEnum.T1 => {},
+        TestEnum.T2 => {},
+        else => {},
+    }
+}
+
+export fn entry() usize { return @sizeOf(@TypeOf(foo)); }
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:14:9: error: unreachable else prong, all cases already handled
diff --git a/test/cases/compile_errors/stage1/obj/switch_expression-unreachable_else_prong_range_i8.zig b/test/cases/compile_errors/stage1/obj/switch_expression-unreachable_else_prong_range_i8.zig
new file mode 100644
index 0000000000000000000000000000000000000000..f0c9d7a08a3b32fa33f0663abc152ef3649e11c4
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/switch_expression-unreachable_else_prong_range_i8.zig
@@ -0,0 +1,17 @@
+fn foo(x: i8) void {
+    switch (x) {
+        -128...0 => {},
+        1 => {},
+        2 => {},
+        3 => {},
+        4...127 => {},
+        else => {},
+    }
+}
+export fn entry() usize { return @sizeOf(@TypeOf(foo)); }
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:8:9: error: unreachable else prong, all cases already handled
diff --git a/test/cases/compile_errors/stage1/obj/switch_expression-unreachable_else_prong_range_u8.zig b/test/cases/compile_errors/stage1/obj/switch_expression-unreachable_else_prong_range_u8.zig
new file mode 100644
index 0000000000000000000000000000000000000000..9342ce8c32f26b8939b01f3db0d642b4dde0b32b
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/switch_expression-unreachable_else_prong_range_u8.zig
@@ -0,0 +1,17 @@
+fn foo(x: u8) void {
+    switch (x) {
+        0 => {},
+        1 => {},
+        2 => {},
+        3 => {},
+        4...255 => {},
+        else => {},
+    }
+}
+export fn entry() usize { return @sizeOf(@TypeOf(foo)); }
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:8:9: error: unreachable else prong, all cases already handled
diff --git a/test/cases/compile_errors/stage1/obj/switch_expression-unreachable_else_prong_u1.zig b/test/cases/compile_errors/stage1/obj/switch_expression-unreachable_else_prong_u1.zig
new file mode 100644
index 0000000000000000000000000000000000000000..90abf5074bebd8bf5c411d0c75752a6f2c4c2d48
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/switch_expression-unreachable_else_prong_u1.zig
@@ -0,0 +1,14 @@
+fn foo(x: u1) void {
+    switch (x) {
+        0 => {},
+        1 => {},
+        else => {},
+    }
+}
+export fn entry() usize { return @sizeOf(@TypeOf(foo)); }
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:5:9: error: unreachable else prong, all cases already handled
diff --git a/test/cases/compile_errors/stage1/obj/switch_expression-unreachable_else_prong_u2.zig b/test/cases/compile_errors/stage1/obj/switch_expression-unreachable_else_prong_u2.zig
new file mode 100644
index 0000000000000000000000000000000000000000..a523046e162008ce1eff29ce29396b7060e90f0c
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/switch_expression-unreachable_else_prong_u2.zig
@@ -0,0 +1,16 @@
+fn foo(x: u2) void {
+    switch (x) {
+        0 => {},
+        1 => {},
+        2 => {},
+        3 => {},
+        else => {},
+    }
+}
+export fn entry() usize { return @sizeOf(@TypeOf(foo)); }
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:7:9: error: unreachable else prong, all cases already handled
diff --git a/test/cases/compile_errors/stage1/obj/switch_on_enum_with_1_field_with_no_prongs.zig b/test/cases/compile_errors/stage1/obj/switch_on_enum_with_1_field_with_no_prongs.zig
new file mode 100644
index 0000000000000000000000000000000000000000..97f7de121d69086f701c4eb986ec7329d6449c8d
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/switch_on_enum_with_1_field_with_no_prongs.zig
@@ -0,0 +1,12 @@
+const Foo = enum { M };
+
+export fn entry() void {
+    var f = Foo.M;
+    switch (f) {}
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:5:5: error: enumeration value 'Foo.M' not handled in switch
diff --git a/test/cases/compile_errors/stage1/obj/switch_on_union_with_no_attached_enum.zig b/test/cases/compile_errors/stage1/obj/switch_on_union_with_no_attached_enum.zig
new file mode 100644
index 0000000000000000000000000000000000000000..684861a898d769124f3c2a6c6e5ed15c319db442
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/switch_on_union_with_no_attached_enum.zig
@@ -0,0 +1,22 @@
+const Payload = union {
+    A: i32,
+    B: f64,
+    C: bool,
+};
+export fn entry() void {
+    const a = Payload { .A = 1234 };
+    foo(a);
+}
+fn foo(a: *const Payload) void {
+    switch (a.*) {
+        Payload.A => {},
+        else => unreachable,
+    }
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:11:14: error: switch on union which has no attached enum
+// tmp.zig:1:17: note: consider 'union(enum)' here
diff --git a/test/cases/compile_errors/stage1/obj/switch_with_invalid_expression_parameter.zig b/test/cases/compile_errors/stage1/obj/switch_with_invalid_expression_parameter.zig
new file mode 100644
index 0000000000000000000000000000000000000000..1eb74519f50fb197b25a5bf4fc843b3c83b3c52b
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/switch_with_invalid_expression_parameter.zig
@@ -0,0 +1,17 @@
+export fn entry() void {
+    Test(i32);
+}
+fn Test(comptime T: type) void {
+    const x = switch (T) {
+        []u8 => |x| x,
+        i32 => |x| x,
+        else => unreachable,
+    };
+    _ = x;
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:7:17: error: switch on type 'type' provides no expression parameter
diff --git a/test/cases/compile_errors/stage1/obj/switch_with_overlapping_case_ranges.zig b/test/cases/compile_errors/stage1/obj/switch_with_overlapping_case_ranges.zig
new file mode 100644
index 0000000000000000000000000000000000000000..1b03d3fe54078d85b6109bbbf916f0f637ba5d6a
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/switch_with_overlapping_case_ranges.zig
@@ -0,0 +1,13 @@
+export fn entry() void {
+    var q: u8 = 0;
+    switch (q) {
+        1...2 => {},
+        0...255 => {},
+    }
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:5:9: error: duplicate switch value
diff --git a/test/cases/compile_errors/stage1/obj/tagName_used_on_union_with_no_associated_enum_tag.zig b/test/cases/compile_errors/stage1/obj/tagName_used_on_union_with_no_associated_enum_tag.zig
new file mode 100644
index 0000000000000000000000000000000000000000..efd9b8ceefc944bc02f8cd65f808771bc712bd70
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/tagName_used_on_union_with_no_associated_enum_tag.zig
@@ -0,0 +1,16 @@
+const FloatInt = extern union {
+    Float: f32,
+    Int: i32,
+};
+export fn entry() void {
+    var fi = FloatInt{.Float = 123.45};
+    var tagName = @tagName(fi);
+    _ = tagName;
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:7:19: error: union has no associated enum
+// tmp.zig:1:18: note: declared here
diff --git a/test/cases/compile_errors/stage1/obj/take_slice_of_invalid_dereference.zig b/test/cases/compile_errors/stage1/obj/take_slice_of_invalid_dereference.zig
new file mode 100644
index 0000000000000000000000000000000000000000..c039be373778354fee485a624a66d1e34aade8c6
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/take_slice_of_invalid_dereference.zig
@@ -0,0 +1,10 @@
+export fn entry() void {
+    const x = 'a'.*[0..];
+    _ = x;
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:2:18: error: attempt to dereference non-pointer type 'comptime_int'
diff --git a/test/cases/compile_errors/stage1/obj/taking_bit_offset_of_void_field_in_struct.zig b/test/cases/compile_errors/stage1/obj/taking_bit_offset_of_void_field_in_struct.zig
new file mode 100644
index 0000000000000000000000000000000000000000..e404c3bdd698fe4b4fa42774a841ebe7191c68c9
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/taking_bit_offset_of_void_field_in_struct.zig
@@ -0,0 +1,13 @@
+const Empty = struct {
+    val: void,
+};
+export fn foo() void {
+    const fieldOffset = @bitOffsetOf(Empty, "val",);
+    _ = fieldOffset;
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:5:45: error: zero-bit field 'val' in struct 'Empty' has no offset
diff --git a/test/cases/compile_errors/stage1/obj/taking_byte_offset_of_void_field_in_struct.zig b/test/cases/compile_errors/stage1/obj/taking_byte_offset_of_void_field_in_struct.zig
new file mode 100644
index 0000000000000000000000000000000000000000..eb7d83efff7c9049cc68118178b5dd3d29a78506
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/taking_byte_offset_of_void_field_in_struct.zig
@@ -0,0 +1,13 @@
+const Empty = struct {
+    val: void,
+};
+export fn foo() void {
+    const fieldOffset = @offsetOf(Empty, "val",);
+    _ = fieldOffset;
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:5:42: error: zero-bit field 'val' in struct 'Empty' has no offset
diff --git a/test/cases/compile_errors/stage1/obj/threadlocal_qualifier_on_const.zig b/test/cases/compile_errors/stage1/obj/threadlocal_qualifier_on_const.zig
new file mode 100644
index 0000000000000000000000000000000000000000..d34ba06879c2d6b0107941a1e4bbdd97bcf7ab7d
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/threadlocal_qualifier_on_const.zig
@@ -0,0 +1,10 @@
+threadlocal const x: i32 = 1234;
+export fn entry() i32 {
+    return x;
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:1:1: error: threadlocal variable cannot be constant
diff --git a/test/cases/compile_errors/stage1/obj/top_level_decl_dependency_loop.zig b/test/cases/compile_errors/stage1/obj/top_level_decl_dependency_loop.zig
new file mode 100644
index 0000000000000000000000000000000000000000..ac70285c9ca3d275b281d1898a8a59dced06511f
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/top_level_decl_dependency_loop.zig
@@ -0,0 +1,12 @@
+const a : @TypeOf(b) = 0;
+const b : @TypeOf(a) = 0;
+export fn entry() void {
+    const c = a + b;
+    _ = c;
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:2:19: error: dependency loop detected
diff --git a/test/cases/compile_errors/stage1/obj/truncate_sign_mismatch.zig b/test/cases/compile_errors/stage1/obj/truncate_sign_mismatch.zig
new file mode 100644
index 0000000000000000000000000000000000000000..8434d9ed16da32a0f0052227d147a1ca94dbe715
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/truncate_sign_mismatch.zig
@@ -0,0 +1,25 @@
+export fn entry1() i8 {
+    var x: u32 = 10;
+    return @truncate(i8, x);
+}
+export fn entry2() u8 {
+    var x: i32 = -10;
+    return @truncate(u8, x);
+}
+export fn entry3() i8 {
+    comptime var x: u32 = 10;
+    return @truncate(i8, x);
+}
+export fn entry4() u8 {
+    comptime var x: i32 = -10;
+    return @truncate(u8, x);
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:3:26: error: expected signed integer type, found 'u32'
+// tmp.zig:7:26: error: expected unsigned integer type, found 'i32'
+// tmp.zig:11:26: error: expected signed integer type, found 'u32'
+// tmp.zig:15:26: error: expected unsigned integer type, found 'i32'
diff --git a/test/cases/compile_errors/stage1/obj/truncate_undefined_value.zig b/test/cases/compile_errors/stage1/obj/truncate_undefined_value.zig
new file mode 100644
index 0000000000000000000000000000000000000000..67a1f17ba783dfbd83c79483ba8f78e7ea0f1f47
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/truncate_undefined_value.zig
@@ -0,0 +1,10 @@
+export fn entry() void {
+    var z = @truncate(u8, @as(u16, undefined));
+    _ = z;
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:2:27: error: use of undefined value here causes undefined behavior
diff --git a/test/cases/compile_errors/stage1/obj/try_in_function_with_non_error_return_type.zig b/test/cases/compile_errors/stage1/obj/try_in_function_with_non_error_return_type.zig
new file mode 100644
index 0000000000000000000000000000000000000000..c00fa2709f726bfe0b8da730520e9b3fa546c9ba
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/try_in_function_with_non_error_return_type.zig
@@ -0,0 +1,10 @@
+export fn f() void {
+    try something();
+}
+fn something() anyerror!void { }
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:2:5: error: expected type 'void', found 'anyerror'
diff --git a/test/cases/compile_errors/stage1/obj/type_checking_function_pointers.zig b/test/cases/compile_errors/stage1/obj/type_checking_function_pointers.zig
new file mode 100644
index 0000000000000000000000000000000000000000..b88b6bdb520883c4019119306e8ae18c58d1d09d
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/type_checking_function_pointers.zig
@@ -0,0 +1,13 @@
+fn a(b: fn (*const u8) void) void {
+    b('a');
+}
+fn c(d: u8) void {_ = d;}
+export fn entry() void {
+    a(c);
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:6:7: error: expected type 'fn(*const u8) void', found 'fn(u8) void'
diff --git a/test/cases/compile_errors/stage1/obj/type_variables_must_be_constant.zig b/test/cases/compile_errors/stage1/obj/type_variables_must_be_constant.zig
new file mode 100644
index 0000000000000000000000000000000000000000..f8cadf8520e55f99c3c8d1e623bc22dc91ff0494
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/type_variables_must_be_constant.zig
@@ -0,0 +1,10 @@
+var foo = u8;
+export fn entry() foo {
+    return 1;
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:1:1: error: variable of type 'type' must be constant
diff --git a/test/cases/compile_errors/stage1/obj/undeclared_identifier.zig b/test/cases/compile_errors/stage1/obj/undeclared_identifier.zig
new file mode 100644
index 0000000000000000000000000000000000000000..297a618eb8978af2398460dfaeea449a6af0ca7e
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/undeclared_identifier.zig
@@ -0,0 +1,11 @@
+export fn a() void {
+    return
+    b +
+    c;
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:3:5: error: use of undeclared identifier 'b'
diff --git a/test/cases/compile_errors/stage1/obj/undeclared_identifier_error_should_mark_fn_as_impure.zig b/test/cases/compile_errors/stage1/obj/undeclared_identifier_error_should_mark_fn_as_impure.zig
new file mode 100644
index 0000000000000000000000000000000000000000..697b7ccb55db0f3ff23265d131f2584e2f8cb0b9
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/undeclared_identifier_error_should_mark_fn_as_impure.zig
@@ -0,0 +1,12 @@
+export fn foo() void {
+    test_a_thing();
+}
+fn test_a_thing() void {
+    bad_fn_call();
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:5:5: error: use of undeclared identifier 'bad_fn_call'
diff --git a/test/cases/compile_errors/stage1/obj/undeclared_identifier_in_unanalyzed_branch.zig b/test/cases/compile_errors/stage1/obj/undeclared_identifier_in_unanalyzed_branch.zig
new file mode 100644
index 0000000000000000000000000000000000000000..2efa8ca115ac96fb9b91edfc07cd81c22957ce69
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/undeclared_identifier_in_unanalyzed_branch.zig
@@ -0,0 +1,11 @@
+export fn a() void {
+    if (false) {
+        lol_this_doesnt_exist = nonsense;
+    }
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:3:9: error: use of undeclared identifier 'lol_this_doesnt_exist'
diff --git a/test/cases/compile_errors/stage1/obj/undefined_as_field_type_is_rejected.zig b/test/cases/compile_errors/stage1/obj/undefined_as_field_type_is_rejected.zig
new file mode 100644
index 0000000000000000000000000000000000000000..b6eb059661c10877af4c38e0e120196ae482960e
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/undefined_as_field_type_is_rejected.zig
@@ -0,0 +1,13 @@
+const Foo = struct {
+    a: undefined,
+};
+export fn entry1() void {
+    const foo: Foo = undefined;
+    _ = foo;
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:2:8: error: use of undefined value here causes undefined behavior
diff --git a/test/cases/compile_errors/stage1/obj/undefined_function_call.zig b/test/cases/compile_errors/stage1/obj/undefined_function_call.zig
new file mode 100644
index 0000000000000000000000000000000000000000..a9627961fe514824e433319bc959dc413b108aff
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/undefined_function_call.zig
@@ -0,0 +1,9 @@
+export fn a() void {
+    b();
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:2:5: error: use of undeclared identifier 'b'
diff --git a/test/cases/compile_errors/stage1/obj/underscore_is_not_a_declarable_symbol.zig b/test/cases/compile_errors/stage1/obj/underscore_is_not_a_declarable_symbol.zig
new file mode 100644
index 0000000000000000000000000000000000000000..f4318af8fd085db48ca01898965fe29a25d3fb28
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/underscore_is_not_a_declarable_symbol.zig
@@ -0,0 +1,10 @@
+export fn f1() usize {
+    var _: usize = 2;
+    return _;
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:2:9: error: '_' used as an identifier without @"_" syntax
diff --git a/test/cases/compile_errors/stage1/obj/underscore_should_not_be_usable_inside_for.zig b/test/cases/compile_errors/stage1/obj/underscore_should_not_be_usable_inside_for.zig
new file mode 100644
index 0000000000000000000000000000000000000000..fe89c8372d6fa93d84df83f5dc0b9bd422a01cfa
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/underscore_should_not_be_usable_inside_for.zig
@@ -0,0 +1,13 @@
+export fn returns() void {
+    for ([_]void{}) |_, i| {
+        for ([_]void{}) |_, j| {
+            return _;
+        }
+    }
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:4:20: error: '_' used as an identifier without @"_" syntax
diff --git a/test/cases/compile_errors/stage1/obj/underscore_should_not_be_usable_inside_while.zig b/test/cases/compile_errors/stage1/obj/underscore_should_not_be_usable_inside_while.zig
new file mode 100644
index 0000000000000000000000000000000000000000..7f694e06031349b551bdc3bd2f21136e05c59f55
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/underscore_should_not_be_usable_inside_while.zig
@@ -0,0 +1,16 @@
+export fn returns() void {
+    while (optionalReturn()) |_| {
+        while (optionalReturn()) |_| {
+            return _;
+        }
+    }
+}
+fn optionalReturn() ?u32 {
+    return 1;
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:4:20: error: '_' used as an identifier without @"_" syntax
diff --git a/test/cases/compile_errors/stage1/obj/underscore_should_not_be_usable_inside_while_else.zig b/test/cases/compile_errors/stage1/obj/underscore_should_not_be_usable_inside_while_else.zig
new file mode 100644
index 0000000000000000000000000000000000000000..87a705ee698afa010defbdc94d540c3f6e41910f
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/underscore_should_not_be_usable_inside_while_else.zig
@@ -0,0 +1,18 @@
+export fn returns() void {
+    while (optionalReturnError()) |_| {
+        while (optionalReturnError()) |_| {
+            return;
+        } else |_| {
+            if (_ == error.optionalReturnError) return;
+        }
+    }
+}
+fn optionalReturnError() !?u32 {
+    return error.optionalReturnError;
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:6:17: error: '_' used as an identifier without @"_" syntax
diff --git a/test/cases/compile_errors/stage1/obj/union_auto-enum_value_already_taken.zig b/test/cases/compile_errors/stage1/obj/union_auto-enum_value_already_taken.zig
new file mode 100644
index 0000000000000000000000000000000000000000..3b00f95ff953f51e464a35e0468fa40bdde282c7
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/union_auto-enum_value_already_taken.zig
@@ -0,0 +1,18 @@
+const MultipleChoice = union(enum(u32)) {
+    A = 20,
+    B = 40,
+    C = 60,
+    D = 1000,
+    E = 60,
+};
+export fn entry() void {
+    var x = MultipleChoice { .C = {} };
+    _ = x;
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:6:9: error: enum tag value 60 already taken
+// tmp.zig:4:9: note: other occurrence here
diff --git a/test/cases/compile_errors/stage1/obj/union_enum_field_does_not_match_enum.zig b/test/cases/compile_errors/stage1/obj/union_enum_field_does_not_match_enum.zig
new file mode 100644
index 0000000000000000000000000000000000000000..38260091dc4a249657cdae7af6184db042b34177
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/union_enum_field_does_not_match_enum.zig
@@ -0,0 +1,22 @@
+const Letter = enum {
+    A,
+    B,
+    C,
+};
+const Payload = union(Letter) {
+    A: i32,
+    B: f64,
+    C: bool,
+    D: bool,
+};
+export fn entry() void {
+    var a = Payload {.A = 1234};
+    _ = a;
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:10:5: error: enum field not found: 'D'
+// tmp.zig:1:16: note: enum declared here
diff --git a/test/cases/compile_errors/stage1/obj/union_fields_with_value_assignments.zig b/test/cases/compile_errors/stage1/obj/union_fields_with_value_assignments.zig
new file mode 100644
index 0000000000000000000000000000000000000000..94568d55c3aef0032243009e50ae8d598b2bf7c3
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/union_fields_with_value_assignments.zig
@@ -0,0 +1,14 @@
+const MultipleChoice = union {
+    A: i32 = 20,
+};
+export fn entry() void {
+    var x: MultipleChoice = undefined;
+    _ = x;
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:1:24: error: explicitly valued tagged union missing integer tag type
+// tmp.zig:2:14: note: tag value specified here
diff --git a/test/cases/compile_errors/stage1/obj/union_with_0_fields.zig b/test/cases/compile_errors/stage1/obj/union_with_0_fields.zig
new file mode 100644
index 0000000000000000000000000000000000000000..a6f3d69faa49f63d86a2d7fac6b480fdad0a5286
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/union_with_0_fields.zig
@@ -0,0 +1,7 @@
+const Foo = union {};
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:1:13: error: union declarations must have at least one tag
diff --git a/test/cases/compile_errors/stage1/obj/union_with_specified_enum_omits_field.zig b/test/cases/compile_errors/stage1/obj/union_with_specified_enum_omits_field.zig
new file mode 100644
index 0000000000000000000000000000000000000000..0bb677a18cdb128090acdbcdcba57079bbc3fdef
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/union_with_specified_enum_omits_field.zig
@@ -0,0 +1,19 @@
+const Letter = enum {
+    A,
+    B,
+    C,
+};
+const Payload = union(Letter) {
+    A: i32,
+    B: f64,
+};
+export fn entry() usize {
+    return @sizeOf(Payload);
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:6:17: error: enum field missing: 'C'
+// tmp.zig:4:5: note: declared here
diff --git a/test/cases/compile_errors/stage1/obj/union_with_too_small_explicit_signed_tag_type.zig b/test/cases/compile_errors/stage1/obj/union_with_too_small_explicit_signed_tag_type.zig
new file mode 100644
index 0000000000000000000000000000000000000000..97f4d48f6b84cc8dbf16ee1715a97a8c81b7ceab
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/union_with_too_small_explicit_signed_tag_type.zig
@@ -0,0 +1,16 @@
+const U = union(enum(i2)) {
+    A: u8,
+    B: u8,
+    C: u8,
+    D: u8,
+};
+export fn entry() void {
+    _ = U{ .D = 1 };
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:1:22: error: specified integer tag type cannot represent every field
+// tmp.zig:1:22: note: type i2 cannot fit values in range 0...3
diff --git a/test/cases/compile_errors/stage1/obj/union_with_too_small_explicit_unsigned_tag_type.zig b/test/cases/compile_errors/stage1/obj/union_with_too_small_explicit_unsigned_tag_type.zig
new file mode 100644
index 0000000000000000000000000000000000000000..c1496ade86dc5e8bb1b8173dd6afe22602568c7c
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/union_with_too_small_explicit_unsigned_tag_type.zig
@@ -0,0 +1,17 @@
+const U = union(enum(u2)) {
+    A: u8,
+    B: u8,
+    C: u8,
+    D: u8,
+    E: u8,
+};
+export fn entry() void {
+    _ = U{ .E = 1 };
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:1:22: error: specified integer tag type cannot represent every field
+// tmp.zig:1:22: note: type u2 cannot fit values in range 0...4
diff --git a/test/cases/compile_errors/stage1/obj/unknown_length_pointer_to_opaque.zig b/test/cases/compile_errors/stage1/obj/unknown_length_pointer_to_opaque.zig
new file mode 100644
index 0000000000000000000000000000000000000000..d155b986d718b90b2f09febfc1a6dd7134c2c114
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/unknown_length_pointer_to_opaque.zig
@@ -0,0 +1,7 @@
+export const T = [*]opaque {};
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:1:21: error: unknown-length pointer to opaque
diff --git a/test/cases/compile_errors/stage1/obj/unreachable_code-double_break.zig b/test/cases/compile_errors/stage1/obj/unreachable_code-double_break.zig
new file mode 100644
index 0000000000000000000000000000000000000000..0a19337af844a7fae0915f4d8ac9fbf64c7b47a1
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/unreachable_code-double_break.zig
@@ -0,0 +1,12 @@
+export fn a() void {
+    const b = blk: {
+        break :blk break :blk @as(u32, 1);
+    };
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:3:9: error: unreachable code
+// tmp.zig:3:20: note: control flow is diverted here
diff --git a/test/cases/compile_errors/stage1/obj/unreachable_code-nested_returns.zig b/test/cases/compile_errors/stage1/obj/unreachable_code-nested_returns.zig
new file mode 100644
index 0000000000000000000000000000000000000000..8a80fcd161c2d5c7f18c6398d5bd59a20dd7bf02
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/unreachable_code-nested_returns.zig
@@ -0,0 +1,10 @@
+export fn a() i32 {
+    return return 1;
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:2:5: error: unreachable code
+// tmp.zig:2:12: note: control flow is diverted here
diff --git a/test/cases/compile_errors/stage1/obj/unreachable_code.zig b/test/cases/compile_errors/stage1/obj/unreachable_code.zig
new file mode 100644
index 0000000000000000000000000000000000000000..30a92d06bf6f48883da302015a404e381cf0476f
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/unreachable_code.zig
@@ -0,0 +1,13 @@
+export fn a() void {
+    return;
+    b();
+}
+
+fn b() void {}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:3:6: error: unreachable code
+// tmp.zig:2:5: note: control flow is diverted here
diff --git a/test/cases/compile_errors/stage1/obj/unreachable_executed_at_comptime.zig b/test/cases/compile_errors/stage1/obj/unreachable_executed_at_comptime.zig
new file mode 100644
index 0000000000000000000000000000000000000000..34cb354e941656f8dd8790da9c1e40a71ed456e5
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/unreachable_executed_at_comptime.zig
@@ -0,0 +1,16 @@
+fn foo(comptime x: i32) i32 {
+    comptime {
+        if (x >= 0) return -x;
+        unreachable;
+    }
+}
+export fn entry() void {
+    _ = foo(-42);
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:4:9: error: reached unreachable code
+// tmp.zig:8:12: note: called from here
diff --git a/test/cases/compile_errors/stage1/obj/unreachable_parameter.zig b/test/cases/compile_errors/stage1/obj/unreachable_parameter.zig
new file mode 100644
index 0000000000000000000000000000000000000000..296194f7e33dbd4e59d0fbb6831664b8fe586426
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/unreachable_parameter.zig
@@ -0,0 +1,8 @@
+fn f(a: noreturn) void { _ = a; }
+export fn entry() void { f(); }
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:1:9: error: parameter of type 'noreturn' not allowed
diff --git a/test/cases/compile_errors/stage1/obj/unreachable_variable.zig b/test/cases/compile_errors/stage1/obj/unreachable_variable.zig
new file mode 100644
index 0000000000000000000000000000000000000000..7f822a8bceb9fe50102f6a50c9f9849ac047de15
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/unreachable_variable.zig
@@ -0,0 +1,10 @@
+export fn f() void {
+    const a: noreturn = {};
+    _ = a;
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:2:25: error: expected type 'noreturn', found 'void'
diff --git a/test/cases/compile_errors/stage1/obj/unreachable_with_return.zig b/test/cases/compile_errors/stage1/obj/unreachable_with_return.zig
new file mode 100644
index 0000000000000000000000000000000000000000..6410d24913a4ad88416b445dbd87600eb352b6e5
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/unreachable_with_return.zig
@@ -0,0 +1,8 @@
+fn a() noreturn {return;}
+export fn entry() void { a(); }
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:1:18: error: expected type 'noreturn', found 'void'
diff --git a/test/cases/compile_errors/stage1/obj/unsupported_modifier_at_start_of_asm_output_constraint.zig b/test/cases/compile_errors/stage1/obj/unsupported_modifier_at_start_of_asm_output_constraint.zig
new file mode 100644
index 0000000000000000000000000000000000000000..7c70fc509528aa9ef19f024d606cf8c507f8457f
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/unsupported_modifier_at_start_of_asm_output_constraint.zig
@@ -0,0 +1,10 @@
+export fn foo() void {
+    var bar: u32 = 3;
+    asm volatile ("" : [baz]"+r"(bar) : : "");
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// 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
diff --git a/test/cases/compile_errors/stage1/obj/unused_variable_error_on_errdefer.zig b/test/cases/compile_errors/stage1/obj/unused_variable_error_on_errdefer.zig
new file mode 100644
index 0000000000000000000000000000000000000000..b85d5729dcf8f62c23cdee35a1a3fa873ff42768
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/unused_variable_error_on_errdefer.zig
@@ -0,0 +1,13 @@
+fn foo() !void {
+    errdefer |a| unreachable;
+    return error.A;
+}
+export fn entry() void {
+    foo() catch unreachable;
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:2:15: error: unused variable: 'a'
diff --git a/test/cases/compile_errors/stage1/obj/use_anyopaque_as_return_type_of_fn_ptr.zig b/test/cases/compile_errors/stage1/obj/use_anyopaque_as_return_type_of_fn_ptr.zig
new file mode 100644
index 0000000000000000000000000000000000000000..ef2787ca75abc320a298bdabe29065ab350b2c48
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/use_anyopaque_as_return_type_of_fn_ptr.zig
@@ -0,0 +1,10 @@
+export fn entry() void {
+    const a: fn () anyopaque = undefined;
+    _ = a;
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:2:20: error: return type cannot be opaque
diff --git a/test/cases/compile_errors/stage1/obj/use_implicit_casts_to_assign_null_to_non-nullable_pointer.zig b/test/cases/compile_errors/stage1/obj/use_implicit_casts_to_assign_null_to_non-nullable_pointer.zig
new file mode 100644
index 0000000000000000000000000000000000000000..4263f38e3e8c56d9bc77513de039fef49060c39a
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/use_implicit_casts_to_assign_null_to_non-nullable_pointer.zig
@@ -0,0 +1,14 @@
+export fn entry() void {
+    var x: i32 = 1234;
+    var p: *i32 = &x;
+    var pp: *?*i32 = &p;
+    pp.* = null;
+    var y = p.*;
+    _ = y;
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:4:23: error: expected type '*?*i32', found '**i32'
diff --git a/test/cases/compile_errors/stage1/obj/use_invalid_number_literal_as_array_index.zig b/test/cases/compile_errors/stage1/obj/use_invalid_number_literal_as_array_index.zig
new file mode 100644
index 0000000000000000000000000000000000000000..b1d0aaa6f47ec8ccdd11f73a53d58ae8c351386c
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/use_invalid_number_literal_as_array_index.zig
@@ -0,0 +1,11 @@
+var v = 25;
+export fn entry() void {
+    var arr: [v]u8 = undefined;
+    _ = arr;
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:1:1: error: unable to infer variable type
diff --git a/test/cases/compile_errors/stage1/obj/use_of_comptime-known_undefined_function_value.zig b/test/cases/compile_errors/stage1/obj/use_of_comptime-known_undefined_function_value.zig
new file mode 100644
index 0000000000000000000000000000000000000000..3500b13dfc21df3fa6fe0eab59da94cf47884da7
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/use_of_comptime-known_undefined_function_value.zig
@@ -0,0 +1,13 @@
+const Cmd = struct {
+    exec: fn () void,
+};
+export fn entry() void {
+    const command = Cmd{ .exec = undefined };
+    command.exec();
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:6:12: error: use of undefined value here causes undefined behavior
diff --git a/test/cases/compile_errors/stage1/obj/use_of_undeclared_identifier.zig b/test/cases/compile_errors/stage1/obj/use_of_undeclared_identifier.zig
new file mode 100644
index 0000000000000000000000000000000000000000..c1297731a30de29d0538068a391507011a99c383
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/use_of_undeclared_identifier.zig
@@ -0,0 +1,9 @@
+export fn f() void {
+    b = 3;
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:2:5: error: use of undeclared identifier 'b'
diff --git a/test/cases/compile_errors/stage1/obj/using_an_unknown_len_ptr_type_instead_of_array.zig b/test/cases/compile_errors/stage1/obj/using_an_unknown_len_ptr_type_instead_of_array.zig
new file mode 100644
index 0000000000000000000000000000000000000000..3124b057a81d365e0bf47552bc15be21f8d14bf3
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/using_an_unknown_len_ptr_type_instead_of_array.zig
@@ -0,0 +1,13 @@
+const resolutions = [*][*]const u8{
+    "[320 240  ]",
+    null,
+};
+comptime {
+    _ = resolutions;
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:1:21: error: expected array type or [_], found '[*][*]const u8'
diff --git a/test/cases/compile_errors/stage1/obj/using_invalid_types_in_function_call_raises_an_error.zig b/test/cases/compile_errors/stage1/obj/using_invalid_types_in_function_call_raises_an_error.zig
new file mode 100644
index 0000000000000000000000000000000000000000..f1fda15ea75a7395f3f9316fbf7ccda770c02fe8
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/using_invalid_types_in_function_call_raises_an_error.zig
@@ -0,0 +1,11 @@
+const MenuEffect = enum {};
+fn func(effect: MenuEffect) void { _ = effect; }
+export fn entry() void {
+    func(MenuEffect.ThisDoesNotExist);
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:1:20: error: enum declarations must have at least one tag
diff --git a/test/cases/compile_errors/stage1/obj/usingnamespace_with_wrong_type.zig b/test/cases/compile_errors/stage1/obj/usingnamespace_with_wrong_type.zig
new file mode 100644
index 0000000000000000000000000000000000000000..86b5f0dcfb3daa295b711d20871b595b68a75331
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/usingnamespace_with_wrong_type.zig
@@ -0,0 +1,7 @@
+usingnamespace void;
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:1:1: error: expected struct, enum, or union; found 'void'
diff --git a/test/cases/compile_errors/stage1/obj/variable_has_wrong_type.zig b/test/cases/compile_errors/stage1/obj/variable_has_wrong_type.zig
new file mode 100644
index 0000000000000000000000000000000000000000..52dcf150de0e57ad064cc6c702a9d06d221e06e7
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/variable_has_wrong_type.zig
@@ -0,0 +1,10 @@
+export fn f() i32 {
+    const a = "a";
+    return a;
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:3:12: error: expected type 'i32', found '*const [1:0]u8'
diff --git a/test/cases/compile_errors/stage1/obj/variable_in_inline_assembly_template_cannot_be_found.zig b/test/cases/compile_errors/stage1/obj/variable_in_inline_assembly_template_cannot_be_found.zig
new file mode 100644
index 0000000000000000000000000000000000000000..7636b501fd0237702050f200014cd065a85a602c
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/variable_in_inline_assembly_template_cannot_be_found.zig
@@ -0,0 +1,12 @@
+export fn entry() void {
+    var sp = asm volatile ("mov %[foo], sp"
+        : [bar] "=r" (-> usize),
+    );
+    _ = sp;
+}
+
+// error
+// backend=stage1
+// target=x86_64-linux-gnu
+//
+// tmp.zig:2:14: error: could not find 'foo' in the inputs or outputs
diff --git a/test/cases/compile_errors/stage1/obj/variable_initialization_compile_error_then_referenced.zig b/test/cases/compile_errors/stage1/obj/variable_initialization_compile_error_then_referenced.zig
new file mode 100644
index 0000000000000000000000000000000000000000..91b70481a1955cb6c9b77f59e502c1ca1ca7406c
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/variable_initialization_compile_error_then_referenced.zig
@@ -0,0 +1,19 @@
+fn Undeclared() type {
+    return T;
+}
+fn Gen() type {
+    const X = Undeclared();
+    return struct {
+        x: X,
+    };
+}
+export fn entry() void {
+    const S = Gen();
+    _ = S;
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:2:12: error: use of undeclared identifier 'T'
diff --git a/test/cases/compile_errors/stage1/obj/variable_with_type_noreturn.zig b/test/cases/compile_errors/stage1/obj/variable_with_type_noreturn.zig
new file mode 100644
index 0000000000000000000000000000000000000000..e2ba9183be83259ca69bc9f3fe4309189c59ffbe
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/variable_with_type_noreturn.zig
@@ -0,0 +1,10 @@
+export fn entry9() void {
+    var z: noreturn = return;
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:2:5: error: unreachable code
+// tmp.zig:2:23: note: control flow is diverted here
diff --git a/test/cases/compile_errors/stage1/obj/vector_index_out_of_bounds.zig b/test/cases/compile_errors/stage1/obj/vector_index_out_of_bounds.zig
new file mode 100644
index 0000000000000000000000000000000000000000..fdffd8b45567777d9dc61263f24a724d019a9431
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/vector_index_out_of_bounds.zig
@@ -0,0 +1,10 @@
+export fn entry() void {
+    const x = @import("std").meta.Vector(3, f32){ 25, 75, 5, 0 };
+    _ = x;
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:2:62: error: index 3 outside vector of size 3
diff --git a/test/cases/compile_errors/stage1/obj/volatile_on_global_assembly.zig b/test/cases/compile_errors/stage1/obj/volatile_on_global_assembly.zig
new file mode 100644
index 0000000000000000000000000000000000000000..2157fe6a71f5f1542665f595bd7ba9b17350d658
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/volatile_on_global_assembly.zig
@@ -0,0 +1,9 @@
+comptime {
+    asm volatile ("");
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:2:9: error: volatile is meaningless on global assembly
diff --git a/test/cases/compile_errors/stage1/obj/wasmMemoryGrow_is_a_compile_error_in_non-Wasm_targets.zig b/test/cases/compile_errors/stage1/obj/wasmMemoryGrow_is_a_compile_error_in_non-Wasm_targets.zig
new file mode 100644
index 0000000000000000000000000000000000000000..6eda076f1228d801fabb8332ebf29ab7aa206c68
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/wasmMemoryGrow_is_a_compile_error_in_non-Wasm_targets.zig
@@ -0,0 +1,10 @@
+export fn foo() void {
+    _ = @wasmMemoryGrow(0, 1);
+    return;
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:2:9: error: @wasmMemoryGrow is a wasm32 feature only
diff --git a/test/cases/compile_errors/stage1/obj/wasmMemorySize_is_a_compile_error_in_non-Wasm_targets.zig b/test/cases/compile_errors/stage1/obj/wasmMemorySize_is_a_compile_error_in_non-Wasm_targets.zig
new file mode 100644
index 0000000000000000000000000000000000000000..9bdf81073f755cf1f8365da1e3a08548104de45c
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/wasmMemorySize_is_a_compile_error_in_non-Wasm_targets.zig
@@ -0,0 +1,10 @@
+export fn foo() void {
+    _ = @wasmMemorySize(0);
+    return;
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:2:9: error: @wasmMemorySize is a wasm32 feature only
diff --git a/test/cases/compile_errors/stage1/obj/while_expected_bool_got_error_union.zig b/test/cases/compile_errors/stage1/obj/while_expected_bool_got_error_union.zig
new file mode 100644
index 0000000000000000000000000000000000000000..9fc327e6c9b24a4052063387e1406b6f38dc1b73
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/while_expected_bool_got_error_union.zig
@@ -0,0 +1,10 @@
+export fn foo() void {
+    while (bar()) {}
+}
+fn bar() anyerror!i32 { return 1; }
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:2:15: error: expected type 'bool', found 'anyerror!i32'
diff --git a/test/cases/compile_errors/stage1/obj/while_expected_bool_got_optional.zig b/test/cases/compile_errors/stage1/obj/while_expected_bool_got_optional.zig
new file mode 100644
index 0000000000000000000000000000000000000000..5948d627867a3b3f7dd97a58d2de58d1bbca4f91
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/while_expected_bool_got_optional.zig
@@ -0,0 +1,10 @@
+export fn foo() void {
+    while (bar()) {}
+}
+fn bar() ?i32 { return 1; }
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:2:15: error: expected type 'bool', found '?i32'
diff --git a/test/cases/compile_errors/stage1/obj/while_expected_error_union_got_bool.zig b/test/cases/compile_errors/stage1/obj/while_expected_error_union_got_bool.zig
new file mode 100644
index 0000000000000000000000000000000000000000..b8a72e97937e454aa404e0c744fef8549d33d4ce
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/while_expected_error_union_got_bool.zig
@@ -0,0 +1,10 @@
+export fn foo() void {
+    while (bar()) |x| {_ = x;} else |err| {_ = err;}
+}
+fn bar() bool { return true; }
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:2:15: error: expected error union type, found 'bool'
diff --git a/test/cases/compile_errors/stage1/obj/while_expected_error_union_got_optional.zig b/test/cases/compile_errors/stage1/obj/while_expected_error_union_got_optional.zig
new file mode 100644
index 0000000000000000000000000000000000000000..c933dc95092aa2bc4637f9dd9498cfe8771496a1
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/while_expected_error_union_got_optional.zig
@@ -0,0 +1,10 @@
+export fn foo() void {
+    while (bar()) |x| {_ = x;} else |err| {_ = err;}
+}
+fn bar() ?i32 { return 1; }
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:2:15: error: expected error union type, found '?i32'
diff --git a/test/cases/compile_errors/stage1/obj/while_expected_optional_got_bool.zig b/test/cases/compile_errors/stage1/obj/while_expected_optional_got_bool.zig
new file mode 100644
index 0000000000000000000000000000000000000000..0458d1ba0179951341bfbbf6e2d78df4ab315a02
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/while_expected_optional_got_bool.zig
@@ -0,0 +1,10 @@
+export fn foo() void {
+    while (bar()) |x| {_ = x;}
+}
+fn bar() bool { return true; }
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:2:15: error: expected optional type, found 'bool'
diff --git a/test/cases/compile_errors/stage1/obj/while_expected_optional_got_error_union.zig b/test/cases/compile_errors/stage1/obj/while_expected_optional_got_error_union.zig
new file mode 100644
index 0000000000000000000000000000000000000000..7cdbd2cccf69ad800659f21f13eabaa6177f6757
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/while_expected_optional_got_error_union.zig
@@ -0,0 +1,10 @@
+export fn foo() void {
+    while (bar()) |x| {_ = x;}
+}
+fn bar() anyerror!i32 { return 1; }
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:2:15: error: expected optional type, found 'anyerror!i32'
diff --git a/test/cases/compile_errors/stage1/obj/while_loop_body_expression_ignored.zig b/test/cases/compile_errors/stage1/obj/while_loop_body_expression_ignored.zig
new file mode 100644
index 0000000000000000000000000000000000000000..9542cbc62f00cb6e3473f6b546ac06c9ac82f0b4
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/while_loop_body_expression_ignored.zig
@@ -0,0 +1,22 @@
+fn returns() usize {
+    return 2;
+}
+export fn f1() void {
+    while (true) returns();
+}
+export fn f2() void {
+    var x: ?i32 = null;
+    while (x) |_| returns();
+}
+export fn f3() void {
+    var x: anyerror!i32 = error.Bad;
+    while (x) |_| returns() else |_| unreachable;
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:5:25: error: expression value is ignored
+// tmp.zig:9:26: error: expression value is ignored
+// tmp.zig:13:26: error: expression value is ignored
diff --git a/test/cases/compile_errors/stage1/obj/write_to_const_global_variable.zig b/test/cases/compile_errors/stage1/obj/write_to_const_global_variable.zig
new file mode 100644
index 0000000000000000000000000000000000000000..4ce93e6b519fe0f52971bb42b3bb44b8908daa9c
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/write_to_const_global_variable.zig
@@ -0,0 +1,11 @@
+const x : i32 = 99;
+fn f() void {
+    x = 1;
+}
+export fn entry() void { f(); }
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:3:9: error: cannot assign to constant
diff --git a/test/cases/compile_errors/stage1/obj/wrong_frame_type_used_for_async_call.zig b/test/cases/compile_errors/stage1/obj/wrong_frame_type_used_for_async_call.zig
new file mode 100644
index 0000000000000000000000000000000000000000..c02c20f495d8760272493a144f2054264cf474f6
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/wrong_frame_type_used_for_async_call.zig
@@ -0,0 +1,16 @@
+export fn entry() void {
+    var frame: @Frame(foo) = undefined;
+    frame = async bar();
+}
+fn foo() void {
+    suspend {}
+}
+fn bar() void {
+    suspend {}
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:3:13: error: expected type '*@Frame(bar)', found '*@Frame(foo)'
diff --git a/test/cases/compile_errors/stage1/obj/wrong_function_type.zig b/test/cases/compile_errors/stage1/obj/wrong_function_type.zig
new file mode 100644
index 0000000000000000000000000000000000000000..58f4477601d3fe33c7d688e8597adff387a5641c
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/wrong_function_type.zig
@@ -0,0 +1,11 @@
+const fns = [_]fn() void { a, b, c };
+fn a() i32 {return 0;}
+fn b() i32 {return 1;}
+fn c() i32 {return 2;}
+export fn entry() usize { return @sizeOf(@TypeOf(fns)); }
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:1:28: error: expected type 'fn() void', found 'fn() i32'
diff --git a/test/cases/compile_errors/stage1/obj/wrong_initializer_for_union_payload_of_type_type.zig b/test/cases/compile_errors/stage1/obj/wrong_initializer_for_union_payload_of_type_type.zig
new file mode 100644
index 0000000000000000000000000000000000000000..2e7b8f2e40ac0f918a473303c60fd78a0778d7bd
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/wrong_initializer_for_union_payload_of_type_type.zig
@@ -0,0 +1,16 @@
+const U = union(enum) {
+    A: type,
+};
+const S = struct {
+    u: U,
+};
+export fn entry() void {
+    comptime var v: S = undefined;
+    v.u.A = U{ .A = i32 };
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:9:8: error: use of undefined value here causes undefined behavior
diff --git a/test/cases/compile_errors/stage1/obj/wrong_number_of_arguments.zig b/test/cases/compile_errors/stage1/obj/wrong_number_of_arguments.zig
new file mode 100644
index 0000000000000000000000000000000000000000..f25c9dae083d800541c3dec579c466a504fd04cb
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/wrong_number_of_arguments.zig
@@ -0,0 +1,10 @@
+export fn a() void {
+    c(1);
+}
+fn c(d: i32, e: i32, f: i32) void { _ = d; _ = e; _ = f; }
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:2:6: error: expected 3 argument(s), found 1
diff --git a/test/cases/compile_errors/stage1/obj/wrong_number_of_arguments_for_method_fn_call.zig b/test/cases/compile_errors/stage1/obj/wrong_number_of_arguments_for_method_fn_call.zig
new file mode 100644
index 0000000000000000000000000000000000000000..7371223863c0f43a33a8bd1ae068053cbd691e32
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/wrong_number_of_arguments_for_method_fn_call.zig
@@ -0,0 +1,14 @@
+const Foo = struct {
+    fn method(self: *const Foo, a: i32) void {_ = self; _ = a;}
+};
+fn f(foo: *const Foo) void {
+
+    foo.method(1, 2);
+}
+export fn entry() usize { return @sizeOf(@TypeOf(f)); }
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:6:15: error: expected 2 argument(s), found 3
diff --git a/test/cases/compile_errors/stage1/obj/wrong_panic_signature_generic_function.zig b/test/cases/compile_errors/stage1/obj/wrong_panic_signature_generic_function.zig
new file mode 100644
index 0000000000000000000000000000000000000000..45de2fc6cbc56d23259efb73993207e1c44841a5
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/wrong_panic_signature_generic_function.zig
@@ -0,0 +1,12 @@
+pub fn panic(comptime msg: []const u8, error_return_trace: ?*builtin.StackTrace) noreturn {
+    _ = msg; _ = error_return_trace;
+    while (true) {}
+}
+const builtin = @import("std").builtin;
+
+// error
+// backend=stage1
+// target=native
+//
+// error: expected type 'fn([]const u8, ?*std.builtin.StackTrace) noreturn', found 'fn([]const u8,anytype) anytype'
+// note: only one of the functions is generic
diff --git a/test/cases/compile_errors/stage1/obj/wrong_panic_signature_runtime_function.zig b/test/cases/compile_errors/stage1/obj/wrong_panic_signature_runtime_function.zig
new file mode 100644
index 0000000000000000000000000000000000000000..5cf224c4a8d8fb8fcc1b380d8995b348d0efdfe4
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/wrong_panic_signature_runtime_function.zig
@@ -0,0 +1,10 @@
+test "" {}
+
+pub fn panic() void {}
+
+
+// error
+// backend=stage1
+// target=native
+//
+// error: expected type 'fn([]const u8, ?*std.builtin.StackTrace) noreturn', found 'fn() void'
diff --git a/test/cases/compile_errors/stage1/obj/wrong_pointer_coerced_to_pointer_to_opaque_{}.zig b/test/cases/compile_errors/stage1/obj/wrong_pointer_coerced_to_pointer_to_opaque_{}.zig
new file mode 100644
index 0000000000000000000000000000000000000000..3f6b0e750bd7ecfef3f70d548b102e06a431ef23
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/wrong_pointer_coerced_to_pointer_to_opaque_{}.zig
@@ -0,0 +1,12 @@
+const Derp = opaque {};
+extern fn bar(d: *Derp) void;
+export fn foo() void {
+    var x = @as(u8, 1);
+    bar(@ptrCast(*anyopaque, &x));
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:5:9: error: expected type '*Derp', found '*anyopaque'
diff --git a/test/cases/compile_errors/stage1/obj/wrong_return_type_for_main.zig b/test/cases/compile_errors/stage1/obj/wrong_return_type_for_main.zig
new file mode 100644
index 0000000000000000000000000000000000000000..218ef0b65d254c68884b6c9f8032874ccbddce9c
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/wrong_return_type_for_main.zig
@@ -0,0 +1,7 @@
+pub fn main() f32 { }
+
+// error
+// backend=stage1
+// target=native
+//
+// error: expected return type of main to be 'void', '!void', 'noreturn', 'u8', or '!u8'
diff --git a/test/cases/compile_errors/stage1/obj/wrong_size_to_an_array_literal.zig b/test/cases/compile_errors/stage1/obj/wrong_size_to_an_array_literal.zig
new file mode 100644
index 0000000000000000000000000000000000000000..909d89458728e960b4034e434ddf2844e8a3ca9a
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/wrong_size_to_an_array_literal.zig
@@ -0,0 +1,10 @@
+comptime {
+    const array = [2]u8{1, 2, 3};
+    _ = array;
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:2:31: error: index 2 outside array of size 2
diff --git a/test/cases/compile_errors/stage1/obj/wrong_type_for_argument_tuple_to_asyncCall.zig b/test/cases/compile_errors/stage1/obj/wrong_type_for_argument_tuple_to_asyncCall.zig
new file mode 100644
index 0000000000000000000000000000000000000000..7a9be0a8cc6e9123a0beb597d4be2683aa7546ff
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/wrong_type_for_argument_tuple_to_asyncCall.zig
@@ -0,0 +1,14 @@
+export fn entry1() void {
+    var frame: @Frame(foo) = undefined;
+    @asyncCall(&frame, {}, foo, {});
+}
+
+fn foo() i32 {
+    return 0;
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:3:33: error: expected tuple or struct, found 'void'
diff --git a/test/cases/compile_errors/stage1/obj/wrong_type_for_reify_type.zig b/test/cases/compile_errors/stage1/obj/wrong_type_for_reify_type.zig
new file mode 100644
index 0000000000000000000000000000000000000000..b0c1d92659d8c73fa2656ad280b0c66829876d7d
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/wrong_type_for_reify_type.zig
@@ -0,0 +1,9 @@
+export fn entry() void {
+    _ = @Type(0);
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:2:15: error: expected type 'std.builtin.Type', found 'comptime_int'
diff --git a/test/cases/compile_errors/stage1/obj/wrong_type_for_result_ptr_to_asyncCall.zig b/test/cases/compile_errors/stage1/obj/wrong_type_for_result_ptr_to_asyncCall.zig
new file mode 100644
index 0000000000000000000000000000000000000000..b4193d4de11d50385900de8afa2b18c4ee2d3f74
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/wrong_type_for_result_ptr_to_asyncCall.zig
@@ -0,0 +1,16 @@
+export fn entry() void {
+    _ = async amain();
+}
+fn amain() i32 {
+    var frame: @Frame(foo) = undefined;
+    return await @asyncCall(&frame, false, foo, .{});
+}
+fn foo() i32 {
+    return 1234;
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:6:37: error: expected type '*i32', found 'bool'
diff --git a/test/cases/compile_errors/stage1/obj/wrong_type_passed_to_panic.zig b/test/cases/compile_errors/stage1/obj/wrong_type_passed_to_panic.zig
new file mode 100644
index 0000000000000000000000000000000000000000..ed237f81dfcee0c19e9ab3c0042323b3ae03bcae
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/wrong_type_passed_to_panic.zig
@@ -0,0 +1,10 @@
+export fn entry() void {
+    var e = error.Foo;
+    @panic(e);
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:3:12: error: expected type '[]const u8', found 'error{Foo}'
diff --git a/test/cases/compile_errors/stage1/obj/wrong_type_to_hasField.zig b/test/cases/compile_errors/stage1/obj/wrong_type_to_hasField.zig
new file mode 100644
index 0000000000000000000000000000000000000000..680c19a6fbaa10e038d56f89bd6b63efb8cbfd7a
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/wrong_type_to_hasField.zig
@@ -0,0 +1,9 @@
+export fn entry() bool {
+    return @hasField(i32, "hi");
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:2:22: error: type 'i32' does not support @hasField
diff --git a/test/cases/compile_errors/stage1/obj/wrong_types_given_to_atomic_order_args_in_cmpxchg.zig b/test/cases/compile_errors/stage1/obj/wrong_types_given_to_atomic_order_args_in_cmpxchg.zig
new file mode 100644
index 0000000000000000000000000000000000000000..b0f484e2fd07868c7d4f11ffa5a1227e611bce46
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/wrong_types_given_to_atomic_order_args_in_cmpxchg.zig
@@ -0,0 +1,10 @@
+export fn entry() void {
+    var x: i32 = 1234;
+    while (!@cmpxchgWeak(i32, &x, 1234, 5678, @as(u32, 1234), @as(u32, 1234))) {}
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:3:47: error: expected type 'std.builtin.AtomicOrder', found 'u32'
diff --git a/test/cases/compile_errors/stage1/obj/wrong_types_given_to_export.zig b/test/cases/compile_errors/stage1/obj/wrong_types_given_to_export.zig
new file mode 100644
index 0000000000000000000000000000000000000000..c06116204f00b04abc3b4b4da4dd941d130f48c4
--- /dev/null
+++ b/test/cases/compile_errors/stage1/obj/wrong_types_given_to_export.zig
@@ -0,0 +1,10 @@
+fn entry() callconv(.C) void { }
+comptime {
+    @export(entry, .{.name = "entry", .linkage = @as(u32, 1234) });
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:3:59: error: expected type 'std.builtin.GlobalLinkage', found 'comptime_int'
diff --git a/test/cases/compile_errors/stage1/test/access_invalid_typeInfo_decl.zig b/test/cases/compile_errors/stage1/test/access_invalid_typeInfo_decl.zig
new file mode 100644
index 0000000000000000000000000000000000000000..40e31a085505b75ca9b0842868bf5f8c2bdb5e85
--- /dev/null
+++ b/test/cases/compile_errors/stage1/test/access_invalid_typeInfo_decl.zig
@@ -0,0 +1,11 @@
+const A = B;
+test "Crash" {
+    _ = @typeInfo(@This()).Struct.decls[0];
+}
+
+// error
+// backend=stage1
+// target=native
+// is_test=1
+//
+// tmp.zig:1:11: error: use of undeclared identifier 'B'
diff --git a/test/cases/compile_errors/stage1/test/alignCast_of_zero_sized_types.zig b/test/cases/compile_errors/stage1/test/alignCast_of_zero_sized_types.zig
new file mode 100644
index 0000000000000000000000000000000000000000..f83d22759cac095e9052141c74b10b7c11b49cef
--- /dev/null
+++ b/test/cases/compile_errors/stage1/test/alignCast_of_zero_sized_types.zig
@@ -0,0 +1,28 @@
+export fn foo() void {
+    const a: *void = undefined;
+    _ = @alignCast(2, a);
+}
+export fn bar() void {
+    const a: ?*void = undefined;
+    _ = @alignCast(2, a);
+}
+export fn baz() void {
+    const a: []void = undefined;
+    _ = @alignCast(2, a);
+}
+export fn qux() void {
+    const a = struct {
+        fn a(comptime b: u32) void { _ = b; }
+    }.a;
+    _ = @alignCast(2, a);
+}
+
+// error
+// backend=stage1
+// target=native
+// is_test=1
+//
+// tmp.zig:3:23: error: cannot adjust alignment of zero sized type '*void'
+// tmp.zig:7:23: error: cannot adjust alignment of zero sized type '?*void'
+// tmp.zig:11:23: error: cannot adjust alignment of zero sized type '[]void'
+// tmp.zig:17:23: error: cannot adjust alignment of zero sized type 'fn(u32) anytype'
diff --git a/test/cases/compile_errors/stage1/test/bad_splat_type.zig b/test/cases/compile_errors/stage1/test/bad_splat_type.zig
new file mode 100644
index 0000000000000000000000000000000000000000..94e3d052a6cd8b2de19c239b1aa3e9f65c6d1df2
--- /dev/null
+++ b/test/cases/compile_errors/stage1/test/bad_splat_type.zig
@@ -0,0 +1,12 @@
+export fn entry() void {
+    const c = 4;
+    var v = @splat(4, c);
+    _ = v;
+}
+
+// error
+// backend=stage1
+// target=native
+// is_test=1
+//
+// tmp.zig:3:23: error: vector element type must be integer, float, bool, or pointer; 'comptime_int' is invalid
diff --git a/test/cases/compile_errors/stage1/test/binary_OR_operator_on_error_sets.zig b/test/cases/compile_errors/stage1/test/binary_OR_operator_on_error_sets.zig
new file mode 100644
index 0000000000000000000000000000000000000000..eb2d21c6eddcc44b2e9571dff3f19ec9cb9e67ff
--- /dev/null
+++ b/test/cases/compile_errors/stage1/test/binary_OR_operator_on_error_sets.zig
@@ -0,0 +1,13 @@
+pub const A = error.A;
+pub const AB = A | error.B;
+export fn entry() void {
+    var x: AB = undefined;
+    _ = x;
+}
+
+// error
+// backend=stage1
+// target=native
+// is_test=1
+//
+// tmp.zig:2:18: error: invalid operands to binary expression: 'error{A}' and 'error{B}'
diff --git a/test/cases/compile_errors/stage1/test/call_rejects_non_comptime-known_fn-always_inline.zig b/test/cases/compile_errors/stage1/test/call_rejects_non_comptime-known_fn-always_inline.zig
new file mode 100644
index 0000000000000000000000000000000000000000..a010414a57ad349bf2b9065ddc4f08d29c6491fe
--- /dev/null
+++ b/test/cases/compile_errors/stage1/test/call_rejects_non_comptime-known_fn-always_inline.zig
@@ -0,0 +1,11 @@
+pub export fn entry() void {
+    var call_me: fn () void = undefined;
+    @call(.{ .modifier = .always_inline }, call_me, .{});
+}
+
+// error
+// backend=stage1
+// target=native
+// is_test=1
+//
+// tmp.zig:3:5: error: the specified modifier requires a comptime-known function
diff --git a/test/cases/compile_errors/stage1/test/call_rejects_non_comptime-known_fn-compile_time.zig b/test/cases/compile_errors/stage1/test/call_rejects_non_comptime-known_fn-compile_time.zig
new file mode 100644
index 0000000000000000000000000000000000000000..b3ffcc6ec2bb77169efd68539817c9f80e7b6e11
--- /dev/null
+++ b/test/cases/compile_errors/stage1/test/call_rejects_non_comptime-known_fn-compile_time.zig
@@ -0,0 +1,11 @@
+pub export fn entry() void {
+    var call_me: fn () void = undefined;
+    @call(.{ .modifier = .compile_time }, call_me, .{});
+}
+
+// error
+// backend=stage1
+// target=native
+// is_test=1
+//
+// tmp.zig:3:5: error: the specified modifier requires a comptime-known function
diff --git a/test/cases/compile_errors/stage1/test/cast_between_optional_T_where_T_is_not_a_pointer.zig b/test/cases/compile_errors/stage1/test/cast_between_optional_T_where_T_is_not_a_pointer.zig
new file mode 100644
index 0000000000000000000000000000000000000000..b8392ff5db5ce80306a649fd4486c2bfdde3e606
--- /dev/null
+++ b/test/cases/compile_errors/stage1/test/cast_between_optional_T_where_T_is_not_a_pointer.zig
@@ -0,0 +1,15 @@
+pub const fnty1 = ?fn (i8) void;
+pub const fnty2 = ?fn (u64) void;
+export fn entry() void {
+    var a: fnty1 = undefined;
+    var b: fnty2 = undefined;
+    a = b;
+}
+
+// error
+// backend=stage1
+// target=native
+// is_test=1
+//
+// tmp.zig:6:9: error: expected type '?fn(i8) void', found '?fn(u64) void'
+// tmp.zig:6:9: note: optional type child 'fn(u64) void' cannot cast into optional type child 'fn(i8) void'
diff --git a/test/cases/compile_errors/stage1/test/combination_of_nosuspend_and_async.zig b/test/cases/compile_errors/stage1/test/combination_of_nosuspend_and_async.zig
new file mode 100644
index 0000000000000000000000000000000000000000..43731c964861741e99c353de416ed6b7c4544d4f
--- /dev/null
+++ b/test/cases/compile_errors/stage1/test/combination_of_nosuspend_and_async.zig
@@ -0,0 +1,16 @@
+export fn entry() void {
+    nosuspend {
+        const bar = async foo();
+        suspend {}
+        resume bar;
+    }
+}
+fn foo() void {}
+
+// error
+// backend=stage1
+// target=native
+// is_test=1
+//
+// tmp.zig:4:9: error: suspend inside nosuspend block
+// tmp.zig:2:5: note: nosuspend block here
diff --git a/test/cases/compile_errors/stage1/test/comparison_of_non-tagged_union_and_enum_literal.zig b/test/cases/compile_errors/stage1/test/comparison_of_non-tagged_union_and_enum_literal.zig
new file mode 100644
index 0000000000000000000000000000000000000000..4898ac744ca97c646e04cb59ea1c9fce85ada31b
--- /dev/null
+++ b/test/cases/compile_errors/stage1/test/comparison_of_non-tagged_union_and_enum_literal.zig
@@ -0,0 +1,14 @@
+export fn entry() void {
+    const U = union { A: u32, B: u64 };
+    var u = U{ .A = 42 };
+    var ok = u == .A;
+    _ = ok;
+}
+
+// error
+// backend=stage1
+// target=native
+// is_test=1
+//
+// 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
diff --git a/test/cases/compile_errors/stage1/test/comptime_vector_overflow_shows_the_index.zig b/test/cases/compile_errors/stage1/test/comptime_vector_overflow_shows_the_index.zig
new file mode 100644
index 0000000000000000000000000000000000000000..a1f026ab70ca4ea344aa7ea8a213e83fde32ca74
--- /dev/null
+++ b/test/cases/compile_errors/stage1/test/comptime_vector_overflow_shows_the_index.zig
@@ -0,0 +1,14 @@
+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;
+}
+
+// error
+// backend=stage1
+// target=native
+// is_test=1
+//
+// tmp.zig:4:15: error: operation caused overflow
+// tmp.zig:4:15: note: when computing vector element at index 2
diff --git a/test/cases/compile_errors/stage1/test/duplicate_field_in_anonymous_struct_literal.zig b/test/cases/compile_errors/stage1/test/duplicate_field_in_anonymous_struct_literal.zig
new file mode 100644
index 0000000000000000000000000000000000000000..7b6821d6691b97ce557be4041f0ce1de220c2453
--- /dev/null
+++ b/test/cases/compile_errors/stage1/test/duplicate_field_in_anonymous_struct_literal.zig
@@ -0,0 +1,19 @@
+export fn entry() void {
+    const anon = .{
+        .inner = .{
+            .a = .{
+                .something = "text",
+            },
+            .a = .{},
+        },
+    };
+    _ = anon;
+}
+
+// error
+// backend=stage1
+// target=native
+// is_test=1
+//
+// tmp.zig:7:13: error: duplicate field
+// tmp.zig:4:13: note: other field here
diff --git a/test/cases/compile_errors/stage1/test/error_in_struct_initializer_doesnt_crash_the_compiler.zig b/test/cases/compile_errors/stage1/test/error_in_struct_initializer_doesnt_crash_the_compiler.zig
new file mode 100644
index 0000000000000000000000000000000000000000..2858fd6a0115c33210172a4e34d6bf0548260e39
--- /dev/null
+++ b/test/cases/compile_errors/stage1/test/error_in_struct_initializer_doesnt_crash_the_compiler.zig
@@ -0,0 +1,15 @@
+pub export fn entry() void {
+    const bitfield = struct {
+        e: u8,
+        e: u8,
+    };
+    var a = .{@sizeOf(bitfield)};
+    _ = a;
+}
+
+// error
+// backend=stage1
+// target=native
+// is_test=1
+//
+// tmp.zig:4:9: error: duplicate struct field: 'e'
diff --git a/test/cases/compile_errors/stage1/test/errors_in_for_loop_bodies_are_propagated.zig b/test/cases/compile_errors/stage1/test/errors_in_for_loop_bodies_are_propagated.zig
new file mode 100644
index 0000000000000000000000000000000000000000..d8be29e39b453032ffd09d38c2452bd88b13eaac
--- /dev/null
+++ b/test/cases/compile_errors/stage1/test/errors_in_for_loop_bodies_are_propagated.zig
@@ -0,0 +1,11 @@
+pub export fn entry() void {
+    var arr: [100]u8 = undefined;
+    for (arr) |bits| _ = @popCount(bits);
+}
+
+// error
+// backend=stage1
+// target=native
+// is_test=1
+//
+// tmp.zig:3:26: error: expected 2 arguments, found 1
diff --git a/test/cases/compile_errors/stage1/test/export_with_empty_name_string.zig b/test/cases/compile_errors/stage1/test/export_with_empty_name_string.zig
new file mode 100644
index 0000000000000000000000000000000000000000..b882d11723afefc50ae5d605b36e200276b82525
--- /dev/null
+++ b/test/cases/compile_errors/stage1/test/export_with_empty_name_string.zig
@@ -0,0 +1,11 @@
+pub export fn entry() void { }
+comptime {
+    @export(entry, .{ .name = "" });
+}
+
+// error
+// backend=stage1
+// target=native
+// is_test=1
+//
+// tmp.zig:3:5: error: exported symbol name cannot be empty
diff --git a/test/cases/compile_errors/stage1/test/helpful_return_type_error_message.zig b/test/cases/compile_errors/stage1/test/helpful_return_type_error_message.zig
new file mode 100644
index 0000000000000000000000000000000000000000..0e97c09de210885dac3f8b91ba4897b817007fbc
--- /dev/null
+++ b/test/cases/compile_errors/stage1/test/helpful_return_type_error_message.zig
@@ -0,0 +1,30 @@
+export fn foo() u32 {
+    return error.Ohno;
+}
+fn bar() !u32 {
+    return error.Ohno;
+}
+export fn baz() void {
+    try bar();
+}
+export fn qux() u32 {
+    return bar();
+}
+export fn quux() u32 {
+    var buf: u32 = 0;
+    buf = bar();
+}
+
+// error
+// backend=stage1
+// target=native
+// is_test=1
+//
+// tmp.zig:2:17: error: expected type 'u32', found 'error{Ohno}'
+// tmp.zig:1:17: note: function cannot return an error
+// tmp.zig:8:5: error: expected type 'void', found '@typeInfo(@typeInfo(@TypeOf(bar)).Fn.return_type.?).ErrorUnion.error_set'
+// tmp.zig:7:17: note: function cannot return an error
+// tmp.zig:11:15: error: cannot convert error union to payload type. consider using `try`, `catch`, or `if`. expected type 'u32', found '@typeInfo(@typeInfo(@TypeOf(bar)).Fn.return_type.?).ErrorUnion.error_set!u32'
+// tmp.zig:10:17: note: function cannot return an error
+// tmp.zig:15:14: error: cannot convert error union to payload type. consider using `try`, `catch`, or `if`. expected type 'u32', found '@typeInfo(@typeInfo(@TypeOf(bar)).Fn.return_type.?).ErrorUnion.error_set!u32'
+// tmp.zig:14:5: note: cannot store an error in type 'u32'
diff --git a/test/cases/compile_errors/stage1/test/int-float_conversion_to_comptime_int-float.zig b/test/cases/compile_errors/stage1/test/int-float_conversion_to_comptime_int-float.zig
new file mode 100644
index 0000000000000000000000000000000000000000..de439168ae36788f367d1ceeb70d3cad065c4f19
--- /dev/null
+++ b/test/cases/compile_errors/stage1/test/int-float_conversion_to_comptime_int-float.zig
@@ -0,0 +1,16 @@
+export fn foo() void {
+    var a: f32 = 2;
+    _ = @floatToInt(comptime_int, a);
+}
+export fn bar() void {
+    var a: u32 = 2;
+    _ = @intToFloat(comptime_float, a);
+}
+
+// error
+// backend=stage1
+// target=native
+// is_test=1
+//
+// tmp.zig:3:35: error: unable to evaluate constant expression
+// tmp.zig:7:37: error: unable to evaluate constant expression
diff --git a/test/cases/compile_errors/stage1/test/invalid_assignments.zig b/test/cases/compile_errors/stage1/test/invalid_assignments.zig
new file mode 100644
index 0000000000000000000000000000000000000000..75f45a8bcb94e526334a65f466beb80ceb625a07
--- /dev/null
+++ b/test/cases/compile_errors/stage1/test/invalid_assignments.zig
@@ -0,0 +1,20 @@
+export fn entry1() void {
+    var a: []const u8 = "foo";
+    a[0..2] = "bar";
+}
+export fn entry2() void {
+    var a: u8 = 2;
+    a + 2 = 3;
+}
+export fn entry4() void {
+    2 + 2 = 3;
+}
+
+// error
+// backend=stage1
+// target=native
+// is_test=1
+//
+// tmp.zig:3:6: error: invalid left-hand side to assignment
+// tmp.zig:7:7: error: invalid left-hand side to assignment
+// tmp.zig:10:7: error: invalid left-hand side to assignment
diff --git a/test/cases/compile_errors/stage1/test/invalid_float_casts.zig b/test/cases/compile_errors/stage1/test/invalid_float_casts.zig
new file mode 100644
index 0000000000000000000000000000000000000000..2fe8003728e0e74131f66725c2b596f5f0151d50
--- /dev/null
+++ b/test/cases/compile_errors/stage1/test/invalid_float_casts.zig
@@ -0,0 +1,26 @@
+export fn foo() void {
+    var a: f32 = 2;
+    _ = @floatCast(comptime_float, a);
+}
+export fn bar() void {
+    var a: f32 = 2;
+    _ = @floatToInt(f32, a);
+}
+export fn baz() void {
+    var a: f32 = 2;
+    _ = @intToFloat(f32, a);
+}
+export fn qux() void {
+    var a: u32 = 2;
+    _ = @floatCast(f32, a);
+}
+
+// error
+// backend=stage1
+// target=native
+// is_test=1
+//
+// tmp.zig:3:36: error: unable to evaluate constant expression
+// tmp.zig:7:21: error: expected integer type, found 'f32'
+// tmp.zig:11:26: error: expected int type, found 'f32'
+// tmp.zig:15:25: error: expected float type, found 'u32'
diff --git a/test/cases/compile_errors/stage1/test/invalid_int_casts.zig b/test/cases/compile_errors/stage1/test/invalid_int_casts.zig
new file mode 100644
index 0000000000000000000000000000000000000000..9945751ef5765baab60e2afe8f47ee2c5725f643
--- /dev/null
+++ b/test/cases/compile_errors/stage1/test/invalid_int_casts.zig
@@ -0,0 +1,26 @@
+export fn foo() void {
+    var a: u32 = 2;
+    _ = @intCast(comptime_int, a);
+}
+export fn bar() void {
+    var a: u32 = 2;
+    _ = @intToFloat(u32, a);
+}
+export fn baz() void {
+    var a: u32 = 2;
+    _ = @floatToInt(u32, a);
+}
+export fn qux() void {
+    var a: f32 = 2;
+    _ = @intCast(u32, a);
+}
+
+// error
+// backend=stage1
+// target=native
+// is_test=1
+//
+// tmp.zig:3:32: error: unable to evaluate constant expression
+// tmp.zig:7:21: error: expected float type, found 'u32'
+// tmp.zig:11:26: error: expected float type, found 'u32'
+// tmp.zig:15:23: error: expected integer type, found 'f32'
diff --git a/test/cases/compile_errors/stage1/test/invalid_non-exhaustive_enum_to_union.zig b/test/cases/compile_errors/stage1/test/invalid_non-exhaustive_enum_to_union.zig
new file mode 100644
index 0000000000000000000000000000000000000000..804e83a66aab2642a9191c21c7bdf52f3a64ed88
--- /dev/null
+++ b/test/cases/compile_errors/stage1/test/invalid_non-exhaustive_enum_to_union.zig
@@ -0,0 +1,27 @@
+const E = enum(u8) {
+    a,
+    b,
+    _,
+};
+const U = union(E) {
+    a,
+    b,
+};
+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;
+}
+
+// error
+// backend=stage1
+// target=native
+// is_test=1
+//
+// tmp.zig:12:16: error: runtime cast to union 'U' from non-exhaustive enum
+// tmp.zig:17:16: error: no tag by value 15
diff --git a/test/cases/compile_errors/stage1/test/invalid_pointer_with_reify_type.zig b/test/cases/compile_errors/stage1/test/invalid_pointer_with_reify_type.zig
new file mode 100644
index 0000000000000000000000000000000000000000..bf1cf6bd6f97e716677cf542bcfec45d166ab042
--- /dev/null
+++ b/test/cases/compile_errors/stage1/test/invalid_pointer_with_reify_type.zig
@@ -0,0 +1,19 @@
+export fn entry() void {
+    _ = @Type(.{ .Pointer = .{
+        .size = .One,
+        .is_const = false,
+        .is_volatile = false,
+        .alignment = 1,
+        .address_space = .generic,
+        .child = u8,
+        .is_allowzero = false,
+        .sentinel = &@as(u8, 0),
+    }});
+}
+
+// error
+// backend=stage1
+// target=native
+// is_test=1
+//
+// tmp.zig:2:16: error: sentinels are only allowed on slices and unknown-length pointers
diff --git a/test/cases/compile_errors/stage1/test/nested_vectors.zig b/test/cases/compile_errors/stage1/test/nested_vectors.zig
new file mode 100644
index 0000000000000000000000000000000000000000..9e87ac814b2f21d33add49e6e89405837f17c8c2
--- /dev/null
+++ b/test/cases/compile_errors/stage1/test/nested_vectors.zig
@@ -0,0 +1,13 @@
+export fn entry() void {
+    const V1 = @import("std").meta.Vector(4, u8);
+    const V2 = @Type(.{ .Vector = .{ .len = 4, .child = V1 } });
+    var v: V2 = undefined;
+    _ = v;
+}
+
+// error
+// backend=stage1
+// target=native
+// is_test=1
+//
+// tmp.zig:3:23: error: vector element type must be integer, float, bool, or pointer; '@Vector(4, u8)' is invalid
diff --git a/test/cases/compile_errors/stage1/test/non-exhaustive_enum_marker_assigned_a_value.zig b/test/cases/compile_errors/stage1/test/non-exhaustive_enum_marker_assigned_a_value.zig
new file mode 100644
index 0000000000000000000000000000000000000000..609af248dfcc2e7ead10dc39ecd4a865202bfc0b
--- /dev/null
+++ b/test/cases/compile_errors/stage1/test/non-exhaustive_enum_marker_assigned_a_value.zig
@@ -0,0 +1,20 @@
+const A = enum {
+    a,
+    b,
+    _ = 1,
+};
+const B = enum {
+    a,
+    b,
+    _,
+};
+comptime { _ = A; _ = B; }
+
+// error
+// backend=stage1
+// target=native
+// is_test=1
+//
+// 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
diff --git a/test/cases/compile_errors/stage1/test/non-exhaustive_enums.zig b/test/cases/compile_errors/stage1/test/non-exhaustive_enums.zig
new file mode 100644
index 0000000000000000000000000000000000000000..3b5f8af7cbb7f51d9a6e78a2bd59e683f5622851
--- /dev/null
+++ b/test/cases/compile_errors/stage1/test/non-exhaustive_enums.zig
@@ -0,0 +1,22 @@
+const B = enum(u1) {
+    a,
+    _,
+    b,
+};
+const C = enum(u1) {
+    a,
+    b,
+    _,
+};
+pub export fn entry() void {
+    _ = B;
+    _ = C;
+}
+
+// error
+// backend=stage1
+// target=native
+// is_test=1
+//
+// tmp.zig:3:5: error: '_' field of non-exhaustive enum must be last
+// tmp.zig:6:11: error: non-exhaustive enum specifies every value
diff --git a/test/cases/compile_errors/stage1/test/not_an_enum_type.zig b/test/cases/compile_errors/stage1/test/not_an_enum_type.zig
new file mode 100644
index 0000000000000000000000000000000000000000..99c733b4d02a10727e88195105bc7e631f34d0c8
--- /dev/null
+++ b/test/cases/compile_errors/stage1/test/not_an_enum_type.zig
@@ -0,0 +1,20 @@
+export fn entry() void {
+    var self: Error = undefined;
+    switch (self) {
+        InvalidToken => |x| return x.token,
+        ExpectedVarDeclOrFn => |x| return x.token,
+    }
+}
+const Error = union(enum) {
+    A: InvalidToken,
+    B: ExpectedVarDeclOrFn,
+};
+const InvalidToken = struct {};
+const ExpectedVarDeclOrFn = struct {};
+
+// error
+// backend=stage1
+// target=native
+// is_test=1
+//
+// tmp.zig:4:9: error: expected type '@typeInfo(Error).Union.tag_type.?', found 'type'
diff --git a/test/cases/compile_errors/stage1/test/packed_struct_with_fields_of_not_allowed_types.zig b/test/cases/compile_errors/stage1/test/packed_struct_with_fields_of_not_allowed_types.zig
new file mode 100644
index 0000000000000000000000000000000000000000..2951d26c52b434368eac60f6111c8df95a13ff6f
--- /dev/null
+++ b/test/cases/compile_errors/stage1/test/packed_struct_with_fields_of_not_allowed_types.zig
@@ -0,0 +1,74 @@
+const A = packed struct {
+    x: anyerror,
+};
+const B = packed struct {
+    x: [2]u24,
+};
+const C = packed struct {
+    x: [1]anyerror,
+};
+const D = packed struct {
+    x: [1]S,
+};
+const E = packed struct {
+    x: [1]U,
+};
+const F = packed struct {
+    x: ?anyerror,
+};
+const G = packed struct {
+    x: Enum,
+};
+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,
+};
+const U = struct {
+    A: i32,
+    B: u32,
+};
+const Enum = enum {
+    A,
+    B,
+};
+
+// error
+// backend=stage1
+// target=native
+// is_test=1
+//
+// tmp.zig:2:5: error: type 'anyerror' not allowed in packed struct; no guaranteed in-memory representation
+// tmp.zig:5:5: error: array of 'u24' not allowed in packed struct due to padding bits (must be padded from 48 to 64 bits)
+// tmp.zig:8:5: error: type 'anyerror' not allowed in packed struct; no guaranteed in-memory representation
+// tmp.zig:11:5: error: non-packed, non-extern struct 'S' not allowed in packed struct; no guaranteed in-memory representation
+// 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:57:14: note: enum declaration does not specify an integer tag type
diff --git a/test/cases/compile_errors/stage1/test/ptrToInt_with_pointer_to_zero-sized_type.zig b/test/cases/compile_errors/stage1/test/ptrToInt_with_pointer_to_zero-sized_type.zig
new file mode 100644
index 0000000000000000000000000000000000000000..7c2ba184c4246887e970e69e17f2b7d92b9b5190
--- /dev/null
+++ b/test/cases/compile_errors/stage1/test/ptrToInt_with_pointer_to_zero-sized_type.zig
@@ -0,0 +1,12 @@
+export fn entry() void {
+    var pointer: ?*u0 = null;
+    var x = @ptrToInt(pointer);
+    _ = x;
+}
+
+// error
+// backend=stage1
+// target=native
+// is_test=1
+//
+// tmp.zig:3:23: error: pointer to size 0 type has no address
diff --git a/test/cases/compile_errors/stage1/test/reassign_to_array_parameter.zig b/test/cases/compile_errors/stage1/test/reassign_to_array_parameter.zig
new file mode 100644
index 0000000000000000000000000000000000000000..f3b51d2c0fd742aae14e5287a013144e04e0bfcd
--- /dev/null
+++ b/test/cases/compile_errors/stage1/test/reassign_to_array_parameter.zig
@@ -0,0 +1,13 @@
+fn reassign(a: [3]f32) void {
+    a = [3]f32{4, 5, 6};
+}
+export fn entry() void {
+    reassign(.{1, 2, 3});
+}
+
+// error
+// backend=stage1
+// target=native
+// is_test=1
+//
+// tmp.zig:2:15: error: cannot assign to constant
diff --git a/test/cases/compile_errors/stage1/test/reassign_to_slice_parameter.zig b/test/cases/compile_errors/stage1/test/reassign_to_slice_parameter.zig
new file mode 100644
index 0000000000000000000000000000000000000000..34bd5541a15e391ecd3bd9a7c93cf874e15200fb
--- /dev/null
+++ b/test/cases/compile_errors/stage1/test/reassign_to_slice_parameter.zig
@@ -0,0 +1,13 @@
+pub fn reassign(s: []const u8) void {
+    s = s[0..];
+}
+export fn entry() void {
+    reassign("foo");
+}
+
+// error
+// backend=stage1
+// target=native
+// is_test=1
+//
+// tmp.zig:2:10: error: cannot assign to constant
diff --git a/test/cases/compile_errors/stage1/test/reassign_to_struct_parameter.zig b/test/cases/compile_errors/stage1/test/reassign_to_struct_parameter.zig
new file mode 100644
index 0000000000000000000000000000000000000000..994833d989bfe0687d02feebbb3770427ee7c6ca
--- /dev/null
+++ b/test/cases/compile_errors/stage1/test/reassign_to_struct_parameter.zig
@@ -0,0 +1,16 @@
+const S = struct {
+    x: u32,
+};
+fn reassign(s: S) void {
+    s = S{.x = 2};
+}
+export fn entry() void {
+    reassign(S{.x = 3});
+}
+
+// error
+// backend=stage1
+// target=native
+// is_test=1
+//
+// tmp.zig:5:10: error: cannot assign to constant
diff --git a/test/cases/compile_errors/stage1/test/reference_to_const_data.zig b/test/cases/compile_errors/stage1/test/reference_to_const_data.zig
new file mode 100644
index 0000000000000000000000000000000000000000..6c98aefd7abd452725c2bdbaedbc52199ee5ba33
--- /dev/null
+++ b/test/cases/compile_errors/stage1/test/reference_to_const_data.zig
@@ -0,0 +1,30 @@
+export fn foo() void {
+    var ptr = &[_]u8{0,0,0,0};
+    ptr[1] = 2;
+}
+export fn bar() void {
+    var ptr = &@as(u32, 2);
+    ptr.* = 2;
+}
+export fn baz() void {
+    var ptr = &true;
+    ptr.* = false;
+}
+export fn qux() void {
+    const S = struct{
+        x: usize,
+        y: usize,
+    };
+    var ptr = &S{.x=1,.y=2};
+    ptr.x = 2;
+}
+
+// error
+// backend=stage1
+// target=native
+// is_test=1
+//
+// tmp.zig:3:14: error: cannot assign to constant
+// tmp.zig:7:13: error: cannot assign to constant
+// tmp.zig:11:13: error: cannot assign to constant
+// tmp.zig:19:13: error: cannot assign to constant
diff --git a/test/cases/compile_errors/stage1/test/reify_typeOf_with_incompatible_arguments.zig b/test/cases/compile_errors/stage1/test/reify_typeOf_with_incompatible_arguments.zig
new file mode 100644
index 0000000000000000000000000000000000000000..2013a07e536d199827132902c0c5c24adc6f7f91
--- /dev/null
+++ b/test/cases/compile_errors/stage1/test/reify_typeOf_with_incompatible_arguments.zig
@@ -0,0 +1,12 @@
+export fn entry() void {
+    var var_1: f32 = undefined;
+    var var_2: u32 = undefined;
+    _ = @TypeOf(var_1, var_2);
+}
+
+// error
+// backend=stage1
+// target=native
+// is_test=1
+//
+// tmp.zig:4:9: error: incompatible types: 'f32' and 'u32'
diff --git a/test/cases/compile_errors/stage1/test/reify_typeOf_with_no_arguments.zig b/test/cases/compile_errors/stage1/test/reify_typeOf_with_no_arguments.zig
new file mode 100644
index 0000000000000000000000000000000000000000..0626d453936f615271824bcdc93d5c6b405b37e2
--- /dev/null
+++ b/test/cases/compile_errors/stage1/test/reify_typeOf_with_no_arguments.zig
@@ -0,0 +1,10 @@
+export fn entry() void {
+    _ = @TypeOf();
+}
+
+// error
+// backend=stage1
+// target=native
+// is_test=1
+//
+// tmp.zig:2:9: error: expected at least 1 argument, found 0
diff --git a/test/cases/compile_errors/stage1/test/reject_extern_function_definitions_with_body.zig b/test/cases/compile_errors/stage1/test/reject_extern_function_definitions_with_body.zig
new file mode 100644
index 0000000000000000000000000000000000000000..a7b92e8399e3992b08b4c8ffcc887286bf0f560e
--- /dev/null
+++ b/test/cases/compile_errors/stage1/test/reject_extern_function_definitions_with_body.zig
@@ -0,0 +1,10 @@
+extern "c" fn definitelyNotInLibC(a: i32, b: i32) i32 {
+    return a + b;
+}
+
+// error
+// backend=stage1
+// target=native
+// is_test=1
+//
+// tmp.zig:1:1: error: extern functions have no body
diff --git a/test/cases/compile_errors/stage1/test/reject_extern_variables_with_initializers.zig b/test/cases/compile_errors/stage1/test/reject_extern_variables_with_initializers.zig
new file mode 100644
index 0000000000000000000000000000000000000000..54239e0948e93fafaa3555ebe7c10c8c09a0ab07
--- /dev/null
+++ b/test/cases/compile_errors/stage1/test/reject_extern_variables_with_initializers.zig
@@ -0,0 +1,8 @@
+extern var foo: int = 2;
+
+// error
+// backend=stage1
+// target=native
+// is_test=1
+//
+// tmp.zig:1:23: error: extern variables have no initializers
diff --git a/test/cases/compile_errors/stage1/test/repeated_invalid_field_access_to_generic_function_returning_type_crashes_compiler_2655.zig b/test/cases/compile_errors/stage1/test/repeated_invalid_field_access_to_generic_function_returning_type_crashes_compiler_2655.zig
new file mode 100644
index 0000000000000000000000000000000000000000..7499939b4a1bbd979861be1dcd8fc3fd17e5207f
--- /dev/null
+++ b/test/cases/compile_errors/stage1/test/repeated_invalid_field_access_to_generic_function_returning_type_crashes_compiler_2655.zig
@@ -0,0 +1,14 @@
+pub fn A() type {
+    return Q;
+}
+test "1" {
+    _ = A().a;
+    _ = A().a;
+}
+
+// error
+// backend=stage1
+// target=native
+// is_test=1
+//
+// tmp.zig:2:12: error: use of undeclared identifier 'Q'
diff --git a/test/cases/compile_errors/stage1/test/return_invalid_type_from_test.zig b/test/cases/compile_errors/stage1/test/return_invalid_type_from_test.zig
new file mode 100644
index 0000000000000000000000000000000000000000..590ac3091860b3177105ede28ff9f39e20631a36
--- /dev/null
+++ b/test/cases/compile_errors/stage1/test/return_invalid_type_from_test.zig
@@ -0,0 +1,8 @@
+test "example" { return 1; }
+
+// error
+// backend=stage1
+// target=native
+// is_test=1
+//
+// tmp.zig:1:25: error: expected type 'void', found 'comptime_int'
diff --git a/test/cases/compile_errors/stage1/test/shift_on_type_with_non-power-of-two_size.zig b/test/cases/compile_errors/stage1/test/shift_on_type_with_non-power-of-two_size.zig
new file mode 100644
index 0000000000000000000000000000000000000000..222cb2256308bec4cca5475a28ffdf7eadf1520a
--- /dev/null
+++ b/test/cases/compile_errors/stage1/test/shift_on_type_with_non-power-of-two_size.zig
@@ -0,0 +1,34 @@
+export fn entry() void {
+    const S = struct {
+        fn a() void {
+            var x: u24 = 42;
+            _ = x >> 24;
+        }
+        fn b() void {
+            var x: u24 = 42;
+            _ = x << 24;
+        }
+        fn c() void {
+            var x: u24 = 42;
+            _ = @shlExact(x, 24);
+        }
+        fn d() void {
+            var x: u24 = 42;
+            _ = @shrExact(x, 24);
+        }
+    };
+    S.a();
+    S.b();
+    S.c();
+    S.d();
+}
+
+// error
+// backend=stage1
+// target=native
+// is_test=1
+//
+// tmp.zig:5:19: error: RHS of shift is too large for LHS type
+// tmp.zig:9:19: error: RHS of shift is too large for LHS type
+// tmp.zig:13:17: error: RHS of shift is too large for LHS type
+// tmp.zig:17:17: error: RHS of shift is too large for LHS type
diff --git a/test/cases/compile_errors/stage1/test/shuffle_with_selected_index_past_first_vector_length.zig b/test/cases/compile_errors/stage1/test/shuffle_with_selected_index_past_first_vector_length.zig
new file mode 100644
index 0000000000000000000000000000000000000000..8b0c5ba780b12c79cdffca4edc911835bcd3a48f
--- /dev/null
+++ b/test/cases/compile_errors/stage1/test/shuffle_with_selected_index_past_first_vector_length.zig
@@ -0,0 +1,15 @@
+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;
+}
+
+// error
+// backend=stage1
+// target=native
+// is_test=1
+//
+// tmp.zig:4:39: error: mask index '4' has out-of-bounds selection
+// tmp.zig:4:27: note: selected index '7' out of bounds of @Vector(4, u32)
+// tmp.zig:4:30: note: selections from the second vector are specified with negative numbers
diff --git a/test/cases/compile_errors/stage1/test/switch_ranges_endpoints_are_validated.zig b/test/cases/compile_errors/stage1/test/switch_ranges_endpoints_are_validated.zig
new file mode 100644
index 0000000000000000000000000000000000000000..a44d59feedfdadc80c4f2a4b7335ce9d02400f64
--- /dev/null
+++ b/test/cases/compile_errors/stage1/test/switch_ranges_endpoints_are_validated.zig
@@ -0,0 +1,16 @@
+pub export fn entry() void {
+    var x: i32 = 0;
+    switch (x) {
+        6...1 => {},
+        -1...-5 => {},
+        else => unreachable,
+    }
+}
+
+// error
+// backend=stage1
+// target=native
+// is_test=1
+//
+// tmp.zig:4:9: error: range start value is greater than the end value
+// tmp.zig:5:9: error: range start value is greater than the end value
diff --git a/test/cases/compile_errors/stage1/test/switching_with_exhaustive_enum_has___prong_.zig b/test/cases/compile_errors/stage1/test/switching_with_exhaustive_enum_has___prong_.zig
new file mode 100644
index 0000000000000000000000000000000000000000..0ca489bdb82f78134b0e18ecb3e0fa6f319033b5
--- /dev/null
+++ b/test/cases/compile_errors/stage1/test/switching_with_exhaustive_enum_has___prong_.zig
@@ -0,0 +1,19 @@
+const E = enum{
+    a,
+    b,
+};
+pub export fn entry() void {
+    var e: E = .b;
+    switch (e) {
+        .a => {},
+        .b => {},
+        _ => {},
+    }
+}
+
+// error
+// backend=stage1
+// target=native
+// is_test=1
+//
+// tmp.zig:7:5: error: switch on exhaustive enum has `_` prong
diff --git a/test/cases/compile_errors/stage1/test/switching_with_non-exhaustive_enums.zig b/test/cases/compile_errors/stage1/test/switching_with_non-exhaustive_enums.zig
new file mode 100644
index 0000000000000000000000000000000000000000..ed46c5f2f14337e7d1e87ed2ca90861bf20bae00
--- /dev/null
+++ b/test/cases/compile_errors/stage1/test/switching_with_non-exhaustive_enums.zig
@@ -0,0 +1,35 @@
+const E = enum(u8) {
+    a,
+    b,
+    _,
+};
+const U = union(E) {
+    a: i32,
+    b: u32,
+};
+pub export fn entry() void {
+    var e: E = .b;
+    switch (e) { // error: switch not handling the tag `b`
+        .a => {},
+        _ => {},
+    }
+    switch (e) { // error: switch on non-exhaustive enum must include `else` or `_` prong
+        .a => {},
+        .b => {},
+    }
+    var u = U{.a = 2};
+    switch (u) { // error: `_` prong not allowed when switching on tagged union
+        .a => {},
+        .b => {},
+        _ => {},
+    }
+}
+
+// error
+// backend=stage1
+// target=native
+// is_test=1
+//
+// tmp.zig:12:5: error: enumeration value 'E.b' not handled in switch
+// tmp.zig:16:5: error: switch on non-exhaustive enum must include `else` or `_` prong
+// tmp.zig:21:5: error: `_` prong not allowed when switching on tagged union
diff --git a/test/cases/compile_errors/stage1/test/tagName_on_invalid_value_of_non-exhaustive_enum.zig b/test/cases/compile_errors/stage1/test/tagName_on_invalid_value_of_non-exhaustive_enum.zig
new file mode 100644
index 0000000000000000000000000000000000000000..a98470b681adf87d7f725d128ef3a88d5948d89a
--- /dev/null
+++ b/test/cases/compile_errors/stage1/test/tagName_on_invalid_value_of_non-exhaustive_enum.zig
@@ -0,0 +1,11 @@
+test "enum" {
+    const E = enum(u8) {A, B, _};
+    _ = @tagName(@intToEnum(E, 5));
+}
+
+// error
+// backend=stage1
+// target=native
+// is_test=1
+//
+// tmp.zig:3:18: error: no tag by value 5
diff --git a/test/cases/compile_errors/stage1/test/type_mismatch_in_C_prototype_with_varargs.zig b/test/cases/compile_errors/stage1/test/type_mismatch_in_C_prototype_with_varargs.zig
new file mode 100644
index 0000000000000000000000000000000000000000..1f78ef3999716b4f6ed7d4086cebc466a64902ec
--- /dev/null
+++ b/test/cases/compile_errors/stage1/test/type_mismatch_in_C_prototype_with_varargs.zig
@@ -0,0 +1,14 @@
+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;
+}
+
+// error
+// backend=stage1
+// target=native
+// is_test=1
+//
+// tmp.zig:5:22: error: expected type 'fn([*c]u8, ...) callconv(.C) void', found 'fn([*:0]u8, ...) callconv(.C) void'
diff --git a/test/cases/compile_errors/stage1/test/type_mismatch_with_tuple_concatenation.zig b/test/cases/compile_errors/stage1/test/type_mismatch_with_tuple_concatenation.zig
new file mode 100644
index 0000000000000000000000000000000000000000..5983224676fd805903614b5e78e0252175ff7382
--- /dev/null
+++ b/test/cases/compile_errors/stage1/test/type_mismatch_with_tuple_concatenation.zig
@@ -0,0 +1,11 @@
+export fn entry() void {
+    var x = .{};
+    x = x ++ .{ 1, 2, 3 };
+}
+
+// error
+// backend=stage1
+// target=native
+// is_test=1
+//
+// tmp.zig:3:11: error: expected type 'struct:2:14', found 'struct:3:11'
diff --git a/test/cases/compile_errors/stage2/comptime_unreachable.zig b/test/cases/compile_errors/stage2/comptime_unreachable.zig
new file mode 100644
index 0000000000000000000000000000000000000000..6086dd85c6033d35f73e8d9d8e26c0a70844f82c
--- /dev/null
+++ b/test/cases/compile_errors/stage2/comptime_unreachable.zig
@@ -0,0 +1,7 @@
+pub export fn entry() void {
+    comptime unreachable;
+}
+
+// error
+//
+// :2:14: error: reached unreachable code
diff --git a/test/cases/compile_errors/stage2/constant_inside_comptime_function_has_compile_error.zig b/test/cases/compile_errors/stage2/constant_inside_comptime_function_has_compile_error.zig
new file mode 100644
index 0000000000000000000000000000000000000000..2b67390b05b2ec7e22608045d5e658810a4b596d
--- /dev/null
+++ b/test/cases/compile_errors/stage2/constant_inside_comptime_function_has_compile_error.zig
@@ -0,0 +1,21 @@
+const ContextAllocator = MemoryPool(usize);
+
+pub fn MemoryPool(comptime T: type) type {
+    const free_list_t = @compileError("aoeu",);
+    _ = T;
+
+    return struct {
+        free_list: free_list_t,
+    };
+}
+
+export fn entry() void {
+    var allocator: ContextAllocator = undefined;
+    _ = allocator;
+}
+
+// error
+// target=native
+//
+// :4:5: error: unreachable code
+// :4:25: note: control flow is diverted here
diff --git a/test/cases/compile_errors/stage2/duplicate-unused_labels.zig b/test/cases/compile_errors/stage2/duplicate-unused_labels.zig
new file mode 100644
index 0000000000000000000000000000000000000000..4bfc6c596012082af8e971d5ab932f86a01c8c5c
--- /dev/null
+++ b/test/cases/compile_errors/stage2/duplicate-unused_labels.zig
@@ -0,0 +1,31 @@
+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)) |_| {}
+}
+
+// error
+// target=native
+//
+// :2:12: error: redefinition of label 'blk'
+// :2:5: note: previous definition here
+// :5:26: error: redefinition of label 'blk'
+// :5:5: note: previous definition here
+// :8:46: error: redefinition of label 'blk'
+// :8:5: note: previous definition here
+// :11:5: error: unused block label
+// :14:5: error: unused while loop label
+// :17:5: error: unused for loop label
diff --git a/test/cases/compile_errors/stage2/embed_outside_package.zig b/test/cases/compile_errors/stage2/embed_outside_package.zig
new file mode 100644
index 0000000000000000000000000000000000000000..2003adb06199e8df8136ea6941d4ac346219f6bb
--- /dev/null
+++ b/test/cases/compile_errors/stage2/embed_outside_package.zig
@@ -0,0 +1,8 @@
+export fn a() usize {
+    return @embedFile("/root/foo").len;
+}
+
+// error
+// target=native
+//
+//:2:23: error: embed of file outside package path: '/root/foo'
diff --git a/test/cases/compile_errors/stage2/import_outside_package.zig b/test/cases/compile_errors/stage2/import_outside_package.zig
new file mode 100644
index 0000000000000000000000000000000000000000..59a75e2745a22d2f1b84d40d0555c4e7dc1ae881
--- /dev/null
+++ b/test/cases/compile_errors/stage2/import_outside_package.zig
@@ -0,0 +1,8 @@
+export fn a() usize {
+    return @import("../../above.zig").len;
+}
+
+// error
+// target=native
+//
+// :2:20: error: import of file outside package path: '../../above.zig'
diff --git a/test/cases/compile_errors/stage2/out_of_bounds_index.zig b/test/cases/compile_errors/stage2/out_of_bounds_index.zig
new file mode 100644
index 0000000000000000000000000000000000000000..ea9bc6521d136e0aacf5ee7c69307f50c6bef577
--- /dev/null
+++ b/test/cases/compile_errors/stage2/out_of_bounds_index.zig
@@ -0,0 +1,29 @@
+comptime {
+    var array = [_:0]u8{ 1, 2, 3, 4 };
+    var src_slice: [:0]u8 = &array;
+    var slice = src_slice[2..6];
+    _ = slice;
+}
+comptime {
+    var array = [_:0]u8{ 1, 2, 3, 4 };
+    var slice = array[2..6];
+    _ = slice;
+}
+comptime {
+    var array = [_]u8{ 1, 2, 3, 4 };
+    var slice = array[2..5];
+    _ = slice;
+}
+comptime {
+    var array = [_:0]u8{ 1, 2, 3, 4 };
+    var slice = array[3..2];
+    _ = slice;
+}
+
+// error
+// target=native
+//
+// :4:26: error: end index 6 out of bounds for slice of length 4 +1 (sentinel)
+// :9:22: error: end index 6 out of bounds for array of length 4 +1 (sentinel)
+// :14:22: error: end index 5 out of bounds for array of length 4
+// :19:22: error: start index 3 is larger than end index 2
diff --git a/test/cases/compile_errors/stage2/slice_of_null_pointer.zig b/test/cases/compile_errors/stage2/slice_of_null_pointer.zig
new file mode 100644
index 0000000000000000000000000000000000000000..7f2c74a8a62bfc65116889043afdcd75e1d04ddd
--- /dev/null
+++ b/test/cases/compile_errors/stage2/slice_of_null_pointer.zig
@@ -0,0 +1,11 @@
+comptime {
+    var x: [*c]u8 = null;
+    var runtime_len: usize = 0;
+    var y = x[0..runtime_len];
+    _ = y;
+}
+
+// error
+// target=native
+//
+// :4:14: error: slice of null pointer
diff --git a/test/cases/compile_errors/stage2/struct_duplicate_field_name.zig b/test/cases/compile_errors/stage2/struct_duplicate_field_name.zig
new file mode 100644
index 0000000000000000000000000000000000000000..7e4434f1d92fa353d9fccff5f2c403fae90c9978
--- /dev/null
+++ b/test/cases/compile_errors/stage2/struct_duplicate_field_name.zig
@@ -0,0 +1,16 @@
+const S = struct {
+    foo: u32,
+    foo: u32,
+};
+
+export fn entry() void {
+    const s: S = .{ .foo = 100 };
+    _ = s;
+}
+
+// error
+// target=native
+//
+// :3:5: error: duplicate struct field: 'foo'
+// :2:5: note: other field here
+// :1:11: note: struct declared here
diff --git a/test/cases/compile_errors/stage2/union_access_of_inactive_field.zig b/test/cases/compile_errors/stage2/union_access_of_inactive_field.zig
new file mode 100644
index 0000000000000000000000000000000000000000..4f72914216fce157fc689d84d177add5ade64fcc
--- /dev/null
+++ b/test/cases/compile_errors/stage2/union_access_of_inactive_field.zig
@@ -0,0 +1,15 @@
+const U = union {
+    a: void,
+    b: u64,
+};
+comptime {
+    var u: U = .{ .a = {} };
+    const v = u.b;
+    _ = v;
+}
+
+// error
+// target=native
+//
+// :7:16: error: access of union field 'b' while field 'a' is active
+// :1:11: note: union declared here
diff --git a/test/cases/compile_errors/stage2/union_duplicate_enum_field.zig b/test/cases/compile_errors/stage2/union_duplicate_enum_field.zig
new file mode 100644
index 0000000000000000000000000000000000000000..44eb58e01449d22d53bf6382c8e61d0cc69b9cb9
--- /dev/null
+++ b/test/cases/compile_errors/stage2/union_duplicate_enum_field.zig
@@ -0,0 +1,17 @@
+const E = enum { a, b };
+const U = union(E) {
+    a: u32,
+    a: u32,
+};
+
+export fn foo() void {
+    var u: U = .{ .a = 123 };
+    _ = u;
+}
+
+// error
+// target=native
+//
+// :4:5: error: duplicate union field: 'a'
+// :3:5: note: other field here
+// :2:11: note: union declared here
diff --git a/test/cases/compile_errors/stage2/union_duplicate_field_definition.zig b/test/cases/compile_errors/stage2/union_duplicate_field_definition.zig
new file mode 100644
index 0000000000000000000000000000000000000000..7993f27141f54f163bc29e32dfe0ed46054c67c4
--- /dev/null
+++ b/test/cases/compile_errors/stage2/union_duplicate_field_definition.zig
@@ -0,0 +1,16 @@
+const U = union {
+    foo: u32,
+    foo: u32,
+};
+
+export fn entry() void {
+    const u: U = .{ .foo = 100 };
+    _ = u;
+}
+
+// error
+// target=native
+//
+// :3:5: error: duplicate union field: 'foo'
+// :2:5: note: other field here
+// :1:11: note: union declared here
diff --git a/test/cases/compile_errors/stage2/union_enum_field_missing.zig b/test/cases/compile_errors/stage2/union_enum_field_missing.zig
new file mode 100644
index 0000000000000000000000000000000000000000..25ec477894be5813bdfa6498309e0861cde49820
--- /dev/null
+++ b/test/cases/compile_errors/stage2/union_enum_field_missing.zig
@@ -0,0 +1,21 @@
+const E = enum {
+    a,
+    b,
+    c,
+};
+
+const U = union(E) {
+    a: i32,
+    b: f64,
+};
+
+export fn entry() usize {
+    return @sizeOf(U);
+}
+
+// error
+// target=native
+//
+// :7:1: error: enum field(s) missing in union
+// :4:5: note: field 'c' missing, declared here
+// :1:11: note: enum declared here
diff --git a/test/cases/compile_errors/stage2/union_extra_field.zig b/test/cases/compile_errors/stage2/union_extra_field.zig
new file mode 100644
index 0000000000000000000000000000000000000000..e3bc0deb33e5a5645b130b316126f532859cb744
--- /dev/null
+++ b/test/cases/compile_errors/stage2/union_extra_field.zig
@@ -0,0 +1,20 @@
+const E = enum {
+    a,
+    b,
+    c,
+};
+const U = union(E) {
+    a: i32,
+    b: f64,
+    c: f64,
+    d: f64,
+};
+export fn entry() usize {
+    return @sizeOf(U);
+}
+
+// error
+// target=native
+//
+// :6:1: error: enum 'tmp.E' has no field named 'd'
+// :1:11: note: enum declared here
diff --git a/test/cases/compile_errors/stage2/union_runtime_coercion_from_enum.zig b/test/cases/compile_errors/stage2/union_runtime_coercion_from_enum.zig
new file mode 100644
index 0000000000000000000000000000000000000000..9020e9d5d7d202ef14c9c2660bee33df59508901
--- /dev/null
+++ b/test/cases/compile_errors/stage2/union_runtime_coercion_from_enum.zig
@@ -0,0 +1,23 @@
+const E = enum {
+    a,
+    b,
+};
+const U = union(E) {
+    a: u32,
+    b: u64,
+};
+fn foo() E {
+    return E.b;
+}
+export fn doTheTest() u64 {
+    var u: U = foo();
+    return u.b;
+}
+
+// error
+// target=native
+//
+// :13:19: error: runtime coercion from enum 'tmp.E' to union 'tmp.U' which has non-void fields
+// :6:5: note: field 'a' has type 'u32'
+// :7:5: note: field 'b' has type 'u64'
+// :5:11: note: union declared here
diff --git a/test/cases/compile_log.0.zig b/test/cases/compile_log.0.zig
new file mode 100644
index 0000000000000000000000000000000000000000..c213ebb930ca78b5b25f6fec55acaf643761afb5
--- /dev/null
+++ b/test/cases/compile_log.0.zig
@@ -0,0 +1,17 @@
+export fn _start() noreturn {
+    const b = true;
+    var f: u32 = 1;
+    @compileLog(b, 20, f, x);
+    @compileLog(1000);
+    var bruh: usize = true;
+    _ = bruh;
+    unreachable;
+}
+export fn other() void {
+    @compileLog(1234);
+}
+fn x() void {}
+
+// error
+//
+// :6:23: error: expected usize, found bool
diff --git a/test/cases/compile_log.1.zig b/test/cases/compile_log.1.zig
new file mode 100644
index 0000000000000000000000000000000000000000..12e66415420870549bdff9b0e1964403985d2dd3
--- /dev/null
+++ b/test/cases/compile_log.1.zig
@@ -0,0 +1,16 @@
+export fn _start() noreturn {
+    const b = true;
+    var f: u32 = 1;
+    @compileLog(b, 20, f, x);
+    @compileLog(1000);
+    unreachable;
+}
+export fn other() void {
+    @compileLog(1234);
+}
+fn x() void {}
+
+// error
+//
+// :9:5: error: found compile log statement
+// :4:5: note: also here
diff --git a/test/cases/double_ampersand.0.zig b/test/cases/double_ampersand.0.zig
new file mode 100644
index 0000000000000000000000000000000000000000..b14c30ecb01225e88025b6e0cb1aa7c25c69f1ed
--- /dev/null
+++ b/test/cases/double_ampersand.0.zig
@@ -0,0 +1,6 @@
+pub const a = if (true && false) 1 else 2;
+
+// error
+// output_mode=Exe
+//
+// :1:24: error: ambiguous use of '&&'; use 'and' for logical AND, or change whitespace to ' & &' for bitwise AND
diff --git a/test/cases/double_ampersand.1.zig b/test/cases/double_ampersand.1.zig
new file mode 100644
index 0000000000000000000000000000000000000000..cd5bba02fdaa14bd47cc3d1332854865e9aaea49
--- /dev/null
+++ b/test/cases/double_ampersand.1.zig
@@ -0,0 +1,11 @@
+pub fn main() void {
+    const a = true;
+    const b = false;
+    _ = a & &b;
+}
+
+// error
+//
+// :4:11: error: incompatible types: 'bool' and '*const bool'
+// :4:9: note: type 'bool' here
+// :4:13: note: type '*const bool' here
diff --git a/test/cases/double_ampersand.2.zig b/test/cases/double_ampersand.2.zig
new file mode 100644
index 0000000000000000000000000000000000000000..c6f461d66126f07c9808aacf5160615fc36d7917
--- /dev/null
+++ b/test/cases/double_ampersand.2.zig
@@ -0,0 +1,7 @@
+pub fn main() void {
+    const b: u8 = 1;
+    _ = &&b;
+}
+
+// run
+//
diff --git a/test/cases/enum_values.0.zig b/test/cases/enum_values.0.zig
new file mode 100644
index 0000000000000000000000000000000000000000..d96841dd8c65b1c20f05849b687d5de6b4f2186e
--- /dev/null
+++ b/test/cases/enum_values.0.zig
@@ -0,0 +1,18 @@
+const Number = enum { One, Two, Three };
+
+pub fn main() void {
+    var number1 = Number.One;
+    var number2: Number = .Two;
+    if (false) {
+        number1;
+        number2;
+    }
+    const number3 = @intToEnum(Number, 2);
+    if (@enumToInt(number3) != 2) {
+        unreachable;
+    }
+    return;
+}
+
+// run
+//
diff --git a/test/cases/enum_values.1.zig b/test/cases/enum_values.1.zig
new file mode 100644
index 0000000000000000000000000000000000000000..47b9e21a2778c2bdb4d23c881326b10ec975acdd
--- /dev/null
+++ b/test/cases/enum_values.1.zig
@@ -0,0 +1,22 @@
+const Number = enum { One, Two, Three };
+
+pub fn main() void {
+    var number1 = Number.One;
+    var number2: Number = .Two;
+    const number3 = @intToEnum(Number, 2);
+    assert(number1 != number2);
+    assert(number2 != number3);
+    assert(@enumToInt(number1) == 0);
+    assert(@enumToInt(number2) == 1);
+    assert(@enumToInt(number3) == 2);
+    var x: Number = .Two;
+    assert(number2 == x);
+
+    return;
+}
+fn assert(val: bool) void {
+    if (!val) unreachable;
+}
+
+// run
+//
diff --git a/test/cases/extern_variable_has_no_type.0.zig b/test/cases/extern_variable_has_no_type.0.zig
new file mode 100644
index 0000000000000000000000000000000000000000..2f03067b3ac8aba8bfe34a948baece7c2796fe05
--- /dev/null
+++ b/test/cases/extern_variable_has_no_type.0.zig
@@ -0,0 +1,9 @@
+comptime {
+    const x = foo + foo;
+    _ = x;
+}
+extern var foo: i32;
+
+// error
+//
+// :2:15: error: unable to resolve comptime value
diff --git a/test/cases/extern_variable_has_no_type.1.zig b/test/cases/extern_variable_has_no_type.1.zig
new file mode 100644
index 0000000000000000000000000000000000000000..f5c31244e5a7bfe9a39f028fd80f40ebcd3dff04
--- /dev/null
+++ b/test/cases/extern_variable_has_no_type.1.zig
@@ -0,0 +1,8 @@
+export fn entry() void {
+    _ = foo;
+}
+extern var foo;
+
+// error
+//
+// :4:8: error: unable to infer variable type
diff --git a/test/cases/function_calls.0.zig b/test/cases/function_calls.0.zig
new file mode 100644
index 0000000000000000000000000000000000000000..eb388bc49f6b9399ebc8b1f42424f7527f735360
--- /dev/null
+++ b/test/cases/function_calls.0.zig
@@ -0,0 +1,12 @@
+pub fn main() void {
+    foo();
+    bar();
+}
+fn foo() void {
+    bar();
+    bar();
+}
+fn bar() void {}
+
+// run
+//
diff --git a/test/cases/function_calls.1.zig b/test/cases/function_calls.1.zig
new file mode 100644
index 0000000000000000000000000000000000000000..60bc061bca50c1e0a18e5bfa0b67c14d1cc06c9f
--- /dev/null
+++ b/test/cases/function_calls.1.zig
@@ -0,0 +1,15 @@
+pub fn main() void {
+    bar();
+    foo();
+    foo();
+    bar();
+    foo();
+    bar();
+}
+fn foo() void {
+    bar();
+}
+fn bar() void {}
+
+// run
+//
diff --git a/test/cases/function_calls.2.zig b/test/cases/function_calls.2.zig
new file mode 100644
index 0000000000000000000000000000000000000000..ce5627378a891a2f894ac79e7197f566f51aa958
--- /dev/null
+++ b/test/cases/function_calls.2.zig
@@ -0,0 +1,14 @@
+pub fn main() void {
+    bar();
+    foo();
+    return;
+}
+fn foo() void {
+    bar();
+    bar();
+    bar();
+}
+fn bar() void {}
+
+// run
+//
diff --git a/test/cases/function_calls.3.zig b/test/cases/function_calls.3.zig
new file mode 100644
index 0000000000000000000000000000000000000000..0316d9042d6b2888e0c7f3a71a2e99fe06bfbc8f
--- /dev/null
+++ b/test/cases/function_calls.3.zig
@@ -0,0 +1,10 @@
+pub fn main() void {
+    foo(10, 20);
+}
+fn foo(x: u8, y: u8) void {
+    _ = x;
+    _ = y;
+}
+
+// run
+//
diff --git a/test/cases/function_redeclaration.zig b/test/cases/function_redeclaration.zig
new file mode 100644
index 0000000000000000000000000000000000000000..a9664646c98a4dcb5b889de88ddfc60ce8d5d8d5
--- /dev/null
+++ b/test/cases/function_redeclaration.zig
@@ -0,0 +1,14 @@
+// dummy comment
+fn entry() void {}
+fn entry() void {}
+
+fn foo() void {
+    var foo = 1234;
+}
+
+// error
+//
+// :3:1: error: redeclaration of 'entry'
+// :2:1: note: other declaration here
+// :6:9: error: local shadows declaration of 'foo'
+// :5:1: note: declared here
diff --git a/test/cases/global_variable_redeclaration.zig b/test/cases/global_variable_redeclaration.zig
new file mode 100644
index 0000000000000000000000000000000000000000..9a0d5939fbffc35ff3da74a6901cf8d69dec421a
--- /dev/null
+++ b/test/cases/global_variable_redeclaration.zig
@@ -0,0 +1,8 @@
+// dummy comment
+var foo = false;
+var foo = true;
+
+// error
+//
+// :3:1: error: redeclaration of 'foo'
+// :2:1: note: other declaration here
diff --git a/test/cases/inner_func_accessing_outer_var.zig b/test/cases/inner_func_accessing_outer_var.zig
new file mode 100644
index 0000000000000000000000000000000000000000..e30cf58ef84d54e38ecfac903a7e47437d971a68
--- /dev/null
+++ b/test/cases/inner_func_accessing_outer_var.zig
@@ -0,0 +1,15 @@
+pub fn f() void {
+    var bar: bool = true;
+    const S = struct {
+        fn baz() bool {
+            return bar;
+        }
+    };
+    _ = S;
+}
+
+// error
+//
+// :5:20: error: mutable 'bar' not accessible from here
+// :2:9: note: declared mutable here
+// :3:15: note: crosses namespace boundary here
diff --git a/test/cases/int_to_ptr.0.zig b/test/cases/int_to_ptr.0.zig
new file mode 100644
index 0000000000000000000000000000000000000000..b7c70b90a44ff58c786fa8b18fa3b440caef980f
--- /dev/null
+++ b/test/cases/int_to_ptr.0.zig
@@ -0,0 +1,8 @@
+pub fn main() void {
+    _ = @intToPtr(*u8, 0);
+}
+
+// error
+// output_mode=Exe
+//
+// :2:24: error: pointer type '*u8' does not allow address zero
diff --git a/test/cases/int_to_ptr.1.zig b/test/cases/int_to_ptr.1.zig
new file mode 100644
index 0000000000000000000000000000000000000000..72c8c8c9d6f06d8c7d4e4d49219106160beae122
--- /dev/null
+++ b/test/cases/int_to_ptr.1.zig
@@ -0,0 +1,7 @@
+pub fn main() void {
+    _ = @intToPtr(*u32, 2);
+}
+
+// error
+//
+// :2:25: error: pointer type '*u32' requires aligned address
diff --git a/test/cases/large_add_function.zig b/test/cases/large_add_function.zig
new file mode 100644
index 0000000000000000000000000000000000000000..8b0e9b879b2f9309f29ef99823f5d26e783124c7
--- /dev/null
+++ b/test/cases/large_add_function.zig
@@ -0,0 +1,38 @@
+pub fn main() void {
+    assert(add(3, 4) == 791);
+}
+
+fn add(a: u32, b: u32) u32 {
+    const x: u32 = blk: {
+        const c = a + b; // 7
+        const d = a + c; // 10
+        const e = d + b; // 14
+        const f = d + e; // 24
+        const g = e + f; // 38
+        const h = f + g; // 62
+        const i = g + h; // 100
+        const j = i + d; // 110
+        const k = i + j; // 210
+        const l = k + c; // 217
+        const m = l + d; // 227
+        const n = m + e; // 241
+        const o = n + f; // 265
+        const p = o + g; // 303
+        const q = p + h; // 365
+        const r = q + i; // 465
+        const s = r + j; // 575
+        const t = s + k; // 785
+        break :blk t;
+    };
+    const y = x + a; // 788
+    const z = y + a; // 791
+    return z;
+}
+
+fn assert(ok: bool) void {
+    if (!ok) unreachable;
+}
+
+// run
+// target=aarch64-linux,aarch64-macos
+//
diff --git a/test/cases/llvm/address_space_pointer_access_chaining_pointer_to_optional_array.zig b/test/cases/llvm/address_space_pointer_access_chaining_pointer_to_optional_array.zig
new file mode 100644
index 0000000000000000000000000000000000000000..cf43513159d1fb4ffe7e5a913833f2f343578e7e
--- /dev/null
+++ b/test/cases/llvm/address_space_pointer_access_chaining_pointer_to_optional_array.zig
@@ -0,0 +1,12 @@
+fn entry(a: *addrspace(.gs) ?[1]i32) *addrspace(.gs) i32 {
+    return &a.*.?[0];
+}
+pub fn main() void {
+    _ = entry;
+}
+
+// error
+// output_mode=Exe
+// backend=llvm
+// target=x86_64-linux,x86_64-macos
+//
diff --git a/test/cases/llvm/address_spaces_pointer_access_chaining_array_pointer.zig b/test/cases/llvm/address_spaces_pointer_access_chaining_array_pointer.zig
new file mode 100644
index 0000000000000000000000000000000000000000..5907c1dad5e961a35d9116f4c1c94a4dc0fbb4da
--- /dev/null
+++ b/test/cases/llvm/address_spaces_pointer_access_chaining_array_pointer.zig
@@ -0,0 +1,12 @@
+fn entry(a: *addrspace(.gs) [1]i32) *addrspace(.gs) i32 {
+    return &a[0];
+}
+pub fn main() void {
+    _ = entry;
+}
+
+// error
+// output_mode=Exe
+// backend=stage2,llvm
+// target=x86_64-linux,x86_64-macos
+//
diff --git a/test/cases/llvm/address_spaces_pointer_access_chaining_complex.zig b/test/cases/llvm/address_spaces_pointer_access_chaining_complex.zig
new file mode 100644
index 0000000000000000000000000000000000000000..ece0614f73040a8a73e22dd356721b815dc115db
--- /dev/null
+++ b/test/cases/llvm/address_spaces_pointer_access_chaining_complex.zig
@@ -0,0 +1,13 @@
+const A = struct { a: ?[1]i32 };
+fn entry(a: *addrspace(.gs) [1]A) *addrspace(.gs) i32 {
+    return &a[0].a.?[0];
+}
+pub fn main() void {
+    _ = entry;
+}
+
+// error
+// output_mode=Exe
+// backend=llvm
+// target=x86_64-linux,x86_64-macos
+//
diff --git a/test/cases/llvm/address_spaces_pointer_access_chaining_struct_pointer.zig b/test/cases/llvm/address_spaces_pointer_access_chaining_struct_pointer.zig
new file mode 100644
index 0000000000000000000000000000000000000000..9175bcbc0ea9165f083ec8973f606ef5baa57040
--- /dev/null
+++ b/test/cases/llvm/address_spaces_pointer_access_chaining_struct_pointer.zig
@@ -0,0 +1,13 @@
+const A = struct { a: i32 };
+fn entry(a: *addrspace(.gs) A) *addrspace(.gs) i32 {
+    return &a.a;
+}
+pub fn main() void {
+    _ = entry;
+}
+
+// error
+// output_mode=Exe
+// backend=stage2,llvm
+// target=x86_64-linux,x86_64-macos
+//
diff --git a/test/cases/llvm/any_typed_null_to_any_typed_optional.zig b/test/cases/llvm/any_typed_null_to_any_typed_optional.zig
new file mode 100644
index 0000000000000000000000000000000000000000..c155d044976655e1becf111027c00d25edadbb90
--- /dev/null
+++ b/test/cases/llvm/any_typed_null_to_any_typed_optional.zig
@@ -0,0 +1,11 @@
+pub fn main() void {
+    var a: ?*anyopaque = undefined;
+    a = @as(?usize, null);
+}
+
+// error
+// output_mode=Exe
+// backend=stage2,llvm
+// target=x86_64-linux,x86_64-macos
+//
+// :3:21: error: expected *anyopaque, found ?usize
diff --git a/test/cases/llvm/blocks.zig b/test/cases/llvm/blocks.zig
new file mode 100644
index 0000000000000000000000000000000000000000..c64909c7fea640a33c5fcf793f6ed82fe3189ba6
--- /dev/null
+++ b/test/cases/llvm/blocks.zig
@@ -0,0 +1,22 @@
+fn assert(ok: bool) void {
+    if (!ok) unreachable;
+}
+
+fn foo(ok: bool) i32 {
+    const val: i32 = blk: {
+        var x: i32 = 1;
+        if (!ok) break :blk x + 9;
+        break :blk x + 19;
+    };
+    return val + 10;
+}
+
+pub fn main() void {
+    assert(foo(false) == 20);
+    assert(foo(true) == 30);
+}
+
+// run
+// backend=stage2,llvm
+// target=x86_64-linux,x86_64-macos
+//
diff --git a/test/cases/llvm/dereferencing_though_multiple_pointers_with_address_spaces.zig b/test/cases/llvm/dereferencing_though_multiple_pointers_with_address_spaces.zig
new file mode 100644
index 0000000000000000000000000000000000000000..8f3670075717006113252c90086f21059337b61f
--- /dev/null
+++ b/test/cases/llvm/dereferencing_though_multiple_pointers_with_address_spaces.zig
@@ -0,0 +1,12 @@
+fn entry(a: *addrspace(.fs) *addrspace(.gs) *i32) *i32 {
+    return a.*.*;
+}
+pub fn main() void {
+    _ = entry;
+}
+
+// error
+// output_mode=Exe
+// backend=stage2,llvm
+// target=x86_64-linux,x86_64-macos
+//
diff --git a/test/cases/llvm/f_segment_address_space_reading_and_writing.zig b/test/cases/llvm/f_segment_address_space_reading_and_writing.zig
new file mode 100644
index 0000000000000000000000000000000000000000..62db92668b4da29b83dc36fdbb531eba4124a882
--- /dev/null
+++ b/test/cases/llvm/f_segment_address_space_reading_and_writing.zig
@@ -0,0 +1,48 @@
+fn assert(ok: bool) void {
+    if (!ok) unreachable;
+}
+
+fn setFs(value: c_ulong) void {
+    asm volatile (
+        \\syscall
+        :
+        : [number] "{rax}" (158),
+          [code] "{rdi}" (0x1002),
+          [val] "{rsi}" (value),
+        : "rcx", "r11", "memory"
+    );
+}
+
+fn getFs() c_ulong {
+    var result: c_ulong = undefined;
+    asm volatile (
+        \\syscall
+        :
+        : [number] "{rax}" (158),
+          [code] "{rdi}" (0x1003),
+          [ptr] "{rsi}" (@ptrToInt(&result)),
+        : "rcx", "r11", "memory"
+    );
+    return result;
+}
+
+var test_value: u64 = 12345;
+
+pub fn main() void {
+    const orig_fs = getFs();
+
+    setFs(@ptrToInt(&test_value));
+    assert(getFs() == @ptrToInt(&test_value));
+
+    var test_ptr = @intToPtr(*allowzero addrspace(.fs) u64, 0);
+    assert(test_ptr.* == 12345);
+    test_ptr.* = 98765;
+    assert(test_value == 98765);
+
+    setFs(orig_fs);
+}
+
+// run
+// backend=llvm
+// target=x86_64-linux
+//
diff --git a/test/cases/llvm/for_loop.zig b/test/cases/llvm/for_loop.zig
new file mode 100644
index 0000000000000000000000000000000000000000..e7e701aafaa88ddd9617e9b24db34fe27b71133e
--- /dev/null
+++ b/test/cases/llvm/for_loop.zig
@@ -0,0 +1,16 @@
+fn assert(ok: bool) void {
+    if (!ok) unreachable;
+}
+
+pub fn main() void {
+    var x: u32 = 0;
+    for ("hello") |_| {
+        x += 1;
+    }
+    assert("hello".len == x);
+}
+
+// run
+// backend=stage2,llvm
+// target=x86_64-linux,x86_64-macos
+//
diff --git a/test/cases/llvm/hello_world.zig b/test/cases/llvm/hello_world.zig
new file mode 100644
index 0000000000000000000000000000000000000000..4243191b0fb7a82da70c8f00ad28e72439b968f1
--- /dev/null
+++ b/test/cases/llvm/hello_world.zig
@@ -0,0 +1,12 @@
+extern fn puts(s: [*:0]const u8) c_int;
+
+pub fn main() void {
+    _ = puts("hello world!");
+}
+
+// run
+// backend=llvm
+// target=x86_64-linux,x86_64-macos
+//
+// hello world!
+//
diff --git a/test/cases/llvm/invalid_address_space_coercion.zig b/test/cases/llvm/invalid_address_space_coercion.zig
new file mode 100644
index 0000000000000000000000000000000000000000..6b72f1d5a8ada2bebfecc79b0b780d9af20eb3d8
--- /dev/null
+++ b/test/cases/llvm/invalid_address_space_coercion.zig
@@ -0,0 +1,13 @@
+fn entry(a: *addrspace(.gs) i32) *i32 {
+    return a;
+}
+pub fn main() void {
+    _ = entry;
+}
+
+// error
+// output_mode=Exe
+// backend=stage2,llvm
+// target=x86_64-linux,x86_64-macos
+//
+// :2:12: error: expected *i32, found *addrspace(.gs) i32
diff --git a/test/cases/llvm/invalid_pointer_keeps_address_space_when_taking_address_of_dereference.zig b/test/cases/llvm/invalid_pointer_keeps_address_space_when_taking_address_of_dereference.zig
new file mode 100644
index 0000000000000000000000000000000000000000..26f68ce7895207a301eb192fc679156573e9d39d
--- /dev/null
+++ b/test/cases/llvm/invalid_pointer_keeps_address_space_when_taking_address_of_dereference.zig
@@ -0,0 +1,13 @@
+fn entry(a: *addrspace(.gs) i32) *i32 {
+    return &a.*;
+}
+pub fn main() void {
+    _ = entry;
+}
+
+// error
+// output_mode=Exe
+// backend=stage2,llvm
+// target=x86_64-linux,x86_64-macos
+//
+// :2:12: error: expected *i32, found *addrspace(.gs) i32
diff --git a/test/cases/llvm/nested_blocks.zig b/test/cases/llvm/nested_blocks.zig
new file mode 100644
index 0000000000000000000000000000000000000000..47b6c5069bffb04c825bd70c695eaca0d7854269
--- /dev/null
+++ b/test/cases/llvm/nested_blocks.zig
@@ -0,0 +1,24 @@
+fn assert(ok: bool) void {
+    if (!ok) unreachable;
+}
+
+fn foo(ok: bool) i32 {
+    var val: i32 = blk: {
+        const val2: i32 = another: {
+            if (!ok) break :blk 10;
+            break :another 10;
+        };
+        break :blk val2 + 10;
+    };
+    return val;
+}
+
+pub fn main() void {
+    assert(foo(false) == 10);
+    assert(foo(true) == 20);
+}
+
+// run
+// backend=stage2, llvm
+// target=x86_64-linux,x86_64-macos
+//
diff --git a/test/cases/llvm/optionals.zig b/test/cases/llvm/optionals.zig
new file mode 100644
index 0000000000000000000000000000000000000000..7d52fc0f17d73b201c3aad46adf461cfe0fe5de2
--- /dev/null
+++ b/test/cases/llvm/optionals.zig
@@ -0,0 +1,45 @@
+fn assert(ok: bool) void {
+    if (!ok) unreachable;
+}
+
+pub fn main() void {
+    var opt_val: ?i32 = 10;
+    var null_val: ?i32 = null;
+
+    var val1: i32 = opt_val.?;
+    const val1_1: i32 = opt_val.?;
+    var ptr_val1 = &(opt_val.?);
+    const ptr_val1_1 = &(opt_val.?);
+
+    var val2: i32 = null_val orelse 20;
+    const val2_2: i32 = null_val orelse 20;
+
+    var value: i32 = 20;
+    var ptr_val2 = &(null_val orelse value);
+
+    const val3 = opt_val orelse 30;
+    var val3_var = opt_val orelse 30;
+
+    assert(val1 == 10);
+    assert(val1_1 == 10);
+    assert(ptr_val1.* == 10);
+    assert(ptr_val1_1.* == 10);
+
+    assert(val2 == 20);
+    assert(val2_2 == 20);
+    assert(ptr_val2.* == 20);
+
+    assert(val3 == 10);
+    assert(val3_var == 10);
+
+    (null_val orelse val2) = 1234;
+    assert(val2 == 1234);
+
+    (opt_val orelse val2) = 5678;
+    assert(opt_val.? == 5678);
+}
+
+// run
+// backend=llvm
+// target=x86_64-linux,x86_64-macos
+//
diff --git a/test/cases/llvm/pointer_keeps_address_space.zig b/test/cases/llvm/pointer_keeps_address_space.zig
new file mode 100644
index 0000000000000000000000000000000000000000..bfd40566f840e493e335031ae44b30c7059e9cf0
--- /dev/null
+++ b/test/cases/llvm/pointer_keeps_address_space.zig
@@ -0,0 +1,12 @@
+fn entry(a: *addrspace(.gs) i32) *addrspace(.gs) i32 {
+    return a;
+}
+pub fn main() void {
+    _ = entry;
+}
+
+// error
+// output_mode=Exe
+// backend=stage2,llvm
+// target=x86_64-linux,x86_64-macos
+//
diff --git a/test/cases/llvm/pointer_keeps_address_space_when_taking_address_of_dereference.zig b/test/cases/llvm/pointer_keeps_address_space_when_taking_address_of_dereference.zig
new file mode 100644
index 0000000000000000000000000000000000000000..8114e86c5da0b836592fbb851fc82d9d0c0ea56c
--- /dev/null
+++ b/test/cases/llvm/pointer_keeps_address_space_when_taking_address_of_dereference.zig
@@ -0,0 +1,12 @@
+fn entry(a: *addrspace(.gs) i32) *addrspace(.gs) i32 {
+    return &a.*;
+}
+pub fn main() void {
+    _ = entry;
+}
+
+// error
+// output_mode=Exe
+// backend=stage2,llvm
+// target=x86_64-linux,x86_64-macos
+//
diff --git a/test/cases/llvm/pointer_to_explicit_generic_address_space_coerces_to_implicit_pointer.zig b/test/cases/llvm/pointer_to_explicit_generic_address_space_coerces_to_implicit_pointer.zig
new file mode 100644
index 0000000000000000000000000000000000000000..78bc3e4bd6f42e5babba073ffa042ce04fffb071
--- /dev/null
+++ b/test/cases/llvm/pointer_to_explicit_generic_address_space_coerces_to_implicit_pointer.zig
@@ -0,0 +1,12 @@
+fn entry(a: *addrspace(.generic) i32) *i32 {
+    return a;
+}
+pub fn main() void {
+    _ = entry;
+}
+
+// error
+// output_mode=Exe
+// backend=stage2,llvm
+// target=x86_64-linux,x86_64-macos
+//
diff --git a/test/cases/llvm/pointer_with_different_address_spaces.zig b/test/cases/llvm/pointer_with_different_address_spaces.zig
new file mode 100644
index 0000000000000000000000000000000000000000..8fbd8b07cfccbcd8f8897881ca38d868c68eff4b
--- /dev/null
+++ b/test/cases/llvm/pointer_with_different_address_spaces.zig
@@ -0,0 +1,13 @@
+fn entry(a: *addrspace(.gs) i32) *addrspace(.fs) i32 {
+    return a;
+}
+pub fn main() void {
+    _ = entry;
+}
+
+// error
+// output_mode=Exe
+// backend=stage2,llvm
+// target=x86_64-linux,x86_64-macos
+//
+// :2:12: error: expected *addrspace(.fs) i32, found *addrspace(.gs) i32
diff --git a/test/cases/llvm/pointers_with_different_address_spaces.zig b/test/cases/llvm/pointers_with_different_address_spaces.zig
new file mode 100644
index 0000000000000000000000000000000000000000..39e5e6a6d176e58fd8237a425e06a9517edf3590
--- /dev/null
+++ b/test/cases/llvm/pointers_with_different_address_spaces.zig
@@ -0,0 +1,13 @@
+fn entry(a: ?*addrspace(.gs) i32) *i32 {
+    return a.?;
+}
+pub fn main() void {
+    _ = entry;
+}
+
+// error
+// output_mode=Exe
+// backend=stage2,llvm
+// target=x86_64-linux,x86_64-macos
+//
+// :2:13: error: expected *i32, found *addrspace(.gs) i32
diff --git a/test/cases/llvm/rem.zig b/test/cases/llvm/rem.zig
new file mode 100644
index 0000000000000000000000000000000000000000..9804338ea6f946fbac06a3e8737929002ab5bf0b
--- /dev/null
+++ b/test/cases/llvm/rem.zig
@@ -0,0 +1,15 @@
+fn assert(ok: bool) void {
+    if (!ok) unreachable;
+}
+fn rem(lhs: i32, rhs: i32, expected: i32) bool {
+    return @rem(lhs, rhs) == expected;
+}
+pub fn main() void {
+    assert(rem(-5, 3, -2));
+    assert(rem(5, 3, 2));
+}
+
+// run
+// backend=stage2,llvm
+// target=x86_64-linux,x86_64-macos
+//
diff --git a/test/cases/llvm/shift_right_plus_left.0.zig b/test/cases/llvm/shift_right_plus_left.0.zig
new file mode 100644
index 0000000000000000000000000000000000000000..23b733c4934ba1dc65ea50ecac37ef447142104a
--- /dev/null
+++ b/test/cases/llvm/shift_right_plus_left.0.zig
@@ -0,0 +1,12 @@
+pub fn main() void {
+    var i: u32 = 16;
+    assert(i >> 1, 8);
+}
+fn assert(a: u32, b: u32) void {
+    if (a != b) unreachable;
+}
+
+// run
+// backend=llvm
+// target=x86_64-linux,x86_64-macos
+//
diff --git a/test/cases/llvm/shift_right_plus_left.1.zig b/test/cases/llvm/shift_right_plus_left.1.zig
new file mode 100644
index 0000000000000000000000000000000000000000..994b67b9d0bc4c8da0c1c344503885c2a8a0dd16
--- /dev/null
+++ b/test/cases/llvm/shift_right_plus_left.1.zig
@@ -0,0 +1,10 @@
+pub fn main() void {
+    var i: u32 = 16;
+    assert(i << 1, 32);
+}
+fn assert(a: u32, b: u32) void {
+    if (a != b) unreachable;
+}
+
+// run
+//
diff --git a/test/cases/llvm/simple_addition_and_subtraction.zig b/test/cases/llvm/simple_addition_and_subtraction.zig
new file mode 100644
index 0000000000000000000000000000000000000000..8a6f419f4a5c64649aa3f7618394c0264b667304
--- /dev/null
+++ b/test/cases/llvm/simple_addition_and_subtraction.zig
@@ -0,0 +1,20 @@
+fn add(a: i32, b: i32) i32 {
+    return a + b;
+}
+
+pub fn main() void {
+    var a: i32 = -5;
+    const x = add(a, 7);
+    var y = add(2, 0);
+    y -= x;
+    assert(y == 0);
+}
+
+fn assert(ok: bool) void {
+    if (!ok) unreachable;
+}
+
+// run
+// backend=stage2,llvm
+// target=x86_64-linux,x86_64-macos
+//
diff --git a/test/cases/llvm/simple_if_statement.zig b/test/cases/llvm/simple_if_statement.zig
new file mode 100644
index 0000000000000000000000000000000000000000..73cf08cda2b45477f87b222dbf5b46cadd6917d9
--- /dev/null
+++ b/test/cases/llvm/simple_if_statement.zig
@@ -0,0 +1,16 @@
+fn add(a: i32, b: i32) i32 {
+    return a + b;
+}
+
+fn assert(ok: bool) void {
+    if (!ok) unreachable;
+}
+
+pub fn main() void {
+    assert(add(1, 2) == 3);
+}
+
+// run
+// backend=stage2,llvm
+// target=x86_64-linux,x86_64-macos
+//
diff --git a/test/cases/llvm/while_loops.zig b/test/cases/llvm/while_loops.zig
new file mode 100644
index 0000000000000000000000000000000000000000..3b9276cf7f31fd3fc22e5db640533026ce6f0834
--- /dev/null
+++ b/test/cases/llvm/while_loops.zig
@@ -0,0 +1,18 @@
+fn assert(ok: bool) void {
+    if (!ok) unreachable;
+}
+
+pub fn main() void {
+    var sum: u32 = 0;
+    var i: u32 = 0;
+    while (i < 5) : (i += 1) {
+        sum += i;
+    }
+    assert(sum == 10);
+    assert(i == 5);
+}
+
+// run
+// backend=stage2,llvm
+// target=x86_64-linux,x86_64-macos
+//
diff --git a/test/cases/lower_unnamed_consts_structs.0.zig b/test/cases/lower_unnamed_consts_structs.0.zig
new file mode 100644
index 0000000000000000000000000000000000000000..31232996461ac972b886c5bb30b9c91ff6840d52
--- /dev/null
+++ b/test/cases/lower_unnamed_consts_structs.0.zig
@@ -0,0 +1,25 @@
+const Foo = struct {
+    a: u8,
+    b: u32,
+
+    fn first(self: *Foo) u8 {
+        return self.a;
+    }
+
+    fn second(self: *Foo) u32 {
+        return self.b;
+    }
+};
+
+pub fn main() void {
+    var foo = Foo{ .a = 1, .b = 5 };
+    assert(foo.first() == 1);
+    assert(foo.second() == 5);
+}
+
+fn assert(ok: bool) void {
+    if (!ok) unreachable;
+}
+
+// run
+//
diff --git a/test/cases/lower_unnamed_consts_structs.1.zig b/test/cases/lower_unnamed_consts_structs.1.zig
new file mode 100644
index 0000000000000000000000000000000000000000..37afdc8a09c0f08f0351a4d0201416e17455b07b
--- /dev/null
+++ b/test/cases/lower_unnamed_consts_structs.1.zig
@@ -0,0 +1,35 @@
+const Foo = struct {
+    a: u8,
+    b: u32,
+
+    fn first(self: *Foo) u8 {
+        return self.a;
+    }
+
+    fn second(self: *Foo) u32 {
+        return self.b;
+    }
+};
+
+pub fn main() void {
+    var foo = Foo{ .a = 1, .b = 5 };
+    assert(foo.first() == 1);
+    assert(foo.second() == 5);
+
+    foo.a = 10;
+    foo.b = 255;
+
+    assert(foo.first() == 10);
+    assert(foo.second() == 255);
+
+    var foo2 = Foo{ .a = 15, .b = 255 };
+    assert(foo2.first() == 15);
+    assert(foo2.second() == 255);
+}
+
+fn assert(ok: bool) void {
+    if (!ok) unreachable;
+}
+
+// run
+//
diff --git a/test/cases/lower_unnamed_consts_structs.2.zig b/test/cases/lower_unnamed_consts_structs.2.zig
new file mode 100644
index 0000000000000000000000000000000000000000..b437c4a030aae4842b371abef19074f27b76d556
--- /dev/null
+++ b/test/cases/lower_unnamed_consts_structs.2.zig
@@ -0,0 +1,25 @@
+const Foo = struct {
+    a: u8,
+    b: u32,
+
+    fn first(self: *Foo) u8 {
+        return self.a;
+    }
+
+    fn second(self: *Foo) u32 {
+        return self.b;
+    }
+};
+
+pub fn main() void {
+    var foo2 = Foo{ .a = 15, .b = 255 };
+    assert(foo2.first() == 15);
+    assert(foo2.second() == 255);
+}
+
+fn assert(ok: bool) void {
+    if (!ok) unreachable;
+}
+
+// run
+//
diff --git a/test/cases/merge_error_sets.0.zig b/test/cases/merge_error_sets.0.zig
new file mode 100644
index 0000000000000000000000000000000000000000..f1f3b968830988d3d8e6105f1bd97d49345a8d08
--- /dev/null
+++ b/test/cases/merge_error_sets.0.zig
@@ -0,0 +1,18 @@
+pub fn main() void {
+    const E = error{ A, B, D } || error{ A, B, C };
+    E.A catch {};
+    E.B catch {};
+    E.C catch {};
+    E.D catch {};
+    const E2 = error{ X, Y } || @TypeOf(error.Z);
+    E2.X catch {};
+    E2.Y catch {};
+    E2.Z catch {};
+    assert(anyerror || error{Z} == anyerror);
+}
+fn assert(b: bool) void {
+    if (!b) unreachable;
+}
+
+// run
+//
diff --git a/test/cases/merge_error_sets.1.zig b/test/cases/merge_error_sets.1.zig
new file mode 100644
index 0000000000000000000000000000000000000000..81c1cad134ec58f46201197a827608b88389f344
--- /dev/null
+++ b/test/cases/merge_error_sets.1.zig
@@ -0,0 +1,9 @@
+pub fn main() void {
+    const z = true || false;
+    _ = z;
+}
+
+// error
+//
+// :2:15: error: expected error set type, found 'bool'
+// :2:20: note: '||' merges error sets; 'or' performs boolean OR
diff --git a/test/cases/multiplying_numbers_at_runtime_and_comptime.0.zig b/test/cases/multiplying_numbers_at_runtime_and_comptime.0.zig
new file mode 100644
index 0000000000000000000000000000000000000000..f113928982fbeedd44b3eab66d73c46bba0b3721
--- /dev/null
+++ b/test/cases/multiplying_numbers_at_runtime_and_comptime.0.zig
@@ -0,0 +1,11 @@
+pub fn main() void {
+    mul(3, 4);
+}
+
+fn mul(a: u32, b: u32) void {
+    if (a * b != 12) unreachable;
+}
+
+// run
+// target=x86_64-linux,x86_64-macos
+//
diff --git a/test/cases/multiplying_numbers_at_runtime_and_comptime.1.zig b/test/cases/multiplying_numbers_at_runtime_and_comptime.1.zig
new file mode 100644
index 0000000000000000000000000000000000000000..1dff884900dcf2811722ea7a9cc6d99484d0f913
--- /dev/null
+++ b/test/cases/multiplying_numbers_at_runtime_and_comptime.1.zig
@@ -0,0 +1,12 @@
+pub fn main() void {
+    if (x - 12 != 0) unreachable;
+}
+
+fn mul(a: u32, b: u32) u32 {
+    return a * b;
+}
+
+const x = mul(3, 4);
+
+// run
+//
diff --git a/test/cases/multiplying_numbers_at_runtime_and_comptime.2.zig b/test/cases/multiplying_numbers_at_runtime_and_comptime.2.zig
new file mode 100644
index 0000000000000000000000000000000000000000..31093729baa7924f2f6461d8049ad5e2f40a2ba5
--- /dev/null
+++ b/test/cases/multiplying_numbers_at_runtime_and_comptime.2.zig
@@ -0,0 +1,12 @@
+pub fn main() void {
+    var x: usize = 5;
+    const y = mul(2, 3, x);
+    if (y - 30 != 0) unreachable;
+}
+
+inline fn mul(a: usize, b: usize, c: usize) usize {
+    return a * b * c;
+}
+
+// run
+//
diff --git a/test/cases/non_leaf_functions.zig b/test/cases/non_leaf_functions.zig
new file mode 100644
index 0000000000000000000000000000000000000000..cb1737130e0e2cebd51b96e1c11ca8d8f7ee799f
--- /dev/null
+++ b/test/cases/non_leaf_functions.zig
@@ -0,0 +1,12 @@
+pub fn main() void {
+    foo();
+}
+
+fn foo() void {
+    bar();
+}
+
+fn bar() void {}
+
+// run
+//
diff --git a/test/cases/optional_payload.0.zig b/test/cases/optional_payload.0.zig
new file mode 100644
index 0000000000000000000000000000000000000000..65296875ff1c27542bf6ee87b3e66d720b023cf5
--- /dev/null
+++ b/test/cases/optional_payload.0.zig
@@ -0,0 +1,19 @@
+pub fn main() void {
+    var x: u32 = undefined;
+    const maybe_x = byPtr(&x);
+    assert(maybe_x != null);
+    maybe_x.?.* = 123;
+    assert(x == 123);
+}
+
+fn byPtr(x: *u32) ?*u32 {
+    return x;
+}
+
+fn assert(ok: bool) void {
+    if (!ok) unreachable;
+}
+
+// run
+// target=x86_64-linux,x86_64-macos
+//
diff --git a/test/cases/optional_payload.1.zig b/test/cases/optional_payload.1.zig
new file mode 100644
index 0000000000000000000000000000000000000000..2d4dafffb9bdb898c20465beba6ec86a7ef54985
--- /dev/null
+++ b/test/cases/optional_payload.1.zig
@@ -0,0 +1,17 @@
+pub fn main() void {
+    var x: u32 = undefined;
+    const maybe_x = byPtr(&x);
+    assert(maybe_x == null);
+}
+
+fn byPtr(x: *u32) ?*u32 {
+    _ = x;
+    return null;
+}
+
+fn assert(ok: bool) void {
+    if (!ok) unreachable;
+}
+
+// run
+//
diff --git a/test/cases/optional_payload.2.zig b/test/cases/optional_payload.2.zig
new file mode 100644
index 0000000000000000000000000000000000000000..608310923bad2f4a376c63f6673c7f66c2275679
--- /dev/null
+++ b/test/cases/optional_payload.2.zig
@@ -0,0 +1,18 @@
+pub fn main() void {
+    var x: u8 = undefined;
+    const maybe_x = byPtr(&x);
+    assert(maybe_x != null);
+    maybe_x.?.* = 255;
+    assert(x == 255);
+}
+
+fn byPtr(x: *u8) ?*u8 {
+    return x;
+}
+
+fn assert(ok: bool) void {
+    if (!ok) unreachable;
+}
+
+// run
+//
diff --git a/test/cases/optional_payload.3.zig b/test/cases/optional_payload.3.zig
new file mode 100644
index 0000000000000000000000000000000000000000..b81ec398c7a28ed88b5dab7295fcbf9fafa19c83
--- /dev/null
+++ b/test/cases/optional_payload.3.zig
@@ -0,0 +1,18 @@
+pub fn main() void {
+    var x: i8 = undefined;
+    const maybe_x = byPtr(&x);
+    assert(maybe_x != null);
+    maybe_x.?.* = -1;
+    assert(x == -1);
+}
+
+fn byPtr(x: *i8) ?*i8 {
+    return x;
+}
+
+fn assert(ok: bool) void {
+    if (!ok) unreachable;
+}
+
+// run
+//
diff --git a/test/cases/orelse_at_comptime.0.zig b/test/cases/orelse_at_comptime.0.zig
new file mode 100644
index 0000000000000000000000000000000000000000..5397ca3b0afae077fb60745b35c3011576c8a49d
--- /dev/null
+++ b/test/cases/orelse_at_comptime.0.zig
@@ -0,0 +1,11 @@
+pub fn main() void {
+    const i: ?u64 = 0;
+    const result = i orelse 5;
+    assert(result == 0);
+}
+fn assert(b: bool) void {
+    if (!b) unreachable;
+}
+
+// run
+//
diff --git a/test/cases/orelse_at_comptime.1.zig b/test/cases/orelse_at_comptime.1.zig
new file mode 100644
index 0000000000000000000000000000000000000000..7d4fcd3178a34fc251f78f49b54857c759dc9254
--- /dev/null
+++ b/test/cases/orelse_at_comptime.1.zig
@@ -0,0 +1,11 @@
+pub fn main() void {
+    const i: ?u64 = null;
+    const result = i orelse 5;
+    assert(result == 5);
+}
+fn assert(b: bool) void {
+    if (!b) unreachable;
+}
+
+// run
+//
diff --git a/test/cases/passing_u0_to_function.zig b/test/cases/passing_u0_to_function.zig
new file mode 100644
index 0000000000000000000000000000000000000000..f84c30be8a4128afa10d50a576ad2600bc8ad5a0
--- /dev/null
+++ b/test/cases/passing_u0_to_function.zig
@@ -0,0 +1,9 @@
+pub fn main() void {
+    doNothing(0);
+}
+fn doNothing(arg: u0) void {
+    _ = arg;
+}
+
+// run
+//
diff --git a/test/cases/plan9/exit.zig b/test/cases/plan9/exit.zig
new file mode 100644
index 0000000000000000000000000000000000000000..735818fb8336c564521926398a7f7d57e7607c07
--- /dev/null
+++ b/test/cases/plan9/exit.zig
@@ -0,0 +1,5 @@
+pub fn main() void {}
+
+// run
+// target=x86_64-plan9,aarch64-plan9
+//
diff --git a/test/cases/plan9/hello_world_with_updates.0.zig b/test/cases/plan9/hello_world_with_updates.0.zig
new file mode 100644
index 0000000000000000000000000000000000000000..7e7c3732518c776f31450f33083af7289c7f6e19
--- /dev/null
+++ b/test/cases/plan9/hello_world_with_updates.0.zig
@@ -0,0 +1,28 @@
+pub fn main() void {
+    const str = "Hello World!\n";
+    asm volatile (
+        \\push $0
+        \\push %%r10
+        \\push %%r11
+        \\push $1
+        \\push $0
+        \\syscall
+        \\pop %%r11
+        \\pop %%r11
+        \\pop %%r11
+        \\pop %%r11
+        \\pop %%r11
+        :
+        // pwrite
+        : [syscall_number] "{rbp}" (51),
+          [hey] "{r11}" (@ptrToInt(str)),
+          [strlen] "{r10}" (str.len),
+        : "rcx", "rbp", "r11", "memory"
+    );
+}
+
+// run
+// target=x86_64-plan9
+//
+// Hello World
+//
diff --git a/test/cases/plan9/hello_world_with_updates.1.zig b/test/cases/plan9/hello_world_with_updates.1.zig
new file mode 100644
index 0000000000000000000000000000000000000000..4111a8dc08738a33687e328cb75e92c3c9112d98
--- /dev/null
+++ b/test/cases/plan9/hello_world_with_updates.1.zig
@@ -0,0 +1,10 @@
+const std = @import("std");
+pub fn main() void {
+    const str = "Hello World!\n";
+    _ = std.os.plan9.pwrite(1, str, str.len, 0);
+}
+
+// run
+//
+// Hello World
+//
diff --git a/test/cases/recursive_fibonacci.zig b/test/cases/recursive_fibonacci.zig
new file mode 100644
index 0000000000000000000000000000000000000000..4e284e3fc1807365381c1fd4098ae8ffc31298d5
--- /dev/null
+++ b/test/cases/recursive_fibonacci.zig
@@ -0,0 +1,24 @@
+pub fn main() void {
+    assert(fib(0) == 0);
+    assert(fib(1) == 1);
+    assert(fib(2) == 1);
+    assert(fib(3) == 2);
+    assert(fib(10) == 55);
+    assert(fib(20) == 6765);
+}
+
+fn fib(n: u32) u32 {
+    if (n < 2) {
+        return n;
+    } else {
+        return fib(n - 2) + fib(n - 1);
+    }
+}
+
+fn assert(ok: bool) void {
+    if (!ok) unreachable;
+}
+
+// run
+// target=arm-linux,x86_64-linux,x86_64-macos,wasm32-wasi
+//
diff --git a/test/cases/recursive_inline_function.0.zig b/test/cases/recursive_inline_function.0.zig
new file mode 100644
index 0000000000000000000000000000000000000000..c8333c906516bccd45128a99106fc510a0ea4d9f
--- /dev/null
+++ b/test/cases/recursive_inline_function.0.zig
@@ -0,0 +1,12 @@
+pub fn main() void {
+    const y = fibonacci(7);
+    if (y - 21 != 0) unreachable;
+}
+
+inline fn fibonacci(n: usize) usize {
+    if (n <= 2) return n;
+    return fibonacci(n - 2) + fibonacci(n - 1);
+}
+
+// run
+//
diff --git a/test/cases/recursive_inline_function.1.zig b/test/cases/recursive_inline_function.1.zig
new file mode 100644
index 0000000000000000000000000000000000000000..139da1c371292c2cbf196d87c3cb80c4fcd3315b
--- /dev/null
+++ b/test/cases/recursive_inline_function.1.zig
@@ -0,0 +1,16 @@
+// This additionally tests that the compile error reports the correct source location.
+// Without storing source locations relative to the owner decl, the compile error
+// here would be off by 2 bytes (from the "7" -> "999").
+pub fn main() void {
+    const y = fibonacci(999);
+    if (y - 21 != 0) unreachable;
+}
+
+inline fn fibonacci(n: usize) usize {
+    if (n <= 2) return n;
+    return fibonacci(n - 2) + fibonacci(n - 1);
+}
+
+// error
+//
+// :11:21: error: evaluation exceeded 1000 backwards branches
diff --git a/test/cases/redundant_comptime.0.zig b/test/cases/redundant_comptime.0.zig
new file mode 100644
index 0000000000000000000000000000000000000000..c1ecbf7acec79ac1c60f9f09780e317b609ccd12
--- /dev/null
+++ b/test/cases/redundant_comptime.0.zig
@@ -0,0 +1,7 @@
+pub fn main() void {
+    var a: comptime u32 = 0;
+}
+
+// error
+//
+// :2:12: error: redundant comptime keyword in already comptime scope
diff --git a/test/cases/redundant_comptime.1.zig b/test/cases/redundant_comptime.1.zig
new file mode 100644
index 0000000000000000000000000000000000000000..79226ae8a6b2799dc4e87cfad71219f09a47fc34
--- /dev/null
+++ b/test/cases/redundant_comptime.1.zig
@@ -0,0 +1,9 @@
+pub fn main() void {
+    comptime {
+        var a: u32 = comptime 0;
+    }
+}
+
+// error
+//
+// :3:22: error: redundant comptime keyword in already comptime scope
diff --git a/test/cases/returns_in_try.zig b/test/cases/returns_in_try.zig
new file mode 100644
index 0000000000000000000000000000000000000000..de5a9a3258288c1357d96172f1e8458abe45d4d1
--- /dev/null
+++ b/test/cases/returns_in_try.zig
@@ -0,0 +1,16 @@
+pub fn main() !void {
+    try a();
+    try b();
+}
+
+pub fn a() !void {
+    defer try b();
+}
+pub fn b() !void {
+    defer return a();
+}
+
+// error
+//
+// :7:11: error: 'try' not allowed inside defer expression
+// :10:11: error: cannot return from defer expression
diff --git a/test/cases/riscv64-linux/hello_world_with_updates.0.zig b/test/cases/riscv64-linux/hello_world_with_updates.0.zig
new file mode 100644
index 0000000000000000000000000000000000000000..dd119fd1f4366a089f62a796daf96cf437a43f04
--- /dev/null
+++ b/test/cases/riscv64-linux/hello_world_with_updates.0.zig
@@ -0,0 +1,21 @@
+pub fn main() void {
+    print();
+}
+
+fn print() void {
+    asm volatile ("ecall"
+        :
+        : [number] "{a7}" (64),
+          [arg1] "{a0}" (1),
+          [arg2] "{a1}" (@ptrToInt("Hello, World!\n")),
+          [arg3] "{a2}" ("Hello, World!\n".len),
+        : "rcx", "r11", "memory"
+    );
+    return;
+}
+
+// run
+// target=riscv64-linux
+//
+// Hello, World!
+//
diff --git a/test/cases/riscv64-linux/hello_world_with_updates.1.zig b/test/cases/riscv64-linux/hello_world_with_updates.1.zig
new file mode 100644
index 0000000000000000000000000000000000000000..26718738a9ed459aeb650db31628ad2f2b7de0c6
--- /dev/null
+++ b/test/cases/riscv64-linux/hello_world_with_updates.1.zig
@@ -0,0 +1,27 @@
+pub fn main() void {
+    print();
+    print();
+    print();
+    print();
+}
+
+fn print() void {
+    asm volatile ("ecall"
+        :
+        : [number] "{a7}" (64),
+          [arg1] "{a0}" (1),
+          [arg2] "{a1}" (@ptrToInt("Hello, World!\n")),
+          [arg3] "{a2}" ("Hello, World!\n".len),
+        : "rcx", "r11", "memory"
+    );
+    return;
+}
+
+// run
+// target=riscv64-linux
+//
+// Hello, World!
+// Hello, World!
+// Hello, World!
+// Hello, World!
+//
diff --git a/test/cases/runtime_bitwise_and.zig b/test/cases/runtime_bitwise_and.zig
new file mode 100644
index 0000000000000000000000000000000000000000..3ba3d3124cc400d5ccd309f392c3fd2c593732e3
--- /dev/null
+++ b/test/cases/runtime_bitwise_and.zig
@@ -0,0 +1,16 @@
+pub fn main() void {
+    var i: u32 = 10;
+    var j: u32 = 11;
+    assert(i & 1 == 0);
+    assert(j & 1 == 1);
+    var m1: u32 = 0b1111;
+    var m2: u32 = 0b0000;
+    assert(m1 & 0b1010 == 0b1010);
+    assert(m2 & 0b1010 == 0b0000);
+}
+fn assert(b: bool) void {
+    if (!b) unreachable;
+}
+
+// run
+//
diff --git a/test/cases/runtime_bitwise_or.zig b/test/cases/runtime_bitwise_or.zig
new file mode 100644
index 0000000000000000000000000000000000000000..b97c2acf0228a3314eccb4ab859eee3a7dc2d77b
--- /dev/null
+++ b/test/cases/runtime_bitwise_or.zig
@@ -0,0 +1,16 @@
+pub fn main() void {
+    var i: u32 = 10;
+    var j: u32 = 11;
+    assert(i | 1 == 11);
+    assert(j | 1 == 11);
+    var m1: u32 = 0b1111;
+    var m2: u32 = 0b0000;
+    assert(m1 | 0b1010 == 0b1111);
+    assert(m2 | 0b1010 == 0b1010);
+}
+fn assert(b: bool) void {
+    if (!b) unreachable;
+}
+
+// run
+//
diff --git a/test/cases/save_function_return_values_in_callee_preserved_register.zig b/test/cases/save_function_return_values_in_callee_preserved_register.zig
new file mode 100644
index 0000000000000000000000000000000000000000..a2019038082b4f978de13ebfef6a1439ccbb79f7
--- /dev/null
+++ b/test/cases/save_function_return_values_in_callee_preserved_register.zig
@@ -0,0 +1,22 @@
+pub fn main() void {
+    assert(foo() == 43);
+}
+
+fn foo() u32 {
+    return bar() + baz(42);
+}
+
+fn bar() u32 {
+    return 1;
+}
+
+fn baz(x: u32) u32 {
+    return x;
+}
+
+fn assert(ok: bool) void {
+    if (!ok) unreachable;
+}
+
+// run
+//
diff --git a/test/cases/setting_an_address_space_on_a_local_variable.zig b/test/cases/setting_an_address_space_on_a_local_variable.zig
new file mode 100644
index 0000000000000000000000000000000000000000..dad282dc318cdf22005f31b55a5eda38bd8018a4
--- /dev/null
+++ b/test/cases/setting_an_address_space_on_a_local_variable.zig
@@ -0,0 +1,8 @@
+export fn entry() i32 {
+    var foo: i32 addrspace(".general") = 1234;
+    return foo;
+}
+
+// error
+//
+// :2:28: error: cannot set address space of local variable 'foo'
diff --git a/test/cases/sparcv9-linux/hello_world.zig b/test/cases/sparcv9-linux/hello_world.zig
new file mode 100644
index 0000000000000000000000000000000000000000..327a8c56ad64fb22e31dc190c076b0886cd6cdde
--- /dev/null
+++ b/test/cases/sparcv9-linux/hello_world.zig
@@ -0,0 +1,27 @@
+const msg = "Hello, World!\n";
+
+pub export fn _start() noreturn {
+    asm volatile ("ta 0x6d"
+        :
+        : [number] "{g1}" (4),
+          [arg1] "{o0}" (1),
+          [arg2] "{o1}" (@ptrToInt(msg)),
+          [arg3] "{o2}" (msg.len),
+        : "o0", "o1", "o2", "o3", "o4", "o5", "o6", "o7", "memory"
+    );
+
+    asm volatile ("ta 0x6d"
+        :
+        : [number] "{g1}" (1),
+          [arg1] "{o0}" (0),
+        : "o0", "o1", "o2", "o3", "o4", "o5", "o6", "o7", "memory"
+    );
+
+    unreachable;
+}
+
+// run
+// target=sparcv9-linux
+//
+// Hello, World!
+//
diff --git a/test/cases/try_in_comptime_in_struct_in_test.zig b/test/cases/try_in_comptime_in_struct_in_test.zig
new file mode 100644
index 0000000000000000000000000000000000000000..e88aa13a7b05977ee51d2b63f20baa8f76af159f
--- /dev/null
+++ b/test/cases/try_in_comptime_in_struct_in_test.zig
@@ -0,0 +1,13 @@
+test "@unionInit on union w/ tag but no fields" {
+    const S = struct {
+        comptime {
+            try expect(false);
+        }
+    };
+    _ = S;
+}
+
+// error
+// is_test=1
+//
+// :4:13: error: 'try' outside function scope
diff --git a/test/cases/type_of.0.zig b/test/cases/type_of.0.zig
new file mode 100644
index 0000000000000000000000000000000000000000..d8a97d144470eff0d74fb59464146a17c52f328d
--- /dev/null
+++ b/test/cases/type_of.0.zig
@@ -0,0 +1,13 @@
+pub fn main() void {
+    var x: usize = 0;
+    _ = x;
+    const z = @TypeOf(x, @as(u128, 5));
+    assert(z == u128);
+}
+
+pub fn assert(ok: bool) void {
+    if (!ok) unreachable; // assertion failure
+}
+
+// run
+//
diff --git a/test/cases/type_of.1.zig b/test/cases/type_of.1.zig
new file mode 100644
index 0000000000000000000000000000000000000000..86d7d87a19da452234bebb83b69d8cb0ee1fa1a8
--- /dev/null
+++ b/test/cases/type_of.1.zig
@@ -0,0 +1,11 @@
+pub fn main() void {
+    const z = @TypeOf(true);
+    assert(z == bool);
+}
+
+pub fn assert(ok: bool) void {
+    if (!ok) unreachable; // assertion failure
+}
+
+// run
+//
diff --git a/test/cases/type_of.2.zig b/test/cases/type_of.2.zig
new file mode 100644
index 0000000000000000000000000000000000000000..cdbc8121fd71bc5f6603e8c2ab399154ba9b0c84
--- /dev/null
+++ b/test/cases/type_of.2.zig
@@ -0,0 +1,9 @@
+pub fn main() void {
+    _ = @TypeOf(true, 1);
+}
+
+// error
+//
+// :2:9: error: incompatible types: 'bool' and 'comptime_int'
+// :2:17: note: type 'bool' here
+// :2:23: note: type 'comptime_int' here
diff --git a/test/cases/unused_labels.0.zig b/test/cases/unused_labels.0.zig
new file mode 100644
index 0000000000000000000000000000000000000000..9afa5facdde2c412bd30cd0d43463c2f90cd2cf2
--- /dev/null
+++ b/test/cases/unused_labels.0.zig
@@ -0,0 +1,8 @@
+comptime {
+    foo: {}
+}
+
+// error
+// output_mode=Exe
+//
+// :2:5: error: unused block label
diff --git a/test/cases/unused_labels.1.zig b/test/cases/unused_labels.1.zig
new file mode 100644
index 0000000000000000000000000000000000000000..c7ff576875dcea1d493816bb78ee56b863023707
--- /dev/null
+++ b/test/cases/unused_labels.1.zig
@@ -0,0 +1,7 @@
+comptime {
+    foo: while (true) {}
+}
+
+// error
+//
+// :2:5: error: unused while loop label
diff --git a/test/cases/unused_labels.2.zig b/test/cases/unused_labels.2.zig
new file mode 100644
index 0000000000000000000000000000000000000000..babe3c7b0a1dda7aac83115faf4c60d00aa06543
--- /dev/null
+++ b/test/cases/unused_labels.2.zig
@@ -0,0 +1,7 @@
+comptime {
+    foo: for ("foo") |_| {}
+}
+
+// error
+//
+// :2:5: error: unused for loop label
diff --git a/test/cases/unused_labels.3.zig b/test/cases/unused_labels.3.zig
new file mode 100644
index 0000000000000000000000000000000000000000..e4f3ac05a404667fb60cad6f5fc8bfe43abb457c
--- /dev/null
+++ b/test/cases/unused_labels.3.zig
@@ -0,0 +1,8 @@
+comptime {
+    blk: {blk: {}}
+}
+
+// error
+//
+// :2:11: error: redefinition of label 'blk'
+// :2:5: note: previous definition here
diff --git a/test/cases/unused_vars.zig b/test/cases/unused_vars.zig
new file mode 100644
index 0000000000000000000000000000000000000000..85e168d19a9e479bf93e1500c141551a1f8e2fad
--- /dev/null
+++ b/test/cases/unused_vars.zig
@@ -0,0 +1,7 @@
+pub fn main() void {
+    const x = 1;
+}
+
+// error
+//
+// :2:11: error: unused local constant
diff --git a/test/cases/variable_shadowing.0.zig b/test/cases/variable_shadowing.0.zig
new file mode 100644
index 0000000000000000000000000000000000000000..0ab53a78f929e43ba4edb678f290b05dd042b35f
--- /dev/null
+++ b/test/cases/variable_shadowing.0.zig
@@ -0,0 +1,9 @@
+pub fn main() void {
+    var i: u32 = 10;
+    var i: u32 = 10;
+}
+
+// error
+//
+// :3:9: error: redeclaration of local variable 'i'
+// :2:9: note: previous declaration here
diff --git a/test/cases/variable_shadowing.1.zig b/test/cases/variable_shadowing.1.zig
new file mode 100644
index 0000000000000000000000000000000000000000..af24af038dfc0da511879b35a0edd97415320621
--- /dev/null
+++ b/test/cases/variable_shadowing.1.zig
@@ -0,0 +1,9 @@
+var testing: i64 = 10;
+pub fn main() void {
+    var testing: i64 = 20;
+}
+
+// error
+//
+// :3:9: error: local shadows declaration of 'testing'
+// :1:1: note: declared here
diff --git a/test/cases/variable_shadowing.2.zig b/test/cases/variable_shadowing.2.zig
new file mode 100644
index 0000000000000000000000000000000000000000..a44372f9b978ce8ed3eef164ce81364637fb2313
--- /dev/null
+++ b/test/cases/variable_shadowing.2.zig
@@ -0,0 +1,13 @@
+fn a() type {
+    return struct {
+        pub fn b() void {
+            const c = 6;
+            const c = 69;
+        }
+    };
+}
+
+// error
+//
+// :5:19: error: redeclaration of local constant 'c'
+// :4:19: note: previous declaration here
diff --git a/test/cases/variable_shadowing.3.zig b/test/cases/variable_shadowing.3.zig
new file mode 100644
index 0000000000000000000000000000000000000000..89288705e1b1d70326edefcc81da2ae02cca7ecf
--- /dev/null
+++ b/test/cases/variable_shadowing.3.zig
@@ -0,0 +1,10 @@
+pub fn main() void {
+    var i = 0;
+    for ("n") |_, i| {
+    }
+}
+
+// error
+//
+// :3:19: error: redeclaration of local variable 'i'
+// :2:9: note: previous declaration here
diff --git a/test/cases/variable_shadowing.4.zig b/test/cases/variable_shadowing.4.zig
new file mode 100644
index 0000000000000000000000000000000000000000..b798cc13c1dc018a136fcca8ef4548839b8130fd
--- /dev/null
+++ b/test/cases/variable_shadowing.4.zig
@@ -0,0 +1,10 @@
+pub fn main() void {
+    var i = 0;
+    for ("n") |i| {
+    }
+}
+
+// error
+//
+// :3:16: error: redeclaration of local variable 'i'
+// :2:9: note: previous declaration here
diff --git a/test/cases/variable_shadowing.5.zig b/test/cases/variable_shadowing.5.zig
new file mode 100644
index 0000000000000000000000000000000000000000..484d218ea20e1e46451a1947d8bbedd5aef61d95
--- /dev/null
+++ b/test/cases/variable_shadowing.5.zig
@@ -0,0 +1,10 @@
+pub fn main() void {
+    var i = 0;
+    while ("n") |i| {
+    }
+}
+
+// error
+//
+// :3:18: error: redeclaration of local variable 'i'
+// :2:9: note: previous declaration here
diff --git a/test/cases/variable_shadowing.6.zig b/test/cases/variable_shadowing.6.zig
new file mode 100644
index 0000000000000000000000000000000000000000..3e53c4da2fcbb95783caf037ff8849ddd8d07999
--- /dev/null
+++ b/test/cases/variable_shadowing.6.zig
@@ -0,0 +1,13 @@
+pub fn main() void {
+    var i = 0;
+    while ("n") |bruh| {
+        _ = bruh;
+    } else |i| {
+
+    }
+}
+
+// error
+//
+// :5:13: error: redeclaration of local variable 'i'
+// :2:9: note: previous declaration here
diff --git a/test/cases/variable_shadowing.7.zig b/test/cases/variable_shadowing.7.zig
new file mode 100644
index 0000000000000000000000000000000000000000..95888839a7107a446c9e850946b4f4484d599f00
--- /dev/null
+++ b/test/cases/variable_shadowing.7.zig
@@ -0,0 +1,9 @@
+pub fn main() void {
+    var i = 0;
+    if (true) |i| {}
+}
+
+// error
+//
+// :3:16: error: redeclaration of local variable 'i'
+// :2:9: note: previous declaration here
diff --git a/test/cases/variable_shadowing.8.zig b/test/cases/variable_shadowing.8.zig
new file mode 100644
index 0000000000000000000000000000000000000000..57e616e1d699d2123eb62fc92acda0a0ec02e4fc
--- /dev/null
+++ b/test/cases/variable_shadowing.8.zig
@@ -0,0 +1,9 @@
+pub fn main() void {
+    var i = 0;
+    if (true) |i| {} else |e| {}
+}
+
+// error
+//
+// :3:16: error: redeclaration of local variable 'i'
+// :2:9: note: previous declaration here
diff --git a/test/cases/variable_shadowing.9.zig b/test/cases/variable_shadowing.9.zig
new file mode 100644
index 0000000000000000000000000000000000000000..b8a1198aed4608b4c8fde8f40e3f2f04fdcdef5a
--- /dev/null
+++ b/test/cases/variable_shadowing.9.zig
@@ -0,0 +1,9 @@
+pub fn main() void {
+    var i = 0;
+    if (true) |_| {} else |i| {}
+}
+
+// error
+//
+// :3:28: error: redeclaration of local variable 'i'
+// :2:9: note: previous declaration here
diff --git a/test/cases/wasm-wasi/conditions.0.zig b/test/cases/wasm-wasi/conditions.0.zig
new file mode 100644
index 0000000000000000000000000000000000000000..1167ea85a4413757b8d481b1d672703b2a2ebd2f
--- /dev/null
+++ b/test/cases/wasm-wasi/conditions.0.zig
@@ -0,0 +1,11 @@
+pub fn main() u8 {
+    var i: u8 = 5;
+    if (i > @as(u8, 4)) {
+        i += 10;
+    }
+    return i - 15;
+}
+
+// run
+// target=wasm32-wasi
+//
diff --git a/test/cases/wasm-wasi/conditions.1.zig b/test/cases/wasm-wasi/conditions.1.zig
new file mode 100644
index 0000000000000000000000000000000000000000..f9f03808b97a134f78276875979f483e8ad317e5
--- /dev/null
+++ b/test/cases/wasm-wasi/conditions.1.zig
@@ -0,0 +1,12 @@
+pub fn main() u8 {
+    var i: u8 = 5;
+    if (i < @as(u8, 4)) {
+        i += 10;
+    } else {
+        i = 2;
+    }
+    return i - 2;
+}
+
+// run
+//
diff --git a/test/cases/wasm-wasi/conditions.2.zig b/test/cases/wasm-wasi/conditions.2.zig
new file mode 100644
index 0000000000000000000000000000000000000000..a80ead9ea54084317c55da133d91bf72f305909f
--- /dev/null
+++ b/test/cases/wasm-wasi/conditions.2.zig
@@ -0,0 +1,12 @@
+pub fn main() u8 {
+    var i: u8 = 5;
+    if (i < @as(u8, 4)) {
+        i += 10;
+    } else if (i == @as(u8, 5)) {
+        i = 20;
+    }
+    return i - 20;
+}
+
+// run
+//
diff --git a/test/cases/wasm-wasi/conditions.3.zig b/test/cases/wasm-wasi/conditions.3.zig
new file mode 100644
index 0000000000000000000000000000000000000000..bd016a47f3c78ec39512ad91d0cd373f35a8bed2
--- /dev/null
+++ b/test/cases/wasm-wasi/conditions.3.zig
@@ -0,0 +1,16 @@
+pub fn main() u8 {
+    var i: u8 = 11;
+    if (i < @as(u8, 4)) {
+        i += 10;
+    } else {
+        if (i > @as(u8, 10)) {
+            i += 20;
+        } else {
+            i = 20;
+        }
+    }
+    return i - 31;
+}
+
+// run
+//
diff --git a/test/cases/wasm-wasi/conditions.4.zig b/test/cases/wasm-wasi/conditions.4.zig
new file mode 100644
index 0000000000000000000000000000000000000000..e1bd9ce0f7b6b397c997f416143b0eac10ac7551
--- /dev/null
+++ b/test/cases/wasm-wasi/conditions.4.zig
@@ -0,0 +1,15 @@
+pub fn main() void {
+    assert(foo(true) != @as(i32, 30));
+}
+
+fn assert(ok: bool) void {
+    if (!ok) unreachable;
+}
+
+fn foo(ok: bool) i32 {
+    const x = if (ok) @as(i32, 20) else @as(i32, 10);
+    return x;
+}
+
+// run
+//
diff --git a/test/cases/wasm-wasi/conditions.5.zig b/test/cases/wasm-wasi/conditions.5.zig
new file mode 100644
index 0000000000000000000000000000000000000000..2d5ba338c7aea87a6f059d6f119bd1e0f7641793
--- /dev/null
+++ b/test/cases/wasm-wasi/conditions.5.zig
@@ -0,0 +1,20 @@
+pub fn main() void {
+    assert(foo(false) == @as(i32, 20));
+    assert(foo(true) == @as(i32, 30));
+}
+
+fn assert(ok: bool) void {
+    if (!ok) unreachable;
+}
+
+fn foo(ok: bool) i32 {
+    const val: i32 = blk: {
+        var x: i32 = 1;
+        if (!ok) break :blk x + @as(i32, 9);
+        break :blk x + @as(i32, 19);
+    };
+    return val + 10;
+}
+
+// run
+//
diff --git a/test/cases/wasm-wasi/error_unions.0.zig b/test/cases/wasm-wasi/error_unions.0.zig
new file mode 100644
index 0000000000000000000000000000000000000000..355698e4b66b7e43c16c1c0b4c92b9161f1c9a11
--- /dev/null
+++ b/test/cases/wasm-wasi/error_unions.0.zig
@@ -0,0 +1,15 @@
+pub fn main() void {
+    var e1 = error.Foo;
+    var e2 = error.Bar;
+    assert(e1 != e2);
+    assert(e1 == error.Foo);
+    assert(e2 == error.Bar);
+}
+
+fn assert(b: bool) void {
+    if (!b) unreachable;
+}
+
+// run
+// target=wasm32-wasi
+//
diff --git a/test/cases/wasm-wasi/error_unions.1.zig b/test/cases/wasm-wasi/error_unions.1.zig
new file mode 100644
index 0000000000000000000000000000000000000000..526e1a110d4c74415d9c3036ae99b828efd133c7
--- /dev/null
+++ b/test/cases/wasm-wasi/error_unions.1.zig
@@ -0,0 +1,8 @@
+pub fn main() u8 {
+    var e: anyerror!u8 = 5;
+    const i = e catch 10;
+    return i - 5;
+}
+
+// run
+//
diff --git a/test/cases/wasm-wasi/error_unions.2.zig b/test/cases/wasm-wasi/error_unions.2.zig
new file mode 100644
index 0000000000000000000000000000000000000000..b66c7d78c073bb0ef4cd4365fed5873fb66901af
--- /dev/null
+++ b/test/cases/wasm-wasi/error_unions.2.zig
@@ -0,0 +1,8 @@
+pub fn main() u8 {
+    var e: anyerror!u8 = error.Foo;
+    const i = e catch 10;
+    return i - 10;
+}
+
+// run
+//
diff --git a/test/cases/wasm-wasi/error_unions.3.zig b/test/cases/wasm-wasi/error_unions.3.zig
new file mode 100644
index 0000000000000000000000000000000000000000..d37f826272dc32f990891837ed1a1a202a81fbd4
--- /dev/null
+++ b/test/cases/wasm-wasi/error_unions.3.zig
@@ -0,0 +1,12 @@
+pub fn main() u8 {
+    var e = foo();
+    const i = e catch 69;
+    return i - 5;
+}
+
+fn foo() anyerror!u8 {
+    return 5;
+}
+
+// run
+//
diff --git a/test/cases/wasm-wasi/error_unions.4.zig b/test/cases/wasm-wasi/error_unions.4.zig
new file mode 100644
index 0000000000000000000000000000000000000000..bbc8dd34da3b637871424a45678b5f5c5f67620c
--- /dev/null
+++ b/test/cases/wasm-wasi/error_unions.4.zig
@@ -0,0 +1,12 @@
+pub fn main() u8 {
+    var e = foo();
+    const i = e catch 69;
+    return i - 69;
+}
+
+fn foo() anyerror!u8 {
+    return error.Bruh;
+}
+
+// run
+//
diff --git a/test/cases/wasm-wasi/error_unions.5.zig b/test/cases/wasm-wasi/error_unions.5.zig
new file mode 100644
index 0000000000000000000000000000000000000000..96d52d1de1f3a3eb31741f0bfdd8f8791f92e232
--- /dev/null
+++ b/test/cases/wasm-wasi/error_unions.5.zig
@@ -0,0 +1,12 @@
+pub fn main() u8 {
+    var e = foo();
+    const i = e catch 42;
+    return i - 42;
+}
+
+fn foo() anyerror!u8 {
+    return error.Dab;
+}
+
+// run
+//
diff --git a/test/cases/wasm-wasi/locals.0.zig b/test/cases/wasm-wasi/locals.0.zig
new file mode 100644
index 0000000000000000000000000000000000000000..f2df242792c6249864477ac4a69614f5032d6ceb
--- /dev/null
+++ b/test/cases/wasm-wasi/locals.0.zig
@@ -0,0 +1,14 @@
+pub fn main() void {
+    var i: u8 = 5;
+    var y: f32 = 42.0;
+    var x: u8 = 10;
+    if (false) {
+        y;
+        x;
+    }
+    if (i != 5) unreachable;
+}
+
+// run
+// target=wasm32-wasi
+//
diff --git a/test/cases/wasm-wasi/locals.1.zig b/test/cases/wasm-wasi/locals.1.zig
new file mode 100644
index 0000000000000000000000000000000000000000..f7e59e1c02e8a328b3bc84e7d0f1820c92b22d22
--- /dev/null
+++ b/test/cases/wasm-wasi/locals.1.zig
@@ -0,0 +1,17 @@
+pub fn main() void {
+    var i: u8 = 5;
+    var y: f32 = 42.0;
+    _ = y;
+    var x: u8 = 10;
+    foo(i, x);
+    i = x;
+    if (i != 10) unreachable;
+}
+fn foo(x: u8, y: u8) void {
+    _ = y;
+    var i: u8 = 10;
+    i = x;
+}
+
+// run
+//
diff --git a/test/cases/wasm-wasi/optionals.0.zig b/test/cases/wasm-wasi/optionals.0.zig
new file mode 100644
index 0000000000000000000000000000000000000000..e602bf1c8047d4b39bd8bb669df837b7842c3e5d
--- /dev/null
+++ b/test/cases/wasm-wasi/optionals.0.zig
@@ -0,0 +1,12 @@
+pub fn main() u8 {
+    var x: ?u8 = 5;
+    var y: u8 = 0;
+    if (x) |val| {
+        y = val;
+    }
+    return y - 5;
+}
+
+// run
+// target=wasm32-wasi
+//
diff --git a/test/cases/wasm-wasi/optionals.1.zig b/test/cases/wasm-wasi/optionals.1.zig
new file mode 100644
index 0000000000000000000000000000000000000000..26e81b890983755980f6e5701d04faec506ff49d
--- /dev/null
+++ b/test/cases/wasm-wasi/optionals.1.zig
@@ -0,0 +1,11 @@
+pub fn main() u8 {
+    var x: ?u8 = null;
+    var y: u8 = 0;
+    if (x) |val| {
+        y = val;
+    }
+    return y;
+}
+
+// run
+//
diff --git a/test/cases/wasm-wasi/optionals.2.zig b/test/cases/wasm-wasi/optionals.2.zig
new file mode 100644
index 0000000000000000000000000000000000000000..b610c6d2e9669ccbbe921cce11695c0200e2ba25
--- /dev/null
+++ b/test/cases/wasm-wasi/optionals.2.zig
@@ -0,0 +1,7 @@
+pub fn main() u8 {
+    var x: ?u8 = 5;
+    return x.? - 5;
+}
+
+// run
+//
diff --git a/test/cases/wasm-wasi/optionals.3.zig b/test/cases/wasm-wasi/optionals.3.zig
new file mode 100644
index 0000000000000000000000000000000000000000..d513c102827858be70c41f43bda1f6698fad19ed
--- /dev/null
+++ b/test/cases/wasm-wasi/optionals.3.zig
@@ -0,0 +1,8 @@
+pub fn main() u8 {
+    var x: u8 = 5;
+    var y: ?u8 = x;
+    return y.? - 5;
+}
+
+// run
+//
diff --git a/test/cases/wasm-wasi/optionals.4.zig b/test/cases/wasm-wasi/optionals.4.zig
new file mode 100644
index 0000000000000000000000000000000000000000..af3400b322a9b9cec82f8a3798c1806e93aae4c4
--- /dev/null
+++ b/test/cases/wasm-wasi/optionals.4.zig
@@ -0,0 +1,13 @@
+pub fn main() u8 {
+    var val: ?u8 = 5;
+    while (val) |*v| {
+        v.* -= 1;
+        if (v.* == 2) {
+            val = null;
+        }
+    }
+    return 0;
+}
+
+// run
+//
diff --git a/test/cases/wasm-wasi/pointers.0.zig b/test/cases/wasm-wasi/pointers.0.zig
new file mode 100644
index 0000000000000000000000000000000000000000..958ee5ac8860225eb4b5d5bfb051a8fb9ea97699
--- /dev/null
+++ b/test/cases/wasm-wasi/pointers.0.zig
@@ -0,0 +1,14 @@
+pub fn main() u8 {
+    var x: u8 = 0;
+
+    foo(&x);
+    return x - 2;
+}
+
+fn foo(x: *u8) void {
+    x.* = 2;
+}
+
+// run
+// target=wasm32-wasi
+//
diff --git a/test/cases/wasm-wasi/pointers.1.zig b/test/cases/wasm-wasi/pointers.1.zig
new file mode 100644
index 0000000000000000000000000000000000000000..b3649cf5204313da4d2979866de590a04d4494a1
--- /dev/null
+++ b/test/cases/wasm-wasi/pointers.1.zig
@@ -0,0 +1,18 @@
+pub fn main() u8 {
+    var x: u8 = 0;
+
+    foo(&x);
+    bar(&x);
+    return x - 4;
+}
+
+fn foo(x: *u8) void {
+    x.* = 2;
+}
+
+fn bar(x: *u8) void {
+    x.* += 2;
+}
+
+// run
+//
diff --git a/test/cases/wasm-wasi/structs.0.zig b/test/cases/wasm-wasi/structs.0.zig
new file mode 100644
index 0000000000000000000000000000000000000000..03a8938d9ebcf80db462bb7f98d093b97a28003d
--- /dev/null
+++ b/test/cases/wasm-wasi/structs.0.zig
@@ -0,0 +1,10 @@
+const Example = struct { x: u8 };
+
+pub fn main() u8 {
+    var example: Example = .{ .x = 5 };
+    return example.x - 5;
+}
+
+// run
+// target=wasm32-wasi
+//
diff --git a/test/cases/wasm-wasi/structs.1.zig b/test/cases/wasm-wasi/structs.1.zig
new file mode 100644
index 0000000000000000000000000000000000000000..8d4250e4a2ac87a7271f06275f2bd951f211180c
--- /dev/null
+++ b/test/cases/wasm-wasi/structs.1.zig
@@ -0,0 +1,10 @@
+const Example = struct { x: u8 };
+
+pub fn main() u8 {
+    var example: Example = .{ .x = 5 };
+    example.x = 10;
+    return example.x - 10;
+}
+
+// run
+//
diff --git a/test/cases/wasm-wasi/structs.2.zig b/test/cases/wasm-wasi/structs.2.zig
new file mode 100644
index 0000000000000000000000000000000000000000..b1d3cbf080accc76edd40158f4f7c5946f9c7c79
--- /dev/null
+++ b/test/cases/wasm-wasi/structs.2.zig
@@ -0,0 +1,9 @@
+const Example = struct { x: u8, y: u8 };
+
+pub fn main() u8 {
+    var example: Example = .{ .x = 5, .y = 10 };
+    return example.y + example.x - 15;
+}
+
+// run
+//
diff --git a/test/cases/wasm-wasi/structs.3.zig b/test/cases/wasm-wasi/structs.3.zig
new file mode 100644
index 0000000000000000000000000000000000000000..558b5a1e2d7109fdf53d0c9b862718588178440e
--- /dev/null
+++ b/test/cases/wasm-wasi/structs.3.zig
@@ -0,0 +1,12 @@
+const Example = struct { x: u8, y: u8 };
+
+pub fn main() u8 {
+    var example: Example = .{ .x = 5, .y = 10 };
+    var example2: Example = .{ .x = 10, .y = 20 };
+
+    example = example2;
+    return example.y + example.x - 30;
+}
+
+// run
+//
diff --git a/test/cases/wasm-wasi/structs.4.zig b/test/cases/wasm-wasi/structs.4.zig
new file mode 100644
index 0000000000000000000000000000000000000000..2d37446c5692f49b68d0de55488e995b1011e075
--- /dev/null
+++ b/test/cases/wasm-wasi/structs.4.zig
@@ -0,0 +1,11 @@
+const Example = struct { x: u8, y: u8 };
+
+pub fn main() u8 {
+    var example: Example = .{ .x = 5, .y = 10 };
+
+    example = .{ .x = 10, .y = 20 };
+    return example.y + example.x - 30;
+}
+
+// run
+//
diff --git a/test/cases/wasm-wasi/switch.0.zig b/test/cases/wasm-wasi/switch.0.zig
new file mode 100644
index 0000000000000000000000000000000000000000..d0c0e43f8fb8d9a5cc41e1636c41ec24e9ffce71
--- /dev/null
+++ b/test/cases/wasm-wasi/switch.0.zig
@@ -0,0 +1,15 @@
+pub fn main() u8 {
+    var val: u8 = 1;
+    var a: u8 = switch (val) {
+        0, 1 => 2,
+        2 => 3,
+        3 => 4,
+        else => 5,
+    };
+
+    return a - 2;
+}
+
+// run
+// target=wasm32-wasi
+//
diff --git a/test/cases/wasm-wasi/switch.1.zig b/test/cases/wasm-wasi/switch.1.zig
new file mode 100644
index 0000000000000000000000000000000000000000..fe503bf212e45fb1c74940b227b33221868e146e
--- /dev/null
+++ b/test/cases/wasm-wasi/switch.1.zig
@@ -0,0 +1,14 @@
+pub fn main() u8 {
+    var val: u8 = 2;
+    var a: u8 = switch (val) {
+        0, 1 => 2,
+        2 => 3,
+        3 => 4,
+        else => 5,
+    };
+
+    return a - 3;
+}
+
+// run
+//
diff --git a/test/cases/wasm-wasi/switch.2.zig b/test/cases/wasm-wasi/switch.2.zig
new file mode 100644
index 0000000000000000000000000000000000000000..24f40d8402ca658e294b45e1d771b9f5697efb90
--- /dev/null
+++ b/test/cases/wasm-wasi/switch.2.zig
@@ -0,0 +1,14 @@
+pub fn main() u8 {
+    var val: u8 = 10;
+    var a: u8 = switch (val) {
+        0, 1 => 2,
+        2 => 3,
+        3 => 4,
+        else => 5,
+    };
+
+    return a - 5;
+}
+
+// run
+//
diff --git a/test/cases/wasm-wasi/switch.3.zig b/test/cases/wasm-wasi/switch.3.zig
new file mode 100644
index 0000000000000000000000000000000000000000..e0b55db3bff6a6809e7ce5285ccce49f40b8c82b
--- /dev/null
+++ b/test/cases/wasm-wasi/switch.3.zig
@@ -0,0 +1,15 @@
+const MyEnum = enum { One, Two, Three };
+
+pub fn main() u8 {
+    var val: MyEnum = .Two;
+    var a: u8 = switch (val) {
+        .One => 1,
+        .Two => 2,
+        .Three => 3,
+    };
+
+    return a - 2;
+}
+
+// run
+//
diff --git a/test/cases/wasm-wasi/while_loops.0.zig b/test/cases/wasm-wasi/while_loops.0.zig
new file mode 100644
index 0000000000000000000000000000000000000000..721b127ff54aeb2d65f03dd4cfdc8315445529f6
--- /dev/null
+++ b/test/cases/wasm-wasi/while_loops.0.zig
@@ -0,0 +1,12 @@
+pub fn main() u8 {
+    var i: u8 = 0;
+    while (i < @as(u8, 5)) {
+        i += 1;
+    }
+
+    return i - 5;
+}
+
+// run
+// target=wasm32-wasi
+//
diff --git a/test/cases/wasm-wasi/while_loops.1.zig b/test/cases/wasm-wasi/while_loops.1.zig
new file mode 100644
index 0000000000000000000000000000000000000000..715a813b65e66c4b1f42e4b00b397b5933b0de35
--- /dev/null
+++ b/test/cases/wasm-wasi/while_loops.1.zig
@@ -0,0 +1,11 @@
+pub fn main() u8 {
+    var i: u8 = 0;
+    while (i < @as(u8, 10)) {
+        var x: u8 = 1;
+        i += x;
+    }
+    return i - 10;
+}
+
+// run
+//
diff --git a/test/cases/wasm-wasi/while_loops.2.zig b/test/cases/wasm-wasi/while_loops.2.zig
new file mode 100644
index 0000000000000000000000000000000000000000..7ad8101c3777d2a94289fedd8406693f4b7c0861
--- /dev/null
+++ b/test/cases/wasm-wasi/while_loops.2.zig
@@ -0,0 +1,12 @@
+pub fn main() u8 {
+    var i: u8 = 0;
+    while (i < @as(u8, 10)) {
+        var x: u8 = 1;
+        i += x;
+        if (i == @as(u8, 5)) break;
+    }
+    return i - 5;
+}
+
+// run
+//
diff --git a/test/cases/x86_64-linux/assert_function.0.zig b/test/cases/x86_64-linux/assert_function.0.zig
new file mode 100644
index 0000000000000000000000000000000000000000..ab34f5328dc90498078384ce434c0e11905f0487
--- /dev/null
+++ b/test/cases/x86_64-linux/assert_function.0.zig
@@ -0,0 +1,15 @@
+pub fn main() void {
+    add(3, 4);
+}
+
+fn add(a: u32, b: u32) void {
+    assert(a + b == 7);
+}
+
+pub fn assert(ok: bool) void {
+    if (!ok) unreachable; // assertion failure
+}
+
+// run
+// target=x86_64-linux
+//
diff --git a/test/cases/x86_64-linux/assert_function.1.zig b/test/cases/x86_64-linux/assert_function.1.zig
new file mode 100644
index 0000000000000000000000000000000000000000..ac2df25d8556c661b48a9382d200283073d5d00b
--- /dev/null
+++ b/test/cases/x86_64-linux/assert_function.1.zig
@@ -0,0 +1,17 @@
+pub fn main() void {
+    add(3, 4);
+}
+
+fn add(a: u32, b: u32) void {
+    const c = a + b; // 7
+    const d = a + c; // 10
+    const e = d + b; // 14
+    assert(e == 14);
+}
+
+pub fn assert(ok: bool) void {
+    if (!ok) unreachable; // assertion failure
+}
+
+// run
+//
diff --git a/test/cases/x86_64-linux/assert_function.10.zig b/test/cases/x86_64-linux/assert_function.10.zig
new file mode 100644
index 0000000000000000000000000000000000000000..b3f1610cd62b71553f20959ef9cf4cec51d8f498
--- /dev/null
+++ b/test/cases/x86_64-linux/assert_function.10.zig
@@ -0,0 +1,27 @@
+pub fn main() void {
+    assert(add(3, 4) == 116);
+}
+
+fn add(a: u32, b: u32) u32 {
+    const x: u32 = blk: {
+        const c = a + b; // 7
+        const d = a + c; // 10
+        const e = d + b; // 14
+        const f = d + e; // 24
+        const g = e + f; // 38
+        const h = f + g; // 62
+        const i = g + h; // 100
+        const j = i + d; // 110
+        break :blk j;
+    };
+    const y = x + a; // 113
+    const z = y + a; // 116
+    return z;
+}
+
+pub fn assert(ok: bool) void {
+    if (!ok) unreachable; // assertion failure
+}
+
+// run
+//
diff --git a/test/cases/x86_64-linux/assert_function.11.zig b/test/cases/x86_64-linux/assert_function.11.zig
new file mode 100644
index 0000000000000000000000000000000000000000..d64130a6775b250ca18a5900e912391dc732a7f7
--- /dev/null
+++ b/test/cases/x86_64-linux/assert_function.11.zig
@@ -0,0 +1,66 @@
+pub fn main() void {
+    assert(add(3, 4) == 1221);
+    assert(mul(3, 4) == 21609);
+}
+
+fn add(a: u32, b: u32) u32 {
+    const x: u32 = blk: {
+        const c = a + b; // 7
+        const d = a + c; // 10
+        const e = d + b; // 14
+        const f = d + e; // 24
+        const g = e + f; // 38
+        const h = f + g; // 62
+        const i = g + h; // 100
+        const j = i + d; // 110
+        const k = i + j; // 210
+        const l = j + k; // 320
+        const m = l + c; // 327
+        const n = m + d; // 337
+        const o = n + e; // 351
+        const p = o + f; // 375
+        const q = p + g; // 413
+        const r = q + h; // 475
+        const s = r + i; // 575
+        const t = s + j; // 685
+        const u = t + k; // 895
+        const v = u + l; // 1215
+        break :blk v;
+    };
+    const y = x + a; // 1218
+    const z = y + a; // 1221
+    return z;
+}
+
+fn mul(a: u32, b: u32) u32 {
+    const x: u32 = blk: {
+        const c = a * a * a * a; // 81
+        const d = a * a * a * b; // 108
+        const e = a * a * b * a; // 108
+        const f = a * a * b * b; // 144
+        const g = a * b * a * a; // 108
+        const h = a * b * a * b; // 144
+        const i = a * b * b * a; // 144
+        const j = a * b * b * b; // 192
+        const k = b * a * a * a; // 108
+        const l = b * a * a * b; // 144
+        const m = b * a * b * a; // 144
+        const n = b * a * b * b; // 192
+        const o = b * b * a * a; // 144
+        const p = b * b * a * b; // 192
+        const q = b * b * b * a; // 192
+        const r = b * b * b * b; // 256
+        const s = c + d + e + f + g + h + i + j + k + l + m + n + o + p + q + r; // 2401
+        break :blk s;
+    };
+    const y = x * a; // 7203
+    const z = y * a; // 21609
+    return z;
+}
+
+pub fn assert(ok: bool) void {
+    if (!ok) unreachable; // assertion failure
+}
+
+// run
+//
diff --git a/test/cases/x86_64-linux/assert_function.12.zig b/test/cases/x86_64-linux/assert_function.12.zig
new file mode 100644
index 0000000000000000000000000000000000000000..4f64c1e0626879a2004d66080292dc7cf962065d
--- /dev/null
+++ b/test/cases/x86_64-linux/assert_function.12.zig
@@ -0,0 +1,47 @@
+pub fn main() void {
+    assert(add(3, 4) == 791);
+    assert(add(4, 3) == 79);
+}
+
+fn add(a: u32, b: u32) u32 {
+    const x: u32 = if (a < b) blk: {
+        const c = a + b; // 7
+        const d = a + c; // 10
+        const e = d + b; // 14
+        const f = d + e; // 24
+        const g = e + f; // 38
+        const h = f + g; // 62
+        const i = g + h; // 100
+        const j = i + d; // 110
+        const k = i + j; // 210
+        const l = k + c; // 217
+        const m = l + d; // 227
+        const n = m + e; // 241
+        const o = n + f; // 265
+        const p = o + g; // 303
+        const q = p + h; // 365
+        const r = q + i; // 465
+        const s = r + j; // 575
+        const t = s + k; // 785
+        break :blk t;
+    } else blk: {
+        const t = b + b + a; // 10
+        const c = a + t; // 14
+        const d = c + t; // 24
+        const e = d + t; // 34
+        const f = e + t; // 44
+        const g = f + t; // 54
+        const h = c + g; // 68
+        break :blk h + b; // 71
+    };
+    const y = x + a; // 788, 75
+    const z = y + a; // 791, 79
+    return z;
+}
+
+pub fn assert(ok: bool) void {
+    if (!ok) unreachable; // assertion failure
+}
+
+// run
+//
diff --git a/test/cases/x86_64-linux/assert_function.13.zig b/test/cases/x86_64-linux/assert_function.13.zig
new file mode 100644
index 0000000000000000000000000000000000000000..240abf0108dbe8c08040533524872e543fd6d621
--- /dev/null
+++ b/test/cases/x86_64-linux/assert_function.13.zig
@@ -0,0 +1,19 @@
+pub fn main() void {
+    const ignore =
+        \\ cool thx
+        \\
+    ;
+    _ = ignore;
+    add('ぁ', '\x03');
+}
+
+fn add(a: u32, b: u32) void {
+    assert(a + b == 12356);
+}
+
+pub fn assert(ok: bool) void {
+    if (!ok) unreachable; // assertion failure
+}
+
+// run
+//
diff --git a/test/cases/x86_64-linux/assert_function.14.zig b/test/cases/x86_64-linux/assert_function.14.zig
new file mode 100644
index 0000000000000000000000000000000000000000..d25100dccee2bda1f615c2d870ee477c1252bed3
--- /dev/null
+++ b/test/cases/x86_64-linux/assert_function.14.zig
@@ -0,0 +1,17 @@
+pub fn main() void {
+    add(aa, bb);
+}
+
+const aa = 'ぁ';
+const bb = '\x03';
+
+fn add(a: u32, b: u32) void {
+    assert(a + b == 12356);
+}
+
+pub fn assert(ok: bool) void {
+    if (!ok) unreachable; // assertion failure
+}
+
+// run
+//
diff --git a/test/cases/x86_64-linux/assert_function.15.zig b/test/cases/x86_64-linux/assert_function.15.zig
new file mode 100644
index 0000000000000000000000000000000000000000..33ae1ed5af1279b74f089003e7b9665b55c2489b
--- /dev/null
+++ b/test/cases/x86_64-linux/assert_function.15.zig
@@ -0,0 +1,10 @@
+pub fn main() void {
+    assert("hello"[0] == 'h');
+}
+
+pub fn assert(ok: bool) void {
+    if (!ok) unreachable; // assertion failure
+}
+
+// run
+//
diff --git a/test/cases/x86_64-linux/assert_function.16.zig b/test/cases/x86_64-linux/assert_function.16.zig
new file mode 100644
index 0000000000000000000000000000000000000000..eef113642324434c4af1723aac512a57192ce726
--- /dev/null
+++ b/test/cases/x86_64-linux/assert_function.16.zig
@@ -0,0 +1,11 @@
+const hello = "hello".*;
+pub fn main() void {
+    assert(hello[1] == 'e');
+}
+
+pub fn assert(ok: bool) void {
+    if (!ok) unreachable; // assertion failure
+}
+
+// run
+//
diff --git a/test/cases/x86_64-linux/assert_function.17.zig b/test/cases/x86_64-linux/assert_function.17.zig
new file mode 100644
index 0000000000000000000000000000000000000000..ac9dce3079f6444476afd65757675726390946cf
--- /dev/null
+++ b/test/cases/x86_64-linux/assert_function.17.zig
@@ -0,0 +1,11 @@
+pub fn main() void {
+    var i: u64 = 0xFFEEDDCCBBAA9988;
+    assert(i == 0xFFEEDDCCBBAA9988);
+}
+
+pub fn assert(ok: bool) void {
+    if (!ok) unreachable; // assertion failure
+}
+
+// run
+//
diff --git a/test/cases/x86_64-linux/assert_function.18.zig b/test/cases/x86_64-linux/assert_function.18.zig
new file mode 100644
index 0000000000000000000000000000000000000000..31cf1207f3dc07541a4210641ee136eb0ba385b0
--- /dev/null
+++ b/test/cases/x86_64-linux/assert_function.18.zig
@@ -0,0 +1,35 @@
+const builtin = @import("builtin");
+
+extern "c" fn write(usize, usize, usize) usize;
+
+pub fn main() void {
+    for ("hello") |_| print();
+}
+
+fn print() void {
+    switch (builtin.os.tag) {
+        .linux => {
+            asm volatile ("syscall"
+                :
+                : [number] "{rax}" (1),
+                  [arg1] "{rdi}" (1),
+                  [arg2] "{rsi}" (@ptrToInt("hello\n")),
+                  [arg3] "{rdx}" (6),
+                : "rcx", "r11", "memory"
+            );
+        },
+        .macos => {
+            _ = write(1, @ptrToInt("hello\n"), 6);
+        },
+        else => unreachable,
+    }
+}
+
+// run
+//
+// hello
+// hello
+// hello
+// hello
+// hello
+//
diff --git a/test/cases/x86_64-linux/assert_function.2.zig b/test/cases/x86_64-linux/assert_function.2.zig
new file mode 100644
index 0000000000000000000000000000000000000000..8c1c510486185f4116841577473c901e13528283
--- /dev/null
+++ b/test/cases/x86_64-linux/assert_function.2.zig
@@ -0,0 +1,21 @@
+pub fn main() void {
+    add(3, 4);
+}
+
+fn add(a: u32, b: u32) void {
+    const c = a + b; // 7
+    const d = a + c; // 10
+    const e = d + b; // 14
+    const f = d + e; // 24
+    const g = e + f; // 38
+    const h = f + g; // 62
+    const i = g + h; // 100
+    assert(i == 100);
+}
+
+pub fn assert(ok: bool) void {
+    if (!ok) unreachable; // assertion failure
+}
+
+// run
+//
diff --git a/test/cases/x86_64-linux/assert_function.3.zig b/test/cases/x86_64-linux/assert_function.3.zig
new file mode 100644
index 0000000000000000000000000000000000000000..a6829f8e0239f8c01f0a1e4e1cf42e9ed035176b
--- /dev/null
+++ b/test/cases/x86_64-linux/assert_function.3.zig
@@ -0,0 +1,22 @@
+pub fn main() void {
+    add(3, 4);
+}
+
+fn add(a: u32, b: u32) void {
+    const c = a + b; // 7
+    const d = a + c; // 10
+    const e = d + b; // 14
+    const f = d + e; // 24
+    const g = e + f; // 38
+    const h = f + g; // 62
+    const i = g + h; // 100
+    const j = i + d; // 110
+    assert(j == 110);
+}
+
+pub fn assert(ok: bool) void {
+    if (!ok) unreachable; // assertion failure
+}
+
+// run
+//
diff --git a/test/cases/x86_64-linux/assert_function.4.zig b/test/cases/x86_64-linux/assert_function.4.zig
new file mode 100644
index 0000000000000000000000000000000000000000..69df4354c3eb8d72d4c91b226fbf4b4c0eddedaf
--- /dev/null
+++ b/test/cases/x86_64-linux/assert_function.4.zig
@@ -0,0 +1,15 @@
+pub fn main() void {
+    assert(add(3, 4) == 7);
+    assert(add(20, 10) == 30);
+}
+
+fn add(a: u32, b: u32) u32 {
+    return a + b;
+}
+
+pub fn assert(ok: bool) void {
+    if (!ok) unreachable; // assertion failure
+}
+
+// run
+//
diff --git a/test/cases/x86_64-linux/assert_function.5.zig b/test/cases/x86_64-linux/assert_function.5.zig
new file mode 100644
index 0000000000000000000000000000000000000000..89f3f7df4fd3f42da6650c27dff3c8160b281860
--- /dev/null
+++ b/test/cases/x86_64-linux/assert_function.5.zig
@@ -0,0 +1,19 @@
+pub fn main() void {
+    assert(add(3, 4) == 7);
+    assert(add(20, 10) == 30);
+}
+
+fn add(a: u32, b: u32) u32 {
+    var x: u32 = undefined;
+    x = 0;
+    x += a;
+    x += b;
+    return x;
+}
+
+pub fn assert(ok: bool) void {
+    if (!ok) unreachable; // assertion failure
+}
+
+// run
+//
diff --git a/test/cases/x86_64-linux/assert_function.6.zig b/test/cases/x86_64-linux/assert_function.6.zig
new file mode 100644
index 0000000000000000000000000000000000000000..1b1b75e68ea72902208bd0889c38202922b89a51
--- /dev/null
+++ b/test/cases/x86_64-linux/assert_function.6.zig
@@ -0,0 +1,9 @@
+pub fn main() void {
+    const a: u32 = 2;
+    const b: ?u32 = a;
+    const c = b.?;
+    if (c != 2) unreachable;
+}
+
+// run
+//
diff --git a/test/cases/x86_64-linux/assert_function.7.zig b/test/cases/x86_64-linux/assert_function.7.zig
new file mode 100644
index 0000000000000000000000000000000000000000..e6d18a5c3f7e1f2f71ffce96c309b8f862541fb0
--- /dev/null
+++ b/test/cases/x86_64-linux/assert_function.7.zig
@@ -0,0 +1,28 @@
+pub fn main() void {
+    var i: u32 = 0;
+    while (i < 4) : (i += 1) print();
+    assert(i == 4);
+}
+
+fn print() void {
+    asm volatile ("syscall"
+        :
+        : [number] "{rax}" (1),
+          [arg1] "{rdi}" (1),
+          [arg2] "{rsi}" (@ptrToInt("hello\n")),
+          [arg3] "{rdx}" (6),
+        : "rcx", "r11", "memory"
+    );
+}
+
+pub fn assert(ok: bool) void {
+    if (!ok) unreachable; // assertion failure
+}
+
+// run
+//
+// hello
+// hello
+// hello
+// hello
+//
diff --git a/test/cases/x86_64-linux/assert_function.8.zig b/test/cases/x86_64-linux/assert_function.8.zig
new file mode 100644
index 0000000000000000000000000000000000000000..ae618cc063eb8921371563dfa6b185f2e0c3ade7
--- /dev/null
+++ b/test/cases/x86_64-linux/assert_function.8.zig
@@ -0,0 +1,24 @@
+pub fn main() void {
+    var i: u32 = 0;
+    inline while (i < 4) : (i += 1) print();
+    assert(i == 4);
+}
+
+fn print() void {
+    asm volatile ("syscall"
+        :
+        : [number] "{rax}" (1),
+          [arg1] "{rdi}" (1),
+          [arg2] "{rsi}" (@ptrToInt("hello\n")),
+          [arg3] "{rdx}" (6),
+        : "rcx", "r11", "memory"
+    );
+}
+
+pub fn assert(ok: bool) void {
+    if (!ok) unreachable; // assertion failure
+}
+
+// error
+//
+// :3:21: error: unable to resolve comptime value
diff --git a/test/cases/x86_64-linux/assert_function.9.zig b/test/cases/x86_64-linux/assert_function.9.zig
new file mode 100644
index 0000000000000000000000000000000000000000..c754bb771133d8b3a595ec9fe46c48c4c6408e61
--- /dev/null
+++ b/test/cases/x86_64-linux/assert_function.9.zig
@@ -0,0 +1,22 @@
+pub fn main() void {
+    assert(add(3, 4) == 20);
+}
+
+fn add(a: u32, b: u32) u32 {
+    const x: u32 = blk: {
+        const c = a + b; // 7
+        const d = a + c; // 10
+        const e = d + b; // 14
+        break :blk e;
+    };
+    const y = x + a; // 17
+    const z = y + a; // 20
+    return z;
+}
+
+pub fn assert(ok: bool) void {
+    if (!ok) unreachable; // assertion failure
+}
+
+// run
+//
diff --git a/test/cases/x86_64-linux/comptime_var.0.zig b/test/cases/x86_64-linux/comptime_var.0.zig
new file mode 100644
index 0000000000000000000000000000000000000000..45f87ecaa13835c447536cbc60dfb84572025a80
--- /dev/null
+++ b/test/cases/x86_64-linux/comptime_var.0.zig
@@ -0,0 +1,12 @@
+pub fn main() void {
+    var a: u32 = 0;
+    comptime var b: u32 = 0;
+    if (a == 0) b = 3;
+}
+
+// error
+// output_mode=Exe
+// target=x86_64-linux
+//
+// :4:21: error: store to comptime variable depends on runtime condition
+// :4:11: note: runtime condition here
diff --git a/test/cases/x86_64-linux/comptime_var.1.zig b/test/cases/x86_64-linux/comptime_var.1.zig
new file mode 100644
index 0000000000000000000000000000000000000000..efc51aafe3e7572bb8815d5e75ec4e4b00761499
--- /dev/null
+++ b/test/cases/x86_64-linux/comptime_var.1.zig
@@ -0,0 +1,13 @@
+pub fn main() void {
+    var a: u32 = 0;
+    comptime var b: u32 = 0;
+    switch (a) {
+        0 => {},
+        else => b = 3,
+    }
+}
+
+// error
+//
+// :6:21: error: store to comptime variable depends on runtime condition
+// :4:13: note: runtime condition here
diff --git a/test/cases/x86_64-linux/comptime_var.2.zig b/test/cases/x86_64-linux/comptime_var.2.zig
new file mode 100644
index 0000000000000000000000000000000000000000..72bdfad90c34a452e3be002cc82ad7315e9fe7d3
--- /dev/null
+++ b/test/cases/x86_64-linux/comptime_var.2.zig
@@ -0,0 +1,22 @@
+pub fn main() void {
+    comptime var len: u32 = 5;
+    print(len);
+    len += 9;
+    print(len);
+}
+
+fn print(len: usize) void {
+    asm volatile ("syscall"
+        :
+        : [number] "{rax}" (1),
+          [arg1] "{rdi}" (1),
+          [arg2] "{rsi}" (@ptrToInt("Hello, World!\n")),
+          [arg3] "{rdx}" (len),
+        : "rcx", "r11", "memory"
+    );
+}
+
+// run
+//
+// HelloHello, World!
+//
diff --git a/test/cases/x86_64-linux/comptime_var.3.zig b/test/cases/x86_64-linux/comptime_var.3.zig
new file mode 100644
index 0000000000000000000000000000000000000000..5d25d6556e4f378d4288acda9ceffcb19397230f
--- /dev/null
+++ b/test/cases/x86_64-linux/comptime_var.3.zig
@@ -0,0 +1,10 @@
+comptime {
+    var x: i32 = 1;
+    x += 1;
+    if (x != 1) unreachable;
+}
+pub fn main() void {}
+
+// error
+//
+// :4:17: error: reached unreachable code
diff --git a/test/cases/x86_64-linux/comptime_var.4.zig b/test/cases/x86_64-linux/comptime_var.4.zig
new file mode 100644
index 0000000000000000000000000000000000000000..74da6ef448edd5534b49b1f850673863b4188b99
--- /dev/null
+++ b/test/cases/x86_64-linux/comptime_var.4.zig
@@ -0,0 +1,9 @@
+pub fn main() void {
+    comptime var i: u64 = 0;
+    while (i < 5) : (i += 1) {}
+}
+
+// error
+//
+// :3:24: error: cannot store to comptime variable in non-inline loop
+// :3:5: note: non-inline loop here
diff --git a/test/cases/x86_64-linux/comptime_var.5.zig b/test/cases/x86_64-linux/comptime_var.5.zig
new file mode 100644
index 0000000000000000000000000000000000000000..76a06f3d4b5931e8fd23271dcc593e07ff414a7f
--- /dev/null
+++ b/test/cases/x86_64-linux/comptime_var.5.zig
@@ -0,0 +1,15 @@
+pub fn main() void {
+    var a: u32 = 0;
+    if (a == 0) {
+        comptime var b: u32 = 0;
+        b = 1;
+    }
+}
+comptime {
+    var x: i32 = 1;
+    x += 1;
+    if (x != 2) unreachable;
+}
+
+// run
+//
diff --git a/test/cases/x86_64-linux/comptime_var.6.zig b/test/cases/x86_64-linux/comptime_var.6.zig
new file mode 100644
index 0000000000000000000000000000000000000000..2790949561cb9d11c777288410d34feebc35a1f0
--- /dev/null
+++ b/test/cases/x86_64-linux/comptime_var.6.zig
@@ -0,0 +1,20 @@
+pub fn main() void {
+    comptime var i: u64 = 2;
+    inline while (i < 6) : (i += 1) {
+        print(i);
+    }
+}
+fn print(len: usize) void {
+    asm volatile ("syscall"
+        :
+        : [number] "{rax}" (1),
+          [arg1] "{rdi}" (1),
+          [arg2] "{rsi}" (@ptrToInt("Hello")),
+          [arg3] "{rdx}" (len),
+        : "rcx", "r11", "memory"
+    );
+}
+
+// run
+//
+// HeHelHellHello
diff --git a/test/cases/x86_64-linux/hello_world_with_updates.0.zig b/test/cases/x86_64-linux/hello_world_with_updates.0.zig
new file mode 100644
index 0000000000000000000000000000000000000000..47b5e9db7abbcfbe9c42c409e943dffeeb988272
--- /dev/null
+++ b/test/cases/x86_64-linux/hello_world_with_updates.0.zig
@@ -0,0 +1,5 @@
+// error
+// output_mode=Exe
+// target=x86_64-linux
+//
+// :107:9: error: struct 'tmp.tmp' has no member named 'main'
diff --git a/test/cases/x86_64-linux/hello_world_with_updates.1.zig b/test/cases/x86_64-linux/hello_world_with_updates.1.zig
new file mode 100644
index 0000000000000000000000000000000000000000..0f347b7f5069ccefb13bd680334cbba2a4beb4e7
--- /dev/null
+++ b/test/cases/x86_64-linux/hello_world_with_updates.1.zig
@@ -0,0 +1,5 @@
+pub export fn _start() noreturn {}
+
+// error
+//
+// :1:34: error: expected noreturn, found void
diff --git a/test/cases/x86_64-linux/hello_world_with_updates.2.zig b/test/cases/x86_64-linux/hello_world_with_updates.2.zig
new file mode 100644
index 0000000000000000000000000000000000000000..fcea1870ce59ef67264c3be650beafabbd5a97e3
--- /dev/null
+++ b/test/cases/x86_64-linux/hello_world_with_updates.2.zig
@@ -0,0 +1,32 @@
+pub export fn _start() noreturn {
+    print();
+
+    exit();
+}
+
+fn print() void {
+    asm volatile ("syscall"
+        :
+        : [number] "{rax}" (1),
+          [arg1] "{rdi}" (1),
+          [arg2] "{rsi}" (@ptrToInt("Hello, World!\n")),
+          [arg3] "{rdx}" (14),
+        : "rcx", "r11", "memory"
+    );
+    return;
+}
+
+fn exit() noreturn {
+    asm volatile ("syscall"
+        :
+        : [number] "{rax}" (231),
+          [arg1] "{rdi}" (0),
+        : "rcx", "r11", "memory"
+    );
+    unreachable;
+}
+
+// run
+//
+// Hello, World!
+//
diff --git a/test/cases/x86_64-linux/hello_world_with_updates.3.zig b/test/cases/x86_64-linux/hello_world_with_updates.3.zig
new file mode 100644
index 0000000000000000000000000000000000000000..7812023372e14acc9c4c93441e913126d1e7de1d
--- /dev/null
+++ b/test/cases/x86_64-linux/hello_world_with_updates.3.zig
@@ -0,0 +1,20 @@
+pub fn main() void {
+    print();
+}
+
+fn print() void {
+    asm volatile ("syscall"
+        :
+        : [number] "{rax}" (1),
+          [arg1] "{rdi}" (1),
+          [arg2] "{rsi}" (@ptrToInt("Hello, World!\n")),
+          [arg3] "{rdx}" (14),
+        : "rcx", "r11", "memory"
+    );
+    return;
+}
+
+// run
+//
+// Hello, World!
+//
diff --git a/test/cases/x86_64-linux/hello_world_with_updates.4.zig b/test/cases/x86_64-linux/hello_world_with_updates.4.zig
new file mode 100644
index 0000000000000000000000000000000000000000..cdf47012b8306d2a234871842bfe00da550522de
--- /dev/null
+++ b/test/cases/x86_64-linux/hello_world_with_updates.4.zig
@@ -0,0 +1,20 @@
+pub fn main() void {
+    print();
+}
+
+fn print() void {
+    asm volatile ("syscall"
+        :
+        : [number] "{rax}" (1),
+          [arg1] "{rdi}" (1),
+          [arg2] "{rsi}" (@ptrToInt("What is up? This is a longer message that will force the data to be relocated in virtual address space.\n")),
+          [arg3] "{rdx}" (104),
+        : "rcx", "r11", "memory"
+    );
+    return;
+}
+
+// run
+//
+// What is up? This is a longer message that will force the data to be relocated in virtual address space.
+//
diff --git a/test/cases/x86_64-linux/hello_world_with_updates.5.zig b/test/cases/x86_64-linux/hello_world_with_updates.5.zig
new file mode 100644
index 0000000000000000000000000000000000000000..68c1e305f713135321cd2000bdd9b50dc2020c8e
--- /dev/null
+++ b/test/cases/x86_64-linux/hello_world_with_updates.5.zig
@@ -0,0 +1,22 @@
+pub fn main() void {
+    print();
+    print();
+}
+
+fn print() void {
+    asm volatile ("syscall"
+        :
+        : [number] "{rax}" (1),
+          [arg1] "{rdi}" (1),
+          [arg2] "{rsi}" (@ptrToInt("What is up? This is a longer message that will force the data to be relocated in virtual address space.\n")),
+          [arg3] "{rdx}" (104),
+        : "rcx", "r11", "memory"
+    );
+    return;
+}
+
+// run
+//
+// What is up? This is a longer message that will force the data to be relocated in virtual address space.
+// What is up? This is a longer message that will force the data to be relocated in virtual address space.
+//
diff --git a/test/cases/x86_64-linux/inline_assembly.0.zig b/test/cases/x86_64-linux/inline_assembly.0.zig
new file mode 100644
index 0000000000000000000000000000000000000000..e3c0f3badbb61fa8a53a63bcabb7b90edbe4657b
--- /dev/null
+++ b/test/cases/x86_64-linux/inline_assembly.0.zig
@@ -0,0 +1,16 @@
+pub fn main() void {
+    const number = 1234;
+    const x = asm volatile ("syscall"
+        : [o] "{rax}" (-> number),
+        : [number] "{rax}" (231),
+          [arg1] "{rdi}" (60),
+        : "rcx", "r11", "memory"
+    );
+    _ = x;
+}
+
+// error
+// output_mode=Exe
+// target=x86_64-linux
+//
+// :4:27: error: expected type, found comptime_int
diff --git a/test/cases/x86_64-linux/inline_assembly.1.zig b/test/cases/x86_64-linux/inline_assembly.1.zig
new file mode 100644
index 0000000000000000000000000000000000000000..b35014b0f6b6afa26cd92e7496edbc70c2b90dbf
--- /dev/null
+++ b/test/cases/x86_64-linux/inline_assembly.1.zig
@@ -0,0 +1,15 @@
+const S = struct {
+    comptime {
+        asm volatile (
+            \\zig_moment:
+            \\syscall
+        );
+    }
+};
+pub fn main() void {
+    _ = S;
+}
+
+// error
+//
+// :3:13: error: volatile is meaningless on global assembly
diff --git a/test/cases/x86_64-linux/inline_assembly.2.zig b/test/cases/x86_64-linux/inline_assembly.2.zig
new file mode 100644
index 0000000000000000000000000000000000000000..1695265ab4ebcbb6a2625bb9abdffb0d751eec07
--- /dev/null
+++ b/test/cases/x86_64-linux/inline_assembly.2.zig
@@ -0,0 +1,12 @@
+pub fn main() void {
+    var bruh: u32 = 1;
+    asm (""
+        :
+        : [bruh] "{rax}" (4)
+        : "memory"
+    );
+}
+
+// error
+//
+// :3:5: error: assembly expression with no output must be marked volatile
diff --git a/test/cases/x86_64-linux/inline_assembly.3.zig b/test/cases/x86_64-linux/inline_assembly.3.zig
new file mode 100644
index 0000000000000000000000000000000000000000..765eaeb97eb2f8373afff7399051a2fca6269070
--- /dev/null
+++ b/test/cases/x86_64-linux/inline_assembly.3.zig
@@ -0,0 +1,12 @@
+pub fn main() void {}
+comptime {
+    asm (""
+        :
+        : [bruh] "{rax}" (4)
+        : "memory"
+    );
+}
+
+// error
+//
+// :3:5: error: global assembly cannot have inputs, outputs, or clobbers
diff --git a/test/cases/x86_64-linux/only_1_function_and_it_gets_updated.0.zig b/test/cases/x86_64-linux/only_1_function_and_it_gets_updated.0.zig
new file mode 100644
index 0000000000000000000000000000000000000000..ecba1c8133714f48d0423b98c9a213a057550ad1
--- /dev/null
+++ b/test/cases/x86_64-linux/only_1_function_and_it_gets_updated.0.zig
@@ -0,0 +1,13 @@
+pub export fn _start() noreturn {
+    asm volatile ("syscall"
+        :
+        : [number] "{rax}" (60), // exit
+          [arg1] "{rdi}" (0),
+        : "rcx", "r11", "memory"
+    );
+    unreachable;
+}
+
+// run
+// target=x86_64-linux
+//
diff --git a/test/cases/x86_64-linux/only_1_function_and_it_gets_updated.1.zig b/test/cases/x86_64-linux/only_1_function_and_it_gets_updated.1.zig
new file mode 100644
index 0000000000000000000000000000000000000000..529acbcf38132bb09f0a47adc2a128ac7c7b7ac5
--- /dev/null
+++ b/test/cases/x86_64-linux/only_1_function_and_it_gets_updated.1.zig
@@ -0,0 +1,12 @@
+pub export fn _start() noreturn {
+    asm volatile ("syscall"
+        :
+        : [number] "{rax}" (231), // exit_group
+          [arg1] "{rdi}" (0),
+        : "rcx", "r11", "memory"
+    );
+    unreachable;
+}
+
+// run
+//
diff --git a/test/cases/x86_64-macos/assert_function.0.zig b/test/cases/x86_64-macos/assert_function.0.zig
new file mode 100644
index 0000000000000000000000000000000000000000..20e5cf0b97a96116457be9805f66190f5d7f8b4c
--- /dev/null
+++ b/test/cases/x86_64-macos/assert_function.0.zig
@@ -0,0 +1,15 @@
+pub fn main() void {
+    add(3, 4);
+}
+
+fn add(a: u32, b: u32) void {
+    assert(a + b == 7);
+}
+
+pub fn assert(ok: bool) void {
+    if (!ok) unreachable; // assertion failure
+}
+
+// run
+// target=x86_64-macos
+//
diff --git a/test/cases/x86_64-macos/assert_function.1.zig b/test/cases/x86_64-macos/assert_function.1.zig
new file mode 100644
index 0000000000000000000000000000000000000000..ac2df25d8556c661b48a9382d200283073d5d00b
--- /dev/null
+++ b/test/cases/x86_64-macos/assert_function.1.zig
@@ -0,0 +1,17 @@
+pub fn main() void {
+    add(3, 4);
+}
+
+fn add(a: u32, b: u32) void {
+    const c = a + b; // 7
+    const d = a + c; // 10
+    const e = d + b; // 14
+    assert(e == 14);
+}
+
+pub fn assert(ok: bool) void {
+    if (!ok) unreachable; // assertion failure
+}
+
+// run
+//
diff --git a/test/cases/x86_64-macos/assert_function.10.zig b/test/cases/x86_64-macos/assert_function.10.zig
new file mode 100644
index 0000000000000000000000000000000000000000..b3f1610cd62b71553f20959ef9cf4cec51d8f498
--- /dev/null
+++ b/test/cases/x86_64-macos/assert_function.10.zig
@@ -0,0 +1,27 @@
+pub fn main() void {
+    assert(add(3, 4) == 116);
+}
+
+fn add(a: u32, b: u32) u32 {
+    const x: u32 = blk: {
+        const c = a + b; // 7
+        const d = a + c; // 10
+        const e = d + b; // 14
+        const f = d + e; // 24
+        const g = e + f; // 38
+        const h = f + g; // 62
+        const i = g + h; // 100
+        const j = i + d; // 110
+        break :blk j;
+    };
+    const y = x + a; // 113
+    const z = y + a; // 116
+    return z;
+}
+
+pub fn assert(ok: bool) void {
+    if (!ok) unreachable; // assertion failure
+}
+
+// run
+//
diff --git a/test/cases/x86_64-macos/assert_function.11.zig b/test/cases/x86_64-macos/assert_function.11.zig
new file mode 100644
index 0000000000000000000000000000000000000000..d64130a6775b250ca18a5900e912391dc732a7f7
--- /dev/null
+++ b/test/cases/x86_64-macos/assert_function.11.zig
@@ -0,0 +1,66 @@
+pub fn main() void {
+    assert(add(3, 4) == 1221);
+    assert(mul(3, 4) == 21609);
+}
+
+fn add(a: u32, b: u32) u32 {
+    const x: u32 = blk: {
+        const c = a + b; // 7
+        const d = a + c; // 10
+        const e = d + b; // 14
+        const f = d + e; // 24
+        const g = e + f; // 38
+        const h = f + g; // 62
+        const i = g + h; // 100
+        const j = i + d; // 110
+        const k = i + j; // 210
+        const l = j + k; // 320
+        const m = l + c; // 327
+        const n = m + d; // 337
+        const o = n + e; // 351
+        const p = o + f; // 375
+        const q = p + g; // 413
+        const r = q + h; // 475
+        const s = r + i; // 575
+        const t = s + j; // 685
+        const u = t + k; // 895
+        const v = u + l; // 1215
+        break :blk v;
+    };
+    const y = x + a; // 1218
+    const z = y + a; // 1221
+    return z;
+}
+
+fn mul(a: u32, b: u32) u32 {
+    const x: u32 = blk: {
+        const c = a * a * a * a; // 81
+        const d = a * a * a * b; // 108
+        const e = a * a * b * a; // 108
+        const f = a * a * b * b; // 144
+        const g = a * b * a * a; // 108
+        const h = a * b * a * b; // 144
+        const i = a * b * b * a; // 144
+        const j = a * b * b * b; // 192
+        const k = b * a * a * a; // 108
+        const l = b * a * a * b; // 144
+        const m = b * a * b * a; // 144
+        const n = b * a * b * b; // 192
+        const o = b * b * a * a; // 144
+        const p = b * b * a * b; // 192
+        const q = b * b * b * a; // 192
+        const r = b * b * b * b; // 256
+        const s = c + d + e + f + g + h + i + j + k + l + m + n + o + p + q + r; // 2401
+        break :blk s;
+    };
+    const y = x * a; // 7203
+    const z = y * a; // 21609
+    return z;
+}
+
+pub fn assert(ok: bool) void {
+    if (!ok) unreachable; // assertion failure
+}
+
+// run
+//
diff --git a/test/cases/x86_64-macos/assert_function.12.zig b/test/cases/x86_64-macos/assert_function.12.zig
new file mode 100644
index 0000000000000000000000000000000000000000..4f64c1e0626879a2004d66080292dc7cf962065d
--- /dev/null
+++ b/test/cases/x86_64-macos/assert_function.12.zig
@@ -0,0 +1,47 @@
+pub fn main() void {
+    assert(add(3, 4) == 791);
+    assert(add(4, 3) == 79);
+}
+
+fn add(a: u32, b: u32) u32 {
+    const x: u32 = if (a < b) blk: {
+        const c = a + b; // 7
+        const d = a + c; // 10
+        const e = d + b; // 14
+        const f = d + e; // 24
+        const g = e + f; // 38
+        const h = f + g; // 62
+        const i = g + h; // 100
+        const j = i + d; // 110
+        const k = i + j; // 210
+        const l = k + c; // 217
+        const m = l + d; // 227
+        const n = m + e; // 241
+        const o = n + f; // 265
+        const p = o + g; // 303
+        const q = p + h; // 365
+        const r = q + i; // 465
+        const s = r + j; // 575
+        const t = s + k; // 785
+        break :blk t;
+    } else blk: {
+        const t = b + b + a; // 10
+        const c = a + t; // 14
+        const d = c + t; // 24
+        const e = d + t; // 34
+        const f = e + t; // 44
+        const g = f + t; // 54
+        const h = c + g; // 68
+        break :blk h + b; // 71
+    };
+    const y = x + a; // 788, 75
+    const z = y + a; // 791, 79
+    return z;
+}
+
+pub fn assert(ok: bool) void {
+    if (!ok) unreachable; // assertion failure
+}
+
+// run
+//
diff --git a/test/cases/x86_64-macos/assert_function.13.zig b/test/cases/x86_64-macos/assert_function.13.zig
new file mode 100644
index 0000000000000000000000000000000000000000..240abf0108dbe8c08040533524872e543fd6d621
--- /dev/null
+++ b/test/cases/x86_64-macos/assert_function.13.zig
@@ -0,0 +1,19 @@
+pub fn main() void {
+    const ignore =
+        \\ cool thx
+        \\
+    ;
+    _ = ignore;
+    add('ぁ', '\x03');
+}
+
+fn add(a: u32, b: u32) void {
+    assert(a + b == 12356);
+}
+
+pub fn assert(ok: bool) void {
+    if (!ok) unreachable; // assertion failure
+}
+
+// run
+//
diff --git a/test/cases/x86_64-macos/assert_function.14.zig b/test/cases/x86_64-macos/assert_function.14.zig
new file mode 100644
index 0000000000000000000000000000000000000000..d25100dccee2bda1f615c2d870ee477c1252bed3
--- /dev/null
+++ b/test/cases/x86_64-macos/assert_function.14.zig
@@ -0,0 +1,17 @@
+pub fn main() void {
+    add(aa, bb);
+}
+
+const aa = 'ぁ';
+const bb = '\x03';
+
+fn add(a: u32, b: u32) void {
+    assert(a + b == 12356);
+}
+
+pub fn assert(ok: bool) void {
+    if (!ok) unreachable; // assertion failure
+}
+
+// run
+//
diff --git a/test/cases/x86_64-macos/assert_function.15.zig b/test/cases/x86_64-macos/assert_function.15.zig
new file mode 100644
index 0000000000000000000000000000000000000000..33ae1ed5af1279b74f089003e7b9665b55c2489b
--- /dev/null
+++ b/test/cases/x86_64-macos/assert_function.15.zig
@@ -0,0 +1,10 @@
+pub fn main() void {
+    assert("hello"[0] == 'h');
+}
+
+pub fn assert(ok: bool) void {
+    if (!ok) unreachable; // assertion failure
+}
+
+// run
+//
diff --git a/test/cases/x86_64-macos/assert_function.16.zig b/test/cases/x86_64-macos/assert_function.16.zig
new file mode 100644
index 0000000000000000000000000000000000000000..eef113642324434c4af1723aac512a57192ce726
--- /dev/null
+++ b/test/cases/x86_64-macos/assert_function.16.zig
@@ -0,0 +1,11 @@
+const hello = "hello".*;
+pub fn main() void {
+    assert(hello[1] == 'e');
+}
+
+pub fn assert(ok: bool) void {
+    if (!ok) unreachable; // assertion failure
+}
+
+// run
+//
diff --git a/test/cases/x86_64-macos/assert_function.17.zig b/test/cases/x86_64-macos/assert_function.17.zig
new file mode 100644
index 0000000000000000000000000000000000000000..ac9dce3079f6444476afd65757675726390946cf
--- /dev/null
+++ b/test/cases/x86_64-macos/assert_function.17.zig
@@ -0,0 +1,11 @@
+pub fn main() void {
+    var i: u64 = 0xFFEEDDCCBBAA9988;
+    assert(i == 0xFFEEDDCCBBAA9988);
+}
+
+pub fn assert(ok: bool) void {
+    if (!ok) unreachable; // assertion failure
+}
+
+// run
+//
diff --git a/test/cases/x86_64-macos/assert_function.18.zig b/test/cases/x86_64-macos/assert_function.18.zig
new file mode 100644
index 0000000000000000000000000000000000000000..31cf1207f3dc07541a4210641ee136eb0ba385b0
--- /dev/null
+++ b/test/cases/x86_64-macos/assert_function.18.zig
@@ -0,0 +1,35 @@
+const builtin = @import("builtin");
+
+extern "c" fn write(usize, usize, usize) usize;
+
+pub fn main() void {
+    for ("hello") |_| print();
+}
+
+fn print() void {
+    switch (builtin.os.tag) {
+        .linux => {
+            asm volatile ("syscall"
+                :
+                : [number] "{rax}" (1),
+                  [arg1] "{rdi}" (1),
+                  [arg2] "{rsi}" (@ptrToInt("hello\n")),
+                  [arg3] "{rdx}" (6),
+                : "rcx", "r11", "memory"
+            );
+        },
+        .macos => {
+            _ = write(1, @ptrToInt("hello\n"), 6);
+        },
+        else => unreachable,
+    }
+}
+
+// run
+//
+// hello
+// hello
+// hello
+// hello
+// hello
+//
diff --git a/test/cases/x86_64-macos/assert_function.2.zig b/test/cases/x86_64-macos/assert_function.2.zig
new file mode 100644
index 0000000000000000000000000000000000000000..8c1c510486185f4116841577473c901e13528283
--- /dev/null
+++ b/test/cases/x86_64-macos/assert_function.2.zig
@@ -0,0 +1,21 @@
+pub fn main() void {
+    add(3, 4);
+}
+
+fn add(a: u32, b: u32) void {
+    const c = a + b; // 7
+    const d = a + c; // 10
+    const e = d + b; // 14
+    const f = d + e; // 24
+    const g = e + f; // 38
+    const h = f + g; // 62
+    const i = g + h; // 100
+    assert(i == 100);
+}
+
+pub fn assert(ok: bool) void {
+    if (!ok) unreachable; // assertion failure
+}
+
+// run
+//
diff --git a/test/cases/x86_64-macos/assert_function.3.zig b/test/cases/x86_64-macos/assert_function.3.zig
new file mode 100644
index 0000000000000000000000000000000000000000..a6829f8e0239f8c01f0a1e4e1cf42e9ed035176b
--- /dev/null
+++ b/test/cases/x86_64-macos/assert_function.3.zig
@@ -0,0 +1,22 @@
+pub fn main() void {
+    add(3, 4);
+}
+
+fn add(a: u32, b: u32) void {
+    const c = a + b; // 7
+    const d = a + c; // 10
+    const e = d + b; // 14
+    const f = d + e; // 24
+    const g = e + f; // 38
+    const h = f + g; // 62
+    const i = g + h; // 100
+    const j = i + d; // 110
+    assert(j == 110);
+}
+
+pub fn assert(ok: bool) void {
+    if (!ok) unreachable; // assertion failure
+}
+
+// run
+//
diff --git a/test/cases/x86_64-macos/assert_function.4.zig b/test/cases/x86_64-macos/assert_function.4.zig
new file mode 100644
index 0000000000000000000000000000000000000000..69df4354c3eb8d72d4c91b226fbf4b4c0eddedaf
--- /dev/null
+++ b/test/cases/x86_64-macos/assert_function.4.zig
@@ -0,0 +1,15 @@
+pub fn main() void {
+    assert(add(3, 4) == 7);
+    assert(add(20, 10) == 30);
+}
+
+fn add(a: u32, b: u32) u32 {
+    return a + b;
+}
+
+pub fn assert(ok: bool) void {
+    if (!ok) unreachable; // assertion failure
+}
+
+// run
+//
diff --git a/test/cases/x86_64-macos/assert_function.5.zig b/test/cases/x86_64-macos/assert_function.5.zig
new file mode 100644
index 0000000000000000000000000000000000000000..89f3f7df4fd3f42da6650c27dff3c8160b281860
--- /dev/null
+++ b/test/cases/x86_64-macos/assert_function.5.zig
@@ -0,0 +1,19 @@
+pub fn main() void {
+    assert(add(3, 4) == 7);
+    assert(add(20, 10) == 30);
+}
+
+fn add(a: u32, b: u32) u32 {
+    var x: u32 = undefined;
+    x = 0;
+    x += a;
+    x += b;
+    return x;
+}
+
+pub fn assert(ok: bool) void {
+    if (!ok) unreachable; // assertion failure
+}
+
+// run
+//
diff --git a/test/cases/x86_64-macos/assert_function.6.zig b/test/cases/x86_64-macos/assert_function.6.zig
new file mode 100644
index 0000000000000000000000000000000000000000..1b1b75e68ea72902208bd0889c38202922b89a51
--- /dev/null
+++ b/test/cases/x86_64-macos/assert_function.6.zig
@@ -0,0 +1,9 @@
+pub fn main() void {
+    const a: u32 = 2;
+    const b: ?u32 = a;
+    const c = b.?;
+    if (c != 2) unreachable;
+}
+
+// run
+//
diff --git a/test/cases/x86_64-macos/assert_function.7.zig b/test/cases/x86_64-macos/assert_function.7.zig
new file mode 100644
index 0000000000000000000000000000000000000000..27ba37029a8bee825a2676c78bcbeded35108033
--- /dev/null
+++ b/test/cases/x86_64-macos/assert_function.7.zig
@@ -0,0 +1,23 @@
+extern "c" fn write(usize, usize, usize) usize;
+
+pub fn main() void {
+    var i: u32 = 0;
+    while (i < 4) : (i += 1) print();
+    assert(i == 4);
+}
+
+fn print() void {
+    _ = write(1, @ptrToInt("hello\n"), 6);
+}
+
+pub fn assert(ok: bool) void {
+    if (!ok) unreachable; // assertion failure
+}
+
+// run
+//
+// hello
+// hello
+// hello
+// hello
+//
diff --git a/test/cases/x86_64-macos/assert_function.8.zig b/test/cases/x86_64-macos/assert_function.8.zig
new file mode 100644
index 0000000000000000000000000000000000000000..801cd2e3be148fc847869d92babb8d92ef7a146f
--- /dev/null
+++ b/test/cases/x86_64-macos/assert_function.8.zig
@@ -0,0 +1,19 @@
+extern "c" fn write(usize, usize, usize) usize;
+
+pub fn main() void {
+    var i: u32 = 0;
+    inline while (i < 4) : (i += 1) print();
+    assert(i == 4);
+}
+
+fn print() void {
+    _ = write(1, @ptrToInt("hello\n"), 6);
+}
+
+pub fn assert(ok: bool) void {
+    if (!ok) unreachable; // assertion failure
+}
+
+// error
+//
+// :5:21: error: unable to resolve comptime value
diff --git a/test/cases/x86_64-macos/assert_function.9.zig b/test/cases/x86_64-macos/assert_function.9.zig
new file mode 100644
index 0000000000000000000000000000000000000000..c754bb771133d8b3a595ec9fe46c48c4c6408e61
--- /dev/null
+++ b/test/cases/x86_64-macos/assert_function.9.zig
@@ -0,0 +1,22 @@
+pub fn main() void {
+    assert(add(3, 4) == 20);
+}
+
+fn add(a: u32, b: u32) u32 {
+    const x: u32 = blk: {
+        const c = a + b; // 7
+        const d = a + c; // 10
+        const e = d + b; // 14
+        break :blk e;
+    };
+    const y = x + a; // 17
+    const z = y + a; // 20
+    return z;
+}
+
+pub fn assert(ok: bool) void {
+    if (!ok) unreachable; // assertion failure
+}
+
+// run
+//
diff --git a/test/cases/x86_64-macos/comptime_var.0.zig b/test/cases/x86_64-macos/comptime_var.0.zig
new file mode 100644
index 0000000000000000000000000000000000000000..da82b35c6fb12795af2ce139adc3766a5ee53483
--- /dev/null
+++ b/test/cases/x86_64-macos/comptime_var.0.zig
@@ -0,0 +1,12 @@
+pub fn main() void {
+    var a: u32 = 0;
+    comptime var b: u32 = 0;
+    if (a == 0) b = 3;
+}
+
+// error
+// output_mode=Exe
+// target=x86_64-macos
+//
+// :4:21: error: store to comptime variable depends on runtime condition
+// :4:11: note: runtime condition here
diff --git a/test/cases/x86_64-macos/comptime_var.1.zig b/test/cases/x86_64-macos/comptime_var.1.zig
new file mode 100644
index 0000000000000000000000000000000000000000..efc51aafe3e7572bb8815d5e75ec4e4b00761499
--- /dev/null
+++ b/test/cases/x86_64-macos/comptime_var.1.zig
@@ -0,0 +1,13 @@
+pub fn main() void {
+    var a: u32 = 0;
+    comptime var b: u32 = 0;
+    switch (a) {
+        0 => {},
+        else => b = 3,
+    }
+}
+
+// error
+//
+// :6:21: error: store to comptime variable depends on runtime condition
+// :4:13: note: runtime condition here
diff --git a/test/cases/x86_64-macos/comptime_var.2.zig b/test/cases/x86_64-macos/comptime_var.2.zig
new file mode 100644
index 0000000000000000000000000000000000000000..abd34255cdc70c519f9166c8a686d0febf5a9669
--- /dev/null
+++ b/test/cases/x86_64-macos/comptime_var.2.zig
@@ -0,0 +1,17 @@
+extern "c" fn write(usize, usize, usize) usize;
+
+pub fn main() void {
+    comptime var len: u32 = 5;
+    print(len);
+    len += 9;
+    print(len);
+}
+
+fn print(len: usize) void {
+    _ = write(1, @ptrToInt("Hello, World!\n"), len);
+}
+
+// run
+//
+// HelloHello, World!
+//
diff --git a/test/cases/x86_64-macos/comptime_var.3.zig b/test/cases/x86_64-macos/comptime_var.3.zig
new file mode 100644
index 0000000000000000000000000000000000000000..5d25d6556e4f378d4288acda9ceffcb19397230f
--- /dev/null
+++ b/test/cases/x86_64-macos/comptime_var.3.zig
@@ -0,0 +1,10 @@
+comptime {
+    var x: i32 = 1;
+    x += 1;
+    if (x != 1) unreachable;
+}
+pub fn main() void {}
+
+// error
+//
+// :4:17: error: reached unreachable code
diff --git a/test/cases/x86_64-macos/comptime_var.4.zig b/test/cases/x86_64-macos/comptime_var.4.zig
new file mode 100644
index 0000000000000000000000000000000000000000..74da6ef448edd5534b49b1f850673863b4188b99
--- /dev/null
+++ b/test/cases/x86_64-macos/comptime_var.4.zig
@@ -0,0 +1,9 @@
+pub fn main() void {
+    comptime var i: u64 = 0;
+    while (i < 5) : (i += 1) {}
+}
+
+// error
+//
+// :3:24: error: cannot store to comptime variable in non-inline loop
+// :3:5: note: non-inline loop here
diff --git a/test/cases/x86_64-macos/comptime_var.5.zig b/test/cases/x86_64-macos/comptime_var.5.zig
new file mode 100644
index 0000000000000000000000000000000000000000..76a06f3d4b5931e8fd23271dcc593e07ff414a7f
--- /dev/null
+++ b/test/cases/x86_64-macos/comptime_var.5.zig
@@ -0,0 +1,15 @@
+pub fn main() void {
+    var a: u32 = 0;
+    if (a == 0) {
+        comptime var b: u32 = 0;
+        b = 1;
+    }
+}
+comptime {
+    var x: i32 = 1;
+    x += 1;
+    if (x != 2) unreachable;
+}
+
+// run
+//
diff --git a/test/cases/x86_64-macos/comptime_var.6.zig b/test/cases/x86_64-macos/comptime_var.6.zig
new file mode 100644
index 0000000000000000000000000000000000000000..381e609bd1143f8284d3323ec63266e604d6719b
--- /dev/null
+++ b/test/cases/x86_64-macos/comptime_var.6.zig
@@ -0,0 +1,15 @@
+extern "c" fn write(usize, usize, usize) usize;
+
+pub fn main() void {
+    comptime var i: u64 = 2;
+    inline while (i < 6) : (i += 1) {
+        print(i);
+    }
+}
+fn print(len: usize) void {
+    _ = write(1, @ptrToInt("Hello"), len);
+}
+
+// run
+//
+// HeHelHellHello
diff --git a/test/cases/x86_64-macos/hello_world_with_updates.0.zig b/test/cases/x86_64-macos/hello_world_with_updates.0.zig
new file mode 100644
index 0000000000000000000000000000000000000000..dd43748e6ebae04fefc21487192228666c7d15ed
--- /dev/null
+++ b/test/cases/x86_64-macos/hello_world_with_updates.0.zig
@@ -0,0 +1,5 @@
+// error
+// output_mode=Exe
+// target=x86_64-macos
+//
+// :107:9: error: struct 'tmp.tmp' has no member named 'main'
diff --git a/test/cases/x86_64-macos/hello_world_with_updates.1.zig b/test/cases/x86_64-macos/hello_world_with_updates.1.zig
new file mode 100644
index 0000000000000000000000000000000000000000..909fc9ccfbcb343f761414446c0ec4d52e98aeef
--- /dev/null
+++ b/test/cases/x86_64-macos/hello_world_with_updates.1.zig
@@ -0,0 +1,5 @@
+pub export fn main() noreturn {}
+
+// error
+//
+// :1:32: error: expected noreturn, found void
diff --git a/test/cases/x86_64-macos/hello_world_with_updates.2.zig b/test/cases/x86_64-macos/hello_world_with_updates.2.zig
new file mode 100644
index 0000000000000000000000000000000000000000..fb8cb39eddf859f843ce61b068c0f6f8f9feb387
--- /dev/null
+++ b/test/cases/x86_64-macos/hello_world_with_updates.2.zig
@@ -0,0 +1,19 @@
+extern "c" fn write(usize, usize, usize) usize;
+extern "c" fn exit(usize) noreturn;
+
+pub export fn main() noreturn {
+    print();
+
+    exit(0);
+}
+
+fn print() void {
+    const msg = @ptrToInt("Hello, World!\n");
+    const len = 14;
+    _ = write(1, msg, len);
+}
+
+// run
+//
+// Hello, World!
+//
diff --git a/test/cases/x86_64-macos/hello_world_with_updates.3.zig b/test/cases/x86_64-macos/hello_world_with_updates.3.zig
new file mode 100644
index 0000000000000000000000000000000000000000..f6e233886b0a7d616f92dd11ffb4232191c997de
--- /dev/null
+++ b/test/cases/x86_64-macos/hello_world_with_updates.3.zig
@@ -0,0 +1,16 @@
+extern "c" fn write(usize, usize, usize) usize;
+
+pub fn main() void {
+    print();
+}
+
+fn print() void {
+    const msg = @ptrToInt("Hello, World!\n");
+    const len = 14;
+    _ = write(1, msg, len);
+}
+
+// run
+//
+// Hello, World!
+//
diff --git a/test/cases/x86_64-macos/hello_world_with_updates.4.zig b/test/cases/x86_64-macos/hello_world_with_updates.4.zig
new file mode 100644
index 0000000000000000000000000000000000000000..f89cef73543ce1f3e51a4e0152c0a8c367edf537
--- /dev/null
+++ b/test/cases/x86_64-macos/hello_world_with_updates.4.zig
@@ -0,0 +1,22 @@
+extern "c" fn write(usize, usize, usize) usize;
+
+pub fn main() void {
+    print();
+    print();
+    print();
+    print();
+}
+
+fn print() void {
+    const msg = @ptrToInt("Hello, World!\n");
+    const len = 14;
+    _ = write(1, msg, len);
+}
+
+// run
+//
+// Hello, World!
+// Hello, World!
+// Hello, World!
+// Hello, World!
+//
diff --git a/test/cases/x86_64-macos/hello_world_with_updates.5.zig b/test/cases/x86_64-macos/hello_world_with_updates.5.zig
new file mode 100644
index 0000000000000000000000000000000000000000..0d7f97578afe1274d1c8e3d356ce702992edca61
--- /dev/null
+++ b/test/cases/x86_64-macos/hello_world_with_updates.5.zig
@@ -0,0 +1,16 @@
+extern "c" fn write(usize, usize, usize) usize;
+
+pub fn main() void {
+    print();
+}
+
+fn print() void {
+    const msg = @ptrToInt("What is up? This is a longer message that will force the data to be relocated in virtual address space.\n");
+    const len = 104;
+    _ = write(1, msg, len);
+}
+
+// run
+//
+// What is up? This is a longer message that will force the data to be relocated in virtual address space.
+//
diff --git a/test/cases/x86_64-macos/hello_world_with_updates.6.zig b/test/cases/x86_64-macos/hello_world_with_updates.6.zig
new file mode 100644
index 0000000000000000000000000000000000000000..3ce2cb717639d663c2679dcdef2a4583c3c3f8ec
--- /dev/null
+++ b/test/cases/x86_64-macos/hello_world_with_updates.6.zig
@@ -0,0 +1,18 @@
+extern "c" fn write(usize, usize, usize) usize;
+
+pub fn main() void {
+    print();
+    print();
+}
+
+fn print() void {
+    const msg = @ptrToInt("What is up? This is a longer message that will force the data to be relocated in virtual address space.\n");
+    const len = 104;
+    _ = write(1, msg, len);
+}
+
+// run
+//
+// What is up? This is a longer message that will force the data to be relocated in virtual address space.
+// What is up? This is a longer message that will force the data to be relocated in virtual address space.
+//
diff --git a/test/compile_errors/stage1/exe/main_missing_name.zig b/test/compile_errors/stage1/exe/main_missing_name.zig
deleted file mode 100644
index 1a53e43cfba2967b5cda0210b92a51714634339d..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/exe/main_missing_name.zig
+++ /dev/null
@@ -1,8 +0,0 @@
-pub fn (main) void {}
-
-// error
-// backend=stage1
-// target=native
-// output_mode=Exe
-//
-// tmp.zig:1:5: error: missing function name
diff --git a/test/compile_errors/stage1/exe/missing_main_fn_in_executable.zig b/test/compile_errors/stage1/exe/missing_main_fn_in_executable.zig
deleted file mode 100644
index 65813abac32cf8541b18e12235a16a7cac85f6f0..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/exe/missing_main_fn_in_executable.zig
+++ /dev/null
@@ -1,8 +0,0 @@
-
-
-// error
-// backend=stage1
-// target=native
-// output_mode=Exe
-//
-// error: root source file has no member called 'main'
diff --git a/test/compile_errors/stage1/exe/private_main_fn.zig b/test/compile_errors/stage1/exe/private_main_fn.zig
deleted file mode 100644
index 5a178389e8905d908a3b35a79fa872d9db20940e..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/exe/private_main_fn.zig
+++ /dev/null
@@ -1,9 +0,0 @@
-fn main() void {}
-
-// error
-// backend=stage1
-// target=native
-// output_mode=Exe
-//
-// error: 'main' is private
-// tmp.zig:1:1: note: declared here
diff --git a/test/compile_errors/stage1/obj/C_pointer_pointing_to_non_C_ABI_compatible_type_or_has_align_attr.zig b/test/compile_errors/stage1/obj/C_pointer_pointing_to_non_C_ABI_compatible_type_or_has_align_attr.zig
deleted file mode 100644
index 72c58adbd61cc3a505f7b6f69966e60d63095820..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/C_pointer_pointing_to_non_C_ABI_compatible_type_or_has_align_attr.zig
+++ /dev/null
@@ -1,12 +0,0 @@
-const Foo = struct {};
-export fn a() void {
-    const T = [*c]Foo;
-    var t: T = undefined;
-    _ = t;
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:3:19: error: C pointers cannot point to non-C-ABI-compatible type 'Foo'
diff --git a/test/compile_errors/stage1/obj/C_pointer_to_anyopaque.zig b/test/compile_errors/stage1/obj/C_pointer_to_anyopaque.zig
deleted file mode 100644
index 36c9789d20f263caa9a96eb2a1fc46fc2fba496c..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/C_pointer_to_anyopaque.zig
+++ /dev/null
@@ -1,11 +0,0 @@
-export fn a() void {
-    var x: *anyopaque = undefined;
-    var y: [*c]anyopaque = x;
-    _ = y;
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:3:16: error: C pointers cannot point to opaque types
diff --git a/test/compile_errors/stage1/obj/Frame_of_generic_function.zig b/test/compile_errors/stage1/obj/Frame_of_generic_function.zig
deleted file mode 100644
index d90e53eb4683dba5f55a8e99388d04f47aa91390..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/Frame_of_generic_function.zig
+++ /dev/null
@@ -1,14 +0,0 @@
-export fn entry() void {
-    var frame: @Frame(func) = undefined;
-    _ = frame;
-}
-fn func(comptime T: type) void {
-    var x: T = undefined;
-    _ = x;
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:2:16: error: @Frame() of generic function
diff --git a/test/compile_errors/stage1/obj/Issue_5586_Make_unary_minus_for_unsigned_types_a_compile_error.zig b/test/compile_errors/stage1/obj/Issue_5586_Make_unary_minus_for_unsigned_types_a_compile_error.zig
deleted file mode 100644
index e1d498e65f40a2e2583e684186d0f6921cf974ef..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/Issue_5586_Make_unary_minus_for_unsigned_types_a_compile_error.zig
+++ /dev/null
@@ -1,16 +0,0 @@
-export fn f1(x: u32) u32 {
-    const y = -%x;
-    return -y;
-}
-const V = @import("std").meta.Vector;
-export fn f2(x: V(4, u32)) V(4, u32) {
-    const y = -%x;
-    return -y;
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:3:12: error: negation of type 'u32'
-// tmp.zig:8:12: error: negation of type 'u32'
diff --git a/test/compile_errors/stage1/obj/Issue_6823_dont_allow_._to_be_followed_by_.zig b/test/compile_errors/stage1/obj/Issue_6823_dont_allow_._to_be_followed_by_.zig
deleted file mode 100644
index 1aa0996ba4d7abacfb09a0aff758cd3bca61424c..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/Issue_6823_dont_allow_._to_be_followed_by_.zig
+++ /dev/null
@@ -1,10 +0,0 @@
-fn foo() void {
-    var sequence = "repeat".*** 10;
-    _ = sequence;
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:2:28: error: '.*' cannot be followed by '*'. Are you missing a space?
diff --git a/test/compile_errors/stage1/obj/Issue_9165_windows_tcp_server_compilation_error.zig b/test/compile_errors/stage1/obj/Issue_9165_windows_tcp_server_compilation_error.zig
deleted file mode 100644
index 3d150693f556edec171b11cc9f0f851c57336fb2..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/Issue_9165_windows_tcp_server_compilation_error.zig
+++ /dev/null
@@ -1,16 +0,0 @@
-const std = @import("std");
-const builtin = @import("builtin");
-pub const io_mode = .evented;
-pub fn main() !void {
-    if (builtin.os.tag == .windows) {
-        _ = try (std.net.StreamServer.init(.{})).accept();
-    } else {
-        @compileError("Unsupported OS");
-    }
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// error: Unsupported OS
diff --git a/test/compile_errors/stage1/obj/access_non-existent_member_of_error_set.zig b/test/compile_errors/stage1/obj/access_non-existent_member_of_error_set.zig
deleted file mode 100644
index caddf36a8436cd538c181efc3974f34f7812b7a4..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/access_non-existent_member_of_error_set.zig
+++ /dev/null
@@ -1,11 +0,0 @@
-const Foo = error{A};
-comptime {
-    const z = Foo.Bar;
-    _ = z;
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:3:18: error: no error named 'Bar' in 'Foo'
diff --git a/test/compile_errors/stage1/obj/accessing_runtime_parameter_from_outer_function.zig b/test/compile_errors/stage1/obj/accessing_runtime_parameter_from_outer_function.zig
deleted file mode 100644
index 73a9e94d4428df5a3de41ef013bf99abe4d5b882..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/accessing_runtime_parameter_from_outer_function.zig
+++ /dev/null
@@ -1,21 +0,0 @@
-fn outer(y: u32) fn (u32) u32 {
-    const st = struct {
-        fn get(z: u32) u32 {
-            return z + y;
-        }
-    };
-    return st.get;
-}
-export fn entry() void {
-    var func = outer(10);
-    var x = func(3);
-    _ = x;
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:4:24: error: 'y' not accessible from inner function
-// tmp.zig:3:28: note: crossed function definition here
-// tmp.zig:1:10: note: declared here
diff --git a/test/compile_errors/stage1/obj/add_assign_on_undefined_value.zig b/test/compile_errors/stage1/obj/add_assign_on_undefined_value.zig
deleted file mode 100644
index 38e4fef81bc124e03c07c0b029c2b2f7e1d6ede0..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/add_assign_on_undefined_value.zig
+++ /dev/null
@@ -1,10 +0,0 @@
-comptime {
-    var a: i64 = undefined;
-    a += a;
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:3:5: error: use of undefined value here causes undefined behavior
diff --git a/test/compile_errors/stage1/obj/add_on_undefined_value.zig b/test/compile_errors/stage1/obj/add_on_undefined_value.zig
deleted file mode 100644
index 4a66f9c102ba452512e78a9320bb008b77179a02..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/add_on_undefined_value.zig
+++ /dev/null
@@ -1,10 +0,0 @@
-comptime {
-    var a: i64 = undefined;
-    _ = a + a;
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:3:9: error: use of undefined value here causes undefined behavior
diff --git a/test/compile_errors/stage1/obj/add_overflow_in_function_evaluation.zig b/test/compile_errors/stage1/obj/add_overflow_in_function_evaluation.zig
deleted file mode 100644
index d4fa312482d942eb5d787956a072635cb674bf26..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/add_overflow_in_function_evaluation.zig
+++ /dev/null
@@ -1,12 +0,0 @@
-const y = add(65530, 10);
-fn add(a: u16, b: u16) u16 {
-    return a + b;
-}
-
-export fn entry() usize { return @sizeOf(@TypeOf(y)); }
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:3:14: error: operation caused overflow
diff --git a/test/compile_errors/stage1/obj/add_wrap_assign_on_undefined_value.zig b/test/compile_errors/stage1/obj/add_wrap_assign_on_undefined_value.zig
deleted file mode 100644
index 5f9a4c61fc34d83790db326f1cc925c70c70fe85..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/add_wrap_assign_on_undefined_value.zig
+++ /dev/null
@@ -1,10 +0,0 @@
-comptime {
-    var a: i64 = undefined;
-    a +%= a;
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:3:5: error: use of undefined value here causes undefined behavior
diff --git a/test/compile_errors/stage1/obj/add_wrap_on_undefined_value.zig b/test/compile_errors/stage1/obj/add_wrap_on_undefined_value.zig
deleted file mode 100644
index 582b8ec1cfc85ff91224f11799f78631c75a2951..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/add_wrap_on_undefined_value.zig
+++ /dev/null
@@ -1,10 +0,0 @@
-comptime {
-    var a: i64 = undefined;
-    _ = a +% a;
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:3:9: error: use of undefined value here causes undefined behavior
diff --git a/test/compile_errors/stage1/obj/addition_with_non_numbers.zig b/test/compile_errors/stage1/obj/addition_with_non_numbers.zig
deleted file mode 100644
index 8f343926f281ffa3efb54881f03a5f4bd4b4f87f..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/addition_with_non_numbers.zig
+++ /dev/null
@@ -1,12 +0,0 @@
-const Foo = struct {
-    field: i32,
-};
-const x = Foo {.field = 1} + Foo {.field = 2};
-
-export fn entry() usize { return @sizeOf(@TypeOf(x)); }
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:4:28: error: invalid operands to binary expression: 'Foo' and 'Foo'
diff --git a/test/compile_errors/stage1/obj/address_of_number_literal.zig b/test/compile_errors/stage1/obj/address_of_number_literal.zig
deleted file mode 100644
index 76d321929d9863e9d2ac1a8fece85e4d12ad2d72..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/address_of_number_literal.zig
+++ /dev/null
@@ -1,10 +0,0 @@
-const x = 3;
-const y = &x;
-fn foo() *const i32 { return y; }
-export fn entry() usize { return @sizeOf(@TypeOf(foo)); }
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:3:30: error: expected type '*const i32', found '*const comptime_int'
diff --git a/test/compile_errors/stage1/obj/alignCast_expects_pointer_or_slice.zig b/test/compile_errors/stage1/obj/alignCast_expects_pointer_or_slice.zig
deleted file mode 100644
index 9f76d3ca4fff45a35b9c12c30ba95260f50a9702..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/alignCast_expects_pointer_or_slice.zig
+++ /dev/null
@@ -1,9 +0,0 @@
-export fn entry() void {
-    @alignCast(4, @as(u32, 3));
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:2:19: error: expected pointer or slice, found 'u32'
diff --git a/test/compile_errors/stage1/obj/align_n_expr_function_pointers_is_a_compile_error.zig b/test/compile_errors/stage1/obj/align_n_expr_function_pointers_is_a_compile_error.zig
deleted file mode 100644
index bd41b3e6574b317af3c5e0c1554b8bf39533f7bd..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/align_n_expr_function_pointers_is_a_compile_error.zig
+++ /dev/null
@@ -1,9 +0,0 @@
-export fn foo() align(1) void {
-    return;
-}
-
-// error
-// backend=stage1
-// target=wasm32-freestanding-none
-//
-// tmp.zig:1:23: error: align(N) expr is not allowed on function prototypes in wasm32/wasm64
diff --git a/test/compile_errors/stage1/obj/aligned_variable_of_zero-bit_type.zig b/test/compile_errors/stage1/obj/aligned_variable_of_zero-bit_type.zig
deleted file mode 100644
index f09f92aca782d98925abbe67f50ae573cbce32e0..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/aligned_variable_of_zero-bit_type.zig
+++ /dev/null
@@ -1,10 +0,0 @@
-export fn f() void {
-    var s: struct {} align(4) = undefined;
-    _ = s;
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:2:5: error: variable 's' of zero-bit type 'struct:2:12' has no in-memory representation, it cannot be aligned
diff --git a/test/compile_errors/stage1/obj/alignment_of_enum_field_specified.zig b/test/compile_errors/stage1/obj/alignment_of_enum_field_specified.zig
deleted file mode 100644
index 9b6f1e452d2dd76f36ecf750d232ae9a07ec0e3f..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/alignment_of_enum_field_specified.zig
+++ /dev/null
@@ -1,14 +0,0 @@
-const Number = enum {
-    a,
-    b align(i32),
-};
-export fn entry1() void {
-    var x: Number = undefined;
-    _ = x;
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:3:7: error: expected ',' after field
diff --git a/test/compile_errors/stage1/obj/ambiguous_decl_reference.zig b/test/compile_errors/stage1/obj/ambiguous_decl_reference.zig
deleted file mode 100644
index 82e6a0a24cadfc2539c66dcc54f07691d6c9815d..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/ambiguous_decl_reference.zig
+++ /dev/null
@@ -1,21 +0,0 @@
-fn foo() void {}
-fn bar() void {
-    const S = struct {
-        fn baz() void {
-            foo();
-        }
-        fn foo() void {}
-    };
-    S.baz();
-}
-export fn entry() void {
-    bar();
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:5:13: error: ambiguous reference
-// tmp.zig:7:9: note: declared here
-// tmp.zig:1:1: note: also declared here
diff --git a/test/compile_errors/stage1/obj/and_on_undefined_value.zig b/test/compile_errors/stage1/obj/and_on_undefined_value.zig
deleted file mode 100644
index 6071d81062fcc32291a7673bcb6e2877ea7d3358..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/and_on_undefined_value.zig
+++ /dev/null
@@ -1,10 +0,0 @@
-comptime {
-    var a: bool = undefined;
-    _ = a and a;
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:3:9: error: use of undefined value here causes undefined behavior
diff --git a/test/compile_errors/stage1/obj/array_access_of_non_array.zig b/test/compile_errors/stage1/obj/array_access_of_non_array.zig
deleted file mode 100644
index 7045f2fdbd304867e7e52ce889c7f69212923e74..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/array_access_of_non_array.zig
+++ /dev/null
@@ -1,15 +0,0 @@
-export fn f() void {
-    var bad : bool = undefined;
-    bad[0] = bad[0];
-}
-export fn g() void {
-    var bad : bool = undefined;
-    _ = bad[0];
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:3:8: error: array access of non-array type 'bool'
-// tmp.zig:7:12: error: array access of non-array type 'bool'
diff --git a/test/compile_errors/stage1/obj/array_access_of_type.zig b/test/compile_errors/stage1/obj/array_access_of_type.zig
deleted file mode 100644
index c0029f24924ee24368470c500f05d2b66e26d233..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/array_access_of_type.zig
+++ /dev/null
@@ -1,10 +0,0 @@
-export fn foo() void {
-    var b: u8[40] = undefined;
-    _ = b;
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:2:14: error: array access of non-array type 'type'
diff --git a/test/compile_errors/stage1/obj/array_access_of_undeclared_identifier.zig b/test/compile_errors/stage1/obj/array_access_of_undeclared_identifier.zig
deleted file mode 100644
index 7d16a0d60e6d9465bba265454034a66a67e2dac0..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/array_access_of_undeclared_identifier.zig
+++ /dev/null
@@ -1,9 +0,0 @@
-export fn f() void {
-    i[i] = i[i];
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:2:5: error: use of undeclared identifier 'i'
diff --git a/test/compile_errors/stage1/obj/array_access_with_non_integer_index.zig b/test/compile_errors/stage1/obj/array_access_with_non_integer_index.zig
deleted file mode 100644
index de0a58656c5789a4f3689cf0a9a7eeed41a6fd26..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/array_access_with_non_integer_index.zig
+++ /dev/null
@@ -1,17 +0,0 @@
-export fn f() void {
-    var array = "aoeu";
-    var bad = false;
-    array[bad] = array[bad];
-}
-export fn g() void {
-    var array = "aoeu";
-    var bad = false;
-    _ = array[bad];
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:4:11: error: expected type 'usize', found 'bool'
-// tmp.zig:9:15: error: expected type 'usize', found 'bool'
diff --git a/test/compile_errors/stage1/obj/array_concatenation_with_wrong_type.zig b/test/compile_errors/stage1/obj/array_concatenation_with_wrong_type.zig
deleted file mode 100644
index ccddc7efbd5b2b37ba81375cad57fda646d78988..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/array_concatenation_with_wrong_type.zig
+++ /dev/null
@@ -1,11 +0,0 @@
-const src = "aoeu";
-const derp: usize = 1234;
-const a = derp ++ "foo";
-
-export fn entry() usize { return @sizeOf(@TypeOf(a)); }
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:3:11: error: expected array, found 'usize'
diff --git a/test/compile_errors/stage1/obj/array_in_c_exported_function.zig b/test/compile_errors/stage1/obj/array_in_c_exported_function.zig
deleted file mode 100644
index 5137755474a6ed7bcfa530a6463232db78a9142f..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/array_in_c_exported_function.zig
+++ /dev/null
@@ -1,14 +0,0 @@
-export fn zig_array(x: [10]u8) void {
-    try std.testing.expect(std.mem.eql(u8, &x, "1234567890"));
-}
-const std = @import("std");
-export fn zig_return_array() [10]u8 {
-    return "1234567890".*;
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:1:24: error: parameter of type '[10]u8' not allowed in function with calling convention 'C'
-// tmp.zig:5:30: error: return type '[10]u8' not allowed in function with calling convention 'C'
diff --git a/test/compile_errors/stage1/obj/asm_at_compile_time.zig b/test/compile_errors/stage1/obj/asm_at_compile_time.zig
deleted file mode 100644
index fcfd5e7da6b1df490029c1f9e6213d3dc90ab6d1..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/asm_at_compile_time.zig
+++ /dev/null
@@ -1,17 +0,0 @@
-comptime {
-    doSomeAsm();
-}
-
-fn doSomeAsm() void {
-    asm volatile (
-        \\.globl aoeu;
-        \\.type aoeu, @function;
-        \\.set aoeu, derp;
-    );
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:6:5: error: unable to evaluate constant expression
diff --git a/test/compile_errors/stage1/obj/assign_inline_fn_to_non-comptime_var.zig b/test/compile_errors/stage1/obj/assign_inline_fn_to_non-comptime_var.zig
deleted file mode 100644
index 7714bb728293133efdcad1c65208995d8d81b8a1..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/assign_inline_fn_to_non-comptime_var.zig
+++ /dev/null
@@ -1,12 +0,0 @@
-export fn entry() void {
-    var a = b;
-    _ = a;
-}
-fn b() callconv(.Inline) void { }
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:2:5: error: functions marked inline must be stored in const or comptime var
-// tmp.zig:5:1: note: declared here
diff --git a/test/compile_errors/stage1/obj/assign_null_to_non-optional_pointer.zig b/test/compile_errors/stage1/obj/assign_null_to_non-optional_pointer.zig
deleted file mode 100644
index 110d6c26299e260fc40c5e5d329e34f5048a0eb3..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/assign_null_to_non-optional_pointer.zig
+++ /dev/null
@@ -1,9 +0,0 @@
-const a: *u8 = null;
-
-export fn entry() usize { return @sizeOf(@TypeOf(a)); }
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:1:16: error: expected type '*u8', found '@Type(.Null)'
diff --git a/test/compile_errors/stage1/obj/assign_through_constant_pointer.zig b/test/compile_errors/stage1/obj/assign_through_constant_pointer.zig
deleted file mode 100644
index 69ba383843554e341ea9ec8263217d351cf38c5d..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/assign_through_constant_pointer.zig
+++ /dev/null
@@ -1,10 +0,0 @@
-export fn f() void {
-  var cstr = "Hat";
-  cstr[0] = 'W';
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:3:13: error: cannot assign to constant
diff --git a/test/compile_errors/stage1/obj/assign_through_constant_slice.zig b/test/compile_errors/stage1/obj/assign_through_constant_slice.zig
deleted file mode 100644
index 55d2e7e7c7f6dd134a93d02a8a13f96e8db8e68a..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/assign_through_constant_slice.zig
+++ /dev/null
@@ -1,10 +0,0 @@
-export fn f() void {
-  var cstr: []const u8 = "Hat";
-  cstr[0] = 'W';
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:3:13: error: cannot assign to constant
diff --git a/test/compile_errors/stage1/obj/assign_to_constant_field.zig b/test/compile_errors/stage1/obj/assign_to_constant_field.zig
deleted file mode 100644
index 610818118ae0c203106f0c41232525a70d9ca70b..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/assign_to_constant_field.zig
+++ /dev/null
@@ -1,13 +0,0 @@
-const Foo = struct {
-    field: i32,
-};
-export fn derp() void {
-    const f = Foo {.field = 1234,};
-    f.field = 0;
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:6:15: error: cannot assign to constant
diff --git a/test/compile_errors/stage1/obj/assign_to_constant_variable.zig b/test/compile_errors/stage1/obj/assign_to_constant_variable.zig
deleted file mode 100644
index 531f669c1aa4af7b066b112aef22547d104c0698..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/assign_to_constant_variable.zig
+++ /dev/null
@@ -1,10 +0,0 @@
-export fn f() void {
-    const a = 3;
-    a = 4;
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:3:9: error: cannot assign to constant
diff --git a/test/compile_errors/stage1/obj/assign_to_invalid_dereference.zig b/test/compile_errors/stage1/obj/assign_to_invalid_dereference.zig
deleted file mode 100644
index 7fef5db83c33e930d40686158e122b081a9c9121..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/assign_to_invalid_dereference.zig
+++ /dev/null
@@ -1,9 +0,0 @@
-export fn entry() void {
-    'a'.* = 1;
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:2:8: error: attempt to dereference non-pointer type 'comptime_int'
diff --git a/test/compile_errors/stage1/obj/assign_too_big_number_to_u16.zig b/test/compile_errors/stage1/obj/assign_too_big_number_to_u16.zig
deleted file mode 100644
index 3138ed5faf7169849afeee1fb37ec6543aad39c2..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/assign_too_big_number_to_u16.zig
+++ /dev/null
@@ -1,10 +0,0 @@
-export fn foo() void {
-    var vga_mem: u16 = 0xB8000;
-    _ = vga_mem;
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:2:24: error: integer value 753664 cannot be coerced to type 'u16'
diff --git a/test/compile_errors/stage1/obj/assign_unreachable.zig b/test/compile_errors/stage1/obj/assign_unreachable.zig
deleted file mode 100644
index f87adcd9942298fa9130ce2f91be392d92db90b2..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/assign_unreachable.zig
+++ /dev/null
@@ -1,10 +0,0 @@
-export fn f() void {
-    const a = return;
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:2:5: error: unreachable code
-// tmp.zig:2:15: note: control flow is diverted here
diff --git a/test/compile_errors/stage1/obj/assigning_to_struct_or_union_fields_that_are_not_optionals_with_a_function_that_returns_an_optional.zig b/test/compile_errors/stage1/obj/assigning_to_struct_or_union_fields_that_are_not_optionals_with_a_function_that_returns_an_optional.zig
deleted file mode 100644
index 8285991c05e042fd12132177640690ca176f8d6f..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/assigning_to_struct_or_union_fields_that_are_not_optionals_with_a_function_that_returns_an_optional.zig
+++ /dev/null
@@ -1,21 +0,0 @@
-fn maybe(is: bool) ?u8 {
-    if (is) return @as(u8, 10) else return null;
-}
-const U = union {
-    Ye: u8,
-};
-const S = struct {
-    num: u8,
-};
-export fn entry() void {
-    var u = U{ .Ye = maybe(false) };
-    var s = S{ .num = maybe(false) };
-    _ = u;
-    _ = s;
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:11:27: error: cannot convert optional to payload type. consider using `.?`, `orelse`, or `if`. expected type 'u8', found '?u8'
diff --git a/test/compile_errors/stage1/obj/async_function_depends_on_its_own_frame.zig b/test/compile_errors/stage1/obj/async_function_depends_on_its_own_frame.zig
deleted file mode 100644
index 4dde5860bafc4709d376e1703df95b14ce58420f..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/async_function_depends_on_its_own_frame.zig
+++ /dev/null
@@ -1,13 +0,0 @@
-export fn entry() void {
-    _ = async amain();
-}
-fn amain() callconv(.Async) void {
-    var x: [@sizeOf(@Frame(amain))]u8 = undefined;
-    _ = x;
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:4:1: error: cannot resolve '@Frame(amain)': function not fully analyzed yet
diff --git a/test/compile_errors/stage1/obj/async_function_indirectly_depends_on_its_own_frame.zig b/test/compile_errors/stage1/obj/async_function_indirectly_depends_on_its_own_frame.zig
deleted file mode 100644
index 4dac0d4fa33fbc45db20184af0c0734552b9df81..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/async_function_indirectly_depends_on_its_own_frame.zig
+++ /dev/null
@@ -1,17 +0,0 @@
-export fn entry() void {
-    _ = async amain();
-}
-fn amain() callconv(.Async) void {
-    other();
-}
-fn other() void {
-    var x: [@sizeOf(@Frame(amain))]u8 = undefined;
-    _ = x;
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:4:1: error: unable to determine async function frame of 'amain'
-// tmp.zig:5:10: note: analysis of function 'other' depends on the frame
diff --git a/test/compile_errors/stage1/obj/atomic_orderings_of_atomicStore_Acquire_or_AcqRel.zig b/test/compile_errors/stage1/obj/atomic_orderings_of_atomicStore_Acquire_or_AcqRel.zig
deleted file mode 100644
index dfc7ff5036871218e35687d4ee5c4e9d54282aed..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/atomic_orderings_of_atomicStore_Acquire_or_AcqRel.zig
+++ /dev/null
@@ -1,10 +0,0 @@
-export fn entry() void {
-    var x: u32 = 0;
-    @atomicStore(u32, &x, 1, .Acquire);
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:3:30: error: @atomicStore atomic ordering must not be Acquire or AcqRel
diff --git a/test/compile_errors/stage1/obj/atomic_orderings_of_cmpxchg-failure_stricter_than_success.zig b/test/compile_errors/stage1/obj/atomic_orderings_of_cmpxchg-failure_stricter_than_success.zig
deleted file mode 100644
index 929950e754ed419589dc91c2056c684a8f5c5c07..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/atomic_orderings_of_cmpxchg-failure_stricter_than_success.zig
+++ /dev/null
@@ -1,11 +0,0 @@
-const AtomicOrder = @import("std").builtin.AtomicOrder;
-export fn f() void {
-    var x: i32 = 1234;
-    while (!@cmpxchgWeak(i32, &x, 1234, 5678, AtomicOrder.Monotonic, AtomicOrder.SeqCst)) {}
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:4:81: error: failure atomic ordering must be no stricter than success
diff --git a/test/compile_errors/stage1/obj/atomic_orderings_of_cmpxchg-success_Monotonic_or_stricter.zig b/test/compile_errors/stage1/obj/atomic_orderings_of_cmpxchg-success_Monotonic_or_stricter.zig
deleted file mode 100644
index fe3344e53664537243ba930ca72069af4011bc14..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/atomic_orderings_of_cmpxchg-success_Monotonic_or_stricter.zig
+++ /dev/null
@@ -1,11 +0,0 @@
-const AtomicOrder = @import("std").builtin.AtomicOrder;
-export fn f() void {
-    var x: i32 = 1234;
-    while (!@cmpxchgWeak(i32, &x, 1234, 5678, AtomicOrder.Unordered, AtomicOrder.Unordered)) {}
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:4:58: error: success atomic ordering must be Monotonic or stricter
diff --git a/test/compile_errors/stage1/obj/atomic_orderings_of_fence_Acquire_or_stricter.zig b/test/compile_errors/stage1/obj/atomic_orderings_of_fence_Acquire_or_stricter.zig
deleted file mode 100644
index 8a01871a80ce34c31d290bea280ff8f98fc0f33e..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/atomic_orderings_of_fence_Acquire_or_stricter.zig
+++ /dev/null
@@ -1,9 +0,0 @@
-export fn entry() void {
-    @fence(.Monotonic);
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:2:12: error: atomic ordering must be Acquire or stricter
diff --git a/test/compile_errors/stage1/obj/atomicrmw_with_bool_op_not_.Xchg.zig b/test/compile_errors/stage1/obj/atomicrmw_with_bool_op_not_.Xchg.zig
deleted file mode 100644
index 0b5b0cd3c1ecfa6a7250928ff8291dcfc70fd734..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/atomicrmw_with_bool_op_not_.Xchg.zig
+++ /dev/null
@@ -1,10 +0,0 @@
-export fn entry() void {
-    var x = false;
-    _ = @atomicRmw(bool, &x, .Add, true, .SeqCst);
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:3:30: error: @atomicRmw with bool only allowed with .Xchg
diff --git a/test/compile_errors/stage1/obj/atomicrmw_with_enum_op_not_.Xchg.zig b/test/compile_errors/stage1/obj/atomicrmw_with_enum_op_not_.Xchg.zig
deleted file mode 100644
index adbf4ca45e8d073fa381f8e3f32243b57da5ba03..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/atomicrmw_with_enum_op_not_.Xchg.zig
+++ /dev/null
@@ -1,16 +0,0 @@
-export fn entry() void {
-    const E = enum(u8) {
-        a,
-        b,
-        c,
-        d,
-    };
-    var x: E = .a;
-    _ = @atomicRmw(E, &x, .Add, .b, .SeqCst);
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:9:27: error: @atomicRmw with enum only allowed with .Xchg
diff --git a/test/compile_errors/stage1/obj/atomicrmw_with_float_op_not_.Xchg_.Add_or_.Sub.zig b/test/compile_errors/stage1/obj/atomicrmw_with_float_op_not_.Xchg_.Add_or_.Sub.zig
deleted file mode 100644
index 4f3ebfcef6af9293418aa92edb8290127f5b3726..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/atomicrmw_with_float_op_not_.Xchg_.Add_or_.Sub.zig
+++ /dev/null
@@ -1,10 +0,0 @@
-export fn entry() void {
-    var x: f32 = 0;
-    _ = @atomicRmw(f32, &x, .And, 2, .SeqCst);
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:3:29: error: @atomicRmw with float only allowed with .Xchg, .Add and .Sub
diff --git a/test/compile_errors/stage1/obj/attempt_to_cast_enum_literal_to_error.zig b/test/compile_errors/stage1/obj/attempt_to_cast_enum_literal_to_error.zig
deleted file mode 100644
index f1c30815fca0dfce8bea8128e6a15bfbf983a243..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/attempt_to_cast_enum_literal_to_error.zig
+++ /dev/null
@@ -1,11 +0,0 @@
-export fn entry() void {
-    switch (error.Hi) {
-        .Hi => {},
-    }
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:3:9: error: expected type 'error{Hi}', found '@Type(.EnumLiteral)'
diff --git a/test/compile_errors/stage1/obj/attempt_to_close_over_comptime_variable_from_outer_scope.zig b/test/compile_errors/stage1/obj/attempt_to_close_over_comptime_variable_from_outer_scope.zig
deleted file mode 100644
index 58eb9d19d20f03b16a30f252c953b818bfa6e77b..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/attempt_to_close_over_comptime_variable_from_outer_scope.zig
+++ /dev/null
@@ -1,14 +0,0 @@
-fn SimpleList(comptime L: usize) type {
-    var T = u8;
-    return struct {
-        array: [L]T,
-    };
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:4:19: error: mutable 'T' not accessible from here
-// tmp.zig:2:9: note: declared mutable here
-// tmp.zig:3:12: note: crosses namespace boundary here
diff --git a/test/compile_errors/stage1/obj/attempt_to_create_17_bit_float_type.zig b/test/compile_errors/stage1/obj/attempt_to_create_17_bit_float_type.zig
deleted file mode 100644
index ba7393fcb76d8f003bc81feb2348b94290dc58e8..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/attempt_to_create_17_bit_float_type.zig
+++ /dev/null
@@ -1,10 +0,0 @@
-const builtin = @import("std").builtin;
-comptime {
-    _ = @Type(.{ .Float = .{ .bits = 17 } });
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:3:16: error: 17-bit float unsupported
diff --git a/test/compile_errors/stage1/obj/attempt_to_negate_a_non-integer_non-float_or_non-vector_type.zig b/test/compile_errors/stage1/obj/attempt_to_negate_a_non-integer_non-float_or_non-vector_type.zig
deleted file mode 100644
index e9bbf921aba193bbdb74c01d65ecd6bd57f8a858..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/attempt_to_negate_a_non-integer_non-float_or_non-vector_type.zig
+++ /dev/null
@@ -1,14 +0,0 @@
-fn foo() anyerror!u32 {
-    return 1;
-}
-
-export fn entry() void {
-    const x = -foo();
-    _ = x;
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:6:15: error: negation of type 'anyerror!u32'
diff --git a/test/compile_errors/stage1/obj/attempt_to_use_0_bit_type_in_extern_fn.zig b/test/compile_errors/stage1/obj/attempt_to_use_0_bit_type_in_extern_fn.zig
deleted file mode 100644
index 021cd97f190493043b72f1aa12338e5c4b5b2cc2..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/attempt_to_use_0_bit_type_in_extern_fn.zig
+++ /dev/null
@@ -1,17 +0,0 @@
-extern fn foo(ptr: fn(*void) callconv(.C) void) void;
-
-export fn entry() void {
-    foo(bar);
-}
-
-fn bar(x: *void) callconv(.C) void { _ = x; }
-export fn entry2() void {
-    bar(&{});
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:1:23: error: parameter of type '*void' has 0 bits; not allowed in function with calling convention 'C'
-// tmp.zig:7:11: error: parameter of type '*void' has 0 bits; not allowed in function with calling convention 'C'
diff --git a/test/compile_errors/stage1/obj/attempted_double_ampersand.zig b/test/compile_errors/stage1/obj/attempted_double_ampersand.zig
deleted file mode 100644
index c749b172c6541a3db255aebc0d2f26f1dd62c70a..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/attempted_double_ampersand.zig
+++ /dev/null
@@ -1,12 +0,0 @@
-export fn entry(a: bool, b: bool) i32 {
-    if (a && b) {
-        return 1234;
-    }
-    return 5678;
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:2:11: error: ambiguous use of '&&'; use 'and' for logical AND, or change whitespace to ' & &' for bitwise AND
diff --git a/test/compile_errors/stage1/obj/attempted_double_pipe_on_boolean_values.zig b/test/compile_errors/stage1/obj/attempted_double_pipe_on_boolean_values.zig
deleted file mode 100644
index b991b1b61b5c603779d53d63c0b9afabd6006b8e..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/attempted_double_pipe_on_boolean_values.zig
+++ /dev/null
@@ -1,13 +0,0 @@
-export fn entry(a: bool, b: bool) i32 {
-    if (a || b) {
-        return 1234;
-    }
-    return 5678;
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:2:9: error: expected error set type, found 'bool'
-// tmp.zig:2:11: note: `||` merges error sets; `or` performs boolean OR
diff --git a/test/compile_errors/stage1/obj/attempted_implicit_cast_from_T_to_slice_const_T.zig b/test/compile_errors/stage1/obj/attempted_implicit_cast_from_T_to_slice_const_T.zig
deleted file mode 100644
index c3b0847129cdd4de1f4525e676ffb0fce2b40d9d..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/attempted_implicit_cast_from_T_to_slice_const_T.zig
+++ /dev/null
@@ -1,10 +0,0 @@
-export fn entry() void {
-    const x: [*]const bool = true;
-    _ = x;
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:2:30: error: expected type '[*]const bool', found 'bool'
diff --git a/test/compile_errors/stage1/obj/attempted_implicit_cast_from_const_T_to_array_len_1_T.zig b/test/compile_errors/stage1/obj/attempted_implicit_cast_from_const_T_to_array_len_1_T.zig
deleted file mode 100644
index 760866dd651acbf6c48e91bfe5665825e01c1634..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/attempted_implicit_cast_from_const_T_to_array_len_1_T.zig
+++ /dev/null
@@ -1,14 +0,0 @@
-export fn entry(byte: u8) void {
-    const w: i32 = 1234;
-    var x: *const i32 = &w;
-    var y: *[1]i32 = x;
-    y[0] += 1;
-    _ = byte;
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:4:22: error: expected type '*[1]i32', found '*const i32'
-// tmp.zig:4:22: note: cast discards const qualifier
diff --git a/test/compile_errors/stage1/obj/attempted_implicit_cast_from_const_T_to_sliceT.zig b/test/compile_errors/stage1/obj/attempted_implicit_cast_from_const_T_to_sliceT.zig
deleted file mode 100644
index 3ff9937983279a8a54947cea711bd3afcea56a84..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/attempted_implicit_cast_from_const_T_to_sliceT.zig
+++ /dev/null
@@ -1,11 +0,0 @@
-export fn entry() void {
-    const u: u32 = 42;
-    const x: []u32 = &u;
-    _ = x;
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:3:23: error: expected type '[]u32', found '*const u32'
diff --git a/test/compile_errors/stage1/obj/bad_alignCast_at_comptime.zig b/test/compile_errors/stage1/obj/bad_alignCast_at_comptime.zig
deleted file mode 100644
index f1ed25e19168d8e4c890e806ef5b6d30d2995494..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/bad_alignCast_at_comptime.zig
+++ /dev/null
@@ -1,11 +0,0 @@
-comptime {
-    const ptr = @intToPtr(*align(1) i32, 0x1);
-    const aligned = @alignCast(4, ptr);
-    _ = aligned;
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:3:35: error: pointer address 0x1 is not aligned to 4 bytes
diff --git a/test/compile_errors/stage1/obj/bad_alignment_in_asynccall.zig b/test/compile_errors/stage1/obj/bad_alignment_in_asynccall.zig
deleted file mode 100644
index 399914000994b76b44c91e8200b74dafcd7aa1be..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/bad_alignment_in_asynccall.zig
+++ /dev/null
@@ -1,12 +0,0 @@
-export fn entry() void {
-    var ptr: fn () callconv(.Async) void = func;
-    var bytes: [64]u8 = undefined;
-    _ = @asyncCall(&bytes, {}, ptr, .{});
-}
-fn func() callconv(.Async) void {}
-
-// error
-// backend=stage1
-// target=aarch64-linux-none
-//
-// tmp.zig:4:21: error: expected type '[]align(8) u8', found '*[64]u8'
diff --git a/test/compile_errors/stage1/obj/bad_alignment_in_implicit_cast_from_array_pointer_to_slice.zig b/test/compile_errors/stage1/obj/bad_alignment_in_implicit_cast_from_array_pointer_to_slice.zig
deleted file mode 100644
index 12064bd9ab0b6b4e8c3f6789bf091d5f12721463..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/bad_alignment_in_implicit_cast_from_array_pointer_to_slice.zig
+++ /dev/null
@@ -1,11 +0,0 @@
-export fn a() void {
-    var x: [10]u8 = undefined;
-    var y: []align(16) u8 = &x;
-    _ = y;
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:3:30: error: expected type '[]align(16) u8', found '*[10]u8'
diff --git a/test/compile_errors/stage1/obj/bad_alignment_type.zig b/test/compile_errors/stage1/obj/bad_alignment_type.zig
deleted file mode 100644
index a4d8b7d68f6cceca709cb5b93d3b7677e4cb7d7d..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/bad_alignment_type.zig
+++ /dev/null
@@ -1,15 +0,0 @@
-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;
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:2:20: error: expected type 'u29', found 'bool'
-// tmp.zig:6:19: error: fractional component prevents float value 12.340000 from being casted to type 'u29'
diff --git a/test/compile_errors/stage1/obj/bad_identifier_in_function_with_struct_defined_inside_function_which_references_local_const.zig b/test/compile_errors/stage1/obj/bad_identifier_in_function_with_struct_defined_inside_function_which_references_local_const.zig
deleted file mode 100644
index 7e44ad5057cc67a71b976c538150574f42cb177f..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/bad_identifier_in_function_with_struct_defined_inside_function_which_references_local_const.zig
+++ /dev/null
@@ -1,17 +0,0 @@
-export fn entry() void {
-    const BlockKind = u32;
-
-    const Block = struct {
-        kind: BlockKind,
-    };
-
-    bogus;
-
-    _ = Block;
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:8:5: error: use of undeclared identifier 'bogus'
diff --git a/test/compile_errors/stage1/obj/bad_import.zig b/test/compile_errors/stage1/obj/bad_import.zig
deleted file mode 100644
index 1a7ab5f00b78f479da870f6009dbdea06dc2a4b3..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/bad_import.zig
+++ /dev/null
@@ -1,7 +0,0 @@
-const bogus = @import("bogus-does-not-exist.zig",);
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:1:23: error: unable to load '${DIR}bogus-does-not-exist.zig': FileNotFound
diff --git a/test/compile_errors/stage1/obj/bad_usage_of_call.zig b/test/compile_errors/stage1/obj/bad_usage_of_call.zig
deleted file mode 100644
index c77ccf1a525ca5144581da98903e60aa74f19b7b..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/bad_usage_of_call.zig
+++ /dev/null
@@ -1,30 +0,0 @@
-export fn entry1() void {
-    @call(.{}, foo, {});
-}
-export fn entry2() void {
-    comptime @call(.{ .modifier = .never_inline }, foo, .{});
-}
-export fn entry3() void {
-    comptime @call(.{ .modifier = .never_tail }, foo, .{});
-}
-export fn entry4() void {
-    @call(.{ .modifier = .never_inline }, bar, .{});
-}
-export fn entry5(c: bool) void {
-    var baz = if (c) baz1 else baz2;
-    @call(.{ .modifier = .compile_time }, baz, .{});
-}
-fn foo() void {}
-fn bar() callconv(.Inline) void {}
-fn baz1() void {}
-fn baz2() void {}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:2:21: error: expected tuple or struct, found 'void'
-// tmp.zig:5:14: error: unable to perform 'never_inline' call at compile-time
-// tmp.zig:8:14: error: unable to perform 'never_tail' call at compile-time
-// tmp.zig:11:5: error: no-inline call of inline function
-// tmp.zig:15:5: error: the specified modifier requires a comptime-known function
diff --git a/test/compile_errors/stage1/obj/bin_and_assign_on_undefined_value.zig b/test/compile_errors/stage1/obj/bin_and_assign_on_undefined_value.zig
deleted file mode 100644
index 1076f9abdb6c170e84f0770f5ec33d04e0c572f1..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/bin_and_assign_on_undefined_value.zig
+++ /dev/null
@@ -1,10 +0,0 @@
-comptime {
-    var a: i64 = undefined;
-    a &= a;
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:3:5: error: use of undefined value here causes undefined behavior
diff --git a/test/compile_errors/stage1/obj/bin_and_on_undefined_value.zig b/test/compile_errors/stage1/obj/bin_and_on_undefined_value.zig
deleted file mode 100644
index a53d9a10ac66b5ba7f107648fea3f18fb7c0c37d..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/bin_and_on_undefined_value.zig
+++ /dev/null
@@ -1,10 +0,0 @@
-comptime {
-    var a: i64 = undefined;
-    _ = a & a;
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:3:9: error: use of undefined value here causes undefined behavior
diff --git a/test/compile_errors/stage1/obj/bin_not_on_undefined_value.zig b/test/compile_errors/stage1/obj/bin_not_on_undefined_value.zig
deleted file mode 100644
index 7e0f554f0b1a718848f4b551f5ae51556cb17e4a..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/bin_not_on_undefined_value.zig
+++ /dev/null
@@ -1,10 +0,0 @@
-comptime {
-    var a: i64 = undefined;
-    _ = ~a;
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:3:10: error: use of undefined value here causes undefined behavior
diff --git a/test/compile_errors/stage1/obj/bin_or_assign_on_undefined_value.zig b/test/compile_errors/stage1/obj/bin_or_assign_on_undefined_value.zig
deleted file mode 100644
index cc61fc03e168cb211ced6b390c2f2923fb719615..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/bin_or_assign_on_undefined_value.zig
+++ /dev/null
@@ -1,10 +0,0 @@
-comptime {
-    var a: i64 = undefined;
-    a |= a;
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:3:5: error: use of undefined value here causes undefined behavior
diff --git a/test/compile_errors/stage1/obj/bin_or_on_undefined_value.zig b/test/compile_errors/stage1/obj/bin_or_on_undefined_value.zig
deleted file mode 100644
index 7ac30bcb4e69471e3e317cc559dca17520d26776..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/bin_or_on_undefined_value.zig
+++ /dev/null
@@ -1,10 +0,0 @@
-comptime {
-    var a: i64 = undefined;
-    _ = a | a;
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:3:9: error: use of undefined value here causes undefined behavior
diff --git a/test/compile_errors/stage1/obj/bin_xor_assign_on_undefined_value.zig b/test/compile_errors/stage1/obj/bin_xor_assign_on_undefined_value.zig
deleted file mode 100644
index 37e3eae321bc7246cd8f1ccce419300891497d04..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/bin_xor_assign_on_undefined_value.zig
+++ /dev/null
@@ -1,10 +0,0 @@
-comptime {
-    var a: i64 = undefined;
-    a ^= a;
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:3:5: error: use of undefined value here causes undefined behavior
diff --git a/test/compile_errors/stage1/obj/bin_xor_on_undefined_value.zig b/test/compile_errors/stage1/obj/bin_xor_on_undefined_value.zig
deleted file mode 100644
index f1656b60131df144286c32a984458cf33dc9793e..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/bin_xor_on_undefined_value.zig
+++ /dev/null
@@ -1,10 +0,0 @@
-comptime {
-    var a: i64 = undefined;
-    _ = a ^ a;
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:3:9: error: use of undefined value here causes undefined behavior
diff --git a/test/compile_errors/stage1/obj/binary_not_on_number_literal.zig b/test/compile_errors/stage1/obj/binary_not_on_number_literal.zig
deleted file mode 100644
index 34ddf9adfa0c44c3180917e53927313ab69f04ed..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/binary_not_on_number_literal.zig
+++ /dev/null
@@ -1,11 +0,0 @@
-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);
-
-export fn entry() usize { return @sizeOf(@TypeOf(block_aligned_stuff)); }
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:3:60: error: unable to perform binary not operation on type 'comptime_int'
diff --git a/test/compile_errors/stage1/obj/bitCast_same_size_but_bit_count_mismatch.zig b/test/compile_errors/stage1/obj/bitCast_same_size_but_bit_count_mismatch.zig
deleted file mode 100644
index 9150dc32853c9ff6c5bd3d9f6553bd4aa2ceee3f..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/bitCast_same_size_but_bit_count_mismatch.zig
+++ /dev/null
@@ -1,10 +0,0 @@
-export fn entry(byte: u8) void {
-    var oops = @bitCast(u7, byte);
-    _ = oops;
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:2:25: error: destination type 'u7' has 7 bits but source type 'u8' has 8 bits
diff --git a/test/compile_errors/stage1/obj/bitCast_to_enum_type.zig b/test/compile_errors/stage1/obj/bitCast_to_enum_type.zig
deleted file mode 100644
index 4d63ab9e019a540760e3d3196e66dbd3b999bc2f..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/bitCast_to_enum_type.zig
+++ /dev/null
@@ -1,10 +0,0 @@
-export fn entry() void {
-    const y = @bitCast(enum(u32) { a, b }, @as(u32, 3));
-    _ = y;
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:2:24: error: cannot cast a value of type 'y'
diff --git a/test/compile_errors/stage1/obj/bitCast_with_different_sizes_inside_an_expression.zig b/test/compile_errors/stage1/obj/bitCast_with_different_sizes_inside_an_expression.zig
deleted file mode 100644
index 64caef7cd0cdf99997a8a228d4a70c9abe33fa53..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/bitCast_with_different_sizes_inside_an_expression.zig
+++ /dev/null
@@ -1,10 +0,0 @@
-export fn entry() void {
-    var foo = (@bitCast(u8, @as(f32, 1.0)) == 0xf);
-    _ = foo;
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:2:25: error: destination type 'u8' has size 1 but source type 'f32' has size 4
diff --git a/test/compile_errors/stage1/obj/bit_shifting_only_works_on_integer_types.zig b/test/compile_errors/stage1/obj/bit_shifting_only_works_on_integer_types.zig
deleted file mode 100644
index 7d1c5873a1fe3242af429f7492719d1b53b7dc55..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/bit_shifting_only_works_on_integer_types.zig
+++ /dev/null
@@ -1,10 +0,0 @@
-export fn entry() void {
-    const x = &@as(u8, 1) << 10;
-    _ = x;
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:2:16: error: bit shifting operation expected integer type, found '*const u8'
diff --git a/test/compile_errors/stage1/obj/bogus_compile_var.zig b/test/compile_errors/stage1/obj/bogus_compile_var.zig
deleted file mode 100644
index 845d943c7ddc973769b2db96407f611f6c2bb43e..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/bogus_compile_var.zig
+++ /dev/null
@@ -1,8 +0,0 @@
-const x = @import("builtin").bogus;
-export fn entry() usize { return @sizeOf(@TypeOf(x)); }
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:1:29: error: container 'builtin' has no member called 'bogus'
diff --git a/test/compile_errors/stage1/obj/bogus_method_call_on_slice.zig b/test/compile_errors/stage1/obj/bogus_method_call_on_slice.zig
deleted file mode 100644
index 3ede578b34e57005baa67405fb3bf406a78ab276..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/bogus_method_call_on_slice.zig
+++ /dev/null
@@ -1,11 +0,0 @@
-var self = "aoeu";
-fn f(m: []const u8) void {
-    m.copy(u8, self[0..], m);
-}
-export fn entry() usize { return @sizeOf(@TypeOf(f)); }
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:3:6: error: no member named 'copy' in '[]const u8'
diff --git a/test/compile_errors/stage1/obj/bool_not_on_undefined_value.zig b/test/compile_errors/stage1/obj/bool_not_on_undefined_value.zig
deleted file mode 100644
index 5c99a9739b5941044e38593009ac0636adceef54..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/bool_not_on_undefined_value.zig
+++ /dev/null
@@ -1,10 +0,0 @@
-comptime {
-    var a: bool = undefined;
-    _ = !a;
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:3:10: error: use of undefined value here causes undefined behavior
diff --git a/test/compile_errors/stage1/obj/branch_on_undefined_value.zig b/test/compile_errors/stage1/obj/branch_on_undefined_value.zig
deleted file mode 100644
index f4b922a3328af9c42082a5e461eb84f6569020da..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/branch_on_undefined_value.zig
+++ /dev/null
@@ -1,9 +0,0 @@
-const x = if (undefined) true else false;
-
-export fn entry() usize { return @sizeOf(@TypeOf(x)); }
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:1:15: error: use of undefined value here causes undefined behavior
diff --git a/test/compile_errors/stage1/obj/cImport_with_bogus_include.zig b/test/compile_errors/stage1/obj/cImport_with_bogus_include.zig
deleted file mode 100644
index 141f21cb9a7ef9a9534a15cd6d0955b6ddef4a5c..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/cImport_with_bogus_include.zig
+++ /dev/null
@@ -1,9 +0,0 @@
-const c = @cImport(@cInclude("bogus.h"));
-export fn entry() usize { return @sizeOf(@TypeOf(c.bogo)); }
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:1:11: error: C import failed
-// .h:1:10: note: 'bogus.h' file not found
diff --git a/test/compile_errors/stage1/obj/call_assigned_to_constant.zig b/test/compile_errors/stage1/obj/call_assigned_to_constant.zig
deleted file mode 100644
index ca4e8b67cd02ece3a12191a4cb66b2cbb6b89055..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/call_assigned_to_constant.zig
+++ /dev/null
@@ -1,24 +0,0 @@
-const Foo = struct {
-    x: i32,
-};
-fn foo() Foo {
-    return .{ .x = 42 };
-}
-fn bar(val: anytype) Foo {
-    return .{ .x = val };
-}
-export fn entry() void {
-    const baz: Foo = undefined;
-    baz = foo();
-}
-export fn entry1() void {
-    const baz: Foo = undefined;
-    baz = bar(42);
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:12:14: error: cannot assign to constant
-// tmp.zig:16:14: error: cannot assign to constant
diff --git a/test/compile_errors/stage1/obj/call_with_new_stack_on_unsupported_target.zig b/test/compile_errors/stage1/obj/call_with_new_stack_on_unsupported_target.zig
deleted file mode 100644
index 7cb504a3f9d645c58bfbfe3fbb1b5d10ba9a9d7f..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/call_with_new_stack_on_unsupported_target.zig
+++ /dev/null
@@ -1,11 +0,0 @@
-var buf: [10]u8 align(16) = undefined;
-export fn entry() void {
-    @call(.{ .stack = &buf }, foo, .{});
-}
-fn foo() void {}
-
-// error
-// backend=stage1
-// target=wasm32-wasi-none
-//
-// tmp.zig:3:5: error: target arch 'wasm32' does not support calling with a new stack
diff --git a/test/compile_errors/stage1/obj/callconv_apcs_aapcs_aapcsvfp_on_unsupported_platform.zig b/test/compile_errors/stage1/obj/callconv_apcs_aapcs_aapcsvfp_on_unsupported_platform.zig
deleted file mode 100644
index fa062878036cc6a321068c9b1489a809367fde59..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/callconv_apcs_aapcs_aapcsvfp_on_unsupported_platform.zig
+++ /dev/null
@@ -1,11 +0,0 @@
-export fn entry1() callconv(.APCS) void {}
-export fn entry2() callconv(.AAPCS) void {}
-export fn entry3() callconv(.AAPCSVFP) void {}
-
-// error
-// backend=stage1
-// target=x86_64-linux-none
-//
-// tmp.zig:1:29: error: callconv 'APCS' is only available on ARM, not x86_64
-// 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
diff --git a/test/compile_errors/stage1/obj/callconv_interrupt_on_unsupported_platform.zig b/test/compile_errors/stage1/obj/callconv_interrupt_on_unsupported_platform.zig
deleted file mode 100644
index 8304fb90c1edc167edec2f9ca142bd6675c3116d..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/callconv_interrupt_on_unsupported_platform.zig
+++ /dev/null
@@ -1,7 +0,0 @@
-export fn entry() callconv(.Interrupt) void {}
-
-// error
-// backend=stage1
-// target=aarch64-linux-none
-//
-// tmp.zig:1:28: error: callconv 'Interrupt' is only available on x86, x86_64, AVR, and MSP430, not aarch64
diff --git a/test/compile_errors/stage1/obj/callconv_signal_on_unsupported_platform.zig b/test/compile_errors/stage1/obj/callconv_signal_on_unsupported_platform.zig
deleted file mode 100644
index 4b19b188fdd8c8b6d03c54886f97e5e75614e83c..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/callconv_signal_on_unsupported_platform.zig
+++ /dev/null
@@ -1,7 +0,0 @@
-export fn entry() callconv(.Signal) void {}
-
-// error
-// backend=stage1
-// target=x86_64-linux-none
-//
-// tmp.zig:1:28: error: callconv 'Signal' is only available on AVR, not x86_64
diff --git a/test/compile_errors/stage1/obj/callconv_stdcall_fastcall_thiscall_on_unsupported_platform-0.zig b/test/compile_errors/stage1/obj/callconv_stdcall_fastcall_thiscall_on_unsupported_platform-0.zig
deleted file mode 100644
index f4994107cd13bae21514393ebcce71f88f36b785..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/callconv_stdcall_fastcall_thiscall_on_unsupported_platform-0.zig
+++ /dev/null
@@ -1,23 +0,0 @@
-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;
-    _ = a;
-}
-export fn entry2() void {
-    var a: F2 = undefined;
-    _ = a;
-}
-export fn entry3() void {
-    var a: F3 = undefined;
-    _ = a;
-}
-
-// error
-// backend=stage1
-// target=x86_64-linux-none
-//
-// 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
diff --git a/test/compile_errors/stage1/obj/callconv_stdcall_fastcall_thiscall_on_unsupported_platform-1.zig b/test/compile_errors/stage1/obj/callconv_stdcall_fastcall_thiscall_on_unsupported_platform-1.zig
deleted file mode 100644
index aa23f9ae51714129903e57ab42655c3656eada31..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/callconv_stdcall_fastcall_thiscall_on_unsupported_platform-1.zig
+++ /dev/null
@@ -1,11 +0,0 @@
-export fn entry1() callconv(.Stdcall) void {}
-export fn entry2() callconv(.Fastcall) void {}
-export fn entry3() callconv(.Thiscall) void {}
-
-// error
-// backend=stage1
-// target=x86_64-linux-none
-//
-// tmp.zig:1:29: error: callconv 'Stdcall' is only available on x86, not x86_64
-// 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
diff --git a/test/compile_errors/stage1/obj/callconv_vectorcall_on_unsupported_platform.zig b/test/compile_errors/stage1/obj/callconv_vectorcall_on_unsupported_platform.zig
deleted file mode 100644
index e60e6ab42c0b9ab8bc756af0ec979502ad9a3dc8..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/callconv_vectorcall_on_unsupported_platform.zig
+++ /dev/null
@@ -1,7 +0,0 @@
-export fn entry() callconv(.Vectorcall) void {}
-
-// error
-// backend=stage1
-// target=x86_64-linux-none
-//
-// tmp.zig:1:28: error: callconv 'Vectorcall' is only available on x86 and AArch64, not x86_64
diff --git a/test/compile_errors/stage1/obj/calling_a_generic_function_only_known_at_runtime.zig b/test/compile_errors/stage1/obj/calling_a_generic_function_only_known_at_runtime.zig
deleted file mode 100644
index 3081f0f1e184573eccf3625c0373233f8d4494b5..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/calling_a_generic_function_only_known_at_runtime.zig
+++ /dev/null
@@ -1,14 +0,0 @@
-var foos = [_]fn(anytype) void { foo1, foo2 };
-
-fn foo1(arg: anytype) void {_ = arg;}
-fn foo2(arg: anytype) void {_ = arg;}
-
-pub fn main() !void {
-    foos[0](true);
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:7:9: error: calling a generic function requires compile-time known function value
diff --git a/test/compile_errors/stage1/obj/calling_function_with_naked_calling_convention.zig b/test/compile_errors/stage1/obj/calling_function_with_naked_calling_convention.zig
deleted file mode 100644
index 401f84e687da591d8ea817f5f1c27f4bfd02a563..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/calling_function_with_naked_calling_convention.zig
+++ /dev/null
@@ -1,11 +0,0 @@
-export fn entry() void {
-    foo();
-}
-fn foo() callconv(.Naked) void { }
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:2:5: error: unable to call function with naked calling convention
-// tmp.zig:4:1: note: declared here
diff --git a/test/compile_errors/stage1/obj/calling_var_args_extern_function_passing_array_instead_of_pointer.zig b/test/compile_errors/stage1/obj/calling_var_args_extern_function_passing_array_instead_of_pointer.zig
deleted file mode 100644
index a71ab051f280967e4af951c8d35d672523a5b9ae..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/calling_var_args_extern_function_passing_array_instead_of_pointer.zig
+++ /dev/null
@@ -1,10 +0,0 @@
-export fn entry() void {
-    foo("hello".*,);
-}
-pub extern fn foo(format: *const u8, ...) void;
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:2:16: error: expected type '*const u8', found '[5:0]u8'
diff --git a/test/compile_errors/stage1/obj/cannot_break_out_of_defer_expression.zig b/test/compile_errors/stage1/obj/cannot_break_out_of_defer_expression.zig
deleted file mode 100644
index 3c7ae4fa2f0669ab158e410357191c0fde58523f..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/cannot_break_out_of_defer_expression.zig
+++ /dev/null
@@ -1,13 +0,0 @@
-export fn foo() void {
-    while (true) {
-        defer {
-            break;
-        }
-    }
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:4:13: error: cannot break out of defer expression
diff --git a/test/compile_errors/stage1/obj/cannot_continue_out_of_defer_expression.zig b/test/compile_errors/stage1/obj/cannot_continue_out_of_defer_expression.zig
deleted file mode 100644
index 56b8ced05be00935793775af365f84ef919ef950..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/cannot_continue_out_of_defer_expression.zig
+++ /dev/null
@@ -1,13 +0,0 @@
-export fn foo() void {
-    while (true) {
-        defer {
-            continue;
-        }
-    }
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:4:13: error: cannot continue out of defer expression
diff --git a/test/compile_errors/stage1/obj/capture_group_on_switch_prong_with_incompatible_payload_types.zig b/test/compile_errors/stage1/obj/capture_group_on_switch_prong_with_incompatible_payload_types.zig
deleted file mode 100644
index ce2068d6c701421af71d3e6a738070889511c9a9..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/capture_group_on_switch_prong_with_incompatible_payload_types.zig
+++ /dev/null
@@ -1,21 +0,0 @@
-const Union = union(enum) {
-    A: usize,
-    B: isize,
-};
-comptime {
-    var u = Union{ .A = 8 };
-    switch (u) {
-        .A, .B => |e| {
-            _ = e;
-            unreachable;
-        },
-    }
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:8:20: error: capture group with incompatible types
-// tmp.zig:8:9: note: type 'usize' here
-// tmp.zig:8:13: note: type 'isize' here
diff --git a/test/compile_errors/stage1/obj/cast_enum_literal_to_enum_but_it_doesnt_match.zig b/test/compile_errors/stage1/obj/cast_enum_literal_to_enum_but_it_doesnt_match.zig
deleted file mode 100644
index ba53646efcc8c700484eaa330c17083dd822ca68..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/cast_enum_literal_to_enum_but_it_doesnt_match.zig
+++ /dev/null
@@ -1,15 +0,0 @@
-const Foo = enum {
-    a,
-    b,
-};
-export fn entry() void {
-    const x: Foo = .c;
-    _ = x;
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:6:20: error: enum 'Foo' has no field named 'c'
-// tmp.zig:1:13: note: 'Foo' declared here
diff --git a/test/compile_errors/stage1/obj/cast_error_union_of_global_error_set_to_error_union_of_smaller_error_set.zig b/test/compile_errors/stage1/obj/cast_error_union_of_global_error_set_to_error_union_of_smaller_error_set.zig
deleted file mode 100644
index 08962afc855f31095613daa866f17448e16e5f9e..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/cast_error_union_of_global_error_set_to_error_union_of_smaller_error_set.zig
+++ /dev/null
@@ -1,16 +0,0 @@
-const SmallErrorSet = error{A};
-export fn entry() void {
-    var x: SmallErrorSet!i32 = foo();
-    _ = x;
-}
-fn foo() anyerror!i32 {
-    return error.B;
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:3:35: error: expected type 'SmallErrorSet!i32', found 'anyerror!i32'
-// tmp.zig:3:35: note: error set 'anyerror' cannot cast into error set 'SmallErrorSet'
-// tmp.zig:3:35: note: cannot cast global error set into smaller set
diff --git a/test/compile_errors/stage1/obj/cast_global_error_set_to_error_set.zig b/test/compile_errors/stage1/obj/cast_global_error_set_to_error_set.zig
deleted file mode 100644
index be9487cc5a9486cc766828d6675e56fe1f02157c..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/cast_global_error_set_to_error_set.zig
+++ /dev/null
@@ -1,15 +0,0 @@
-const SmallErrorSet = error{A};
-export fn entry() void {
-    var x: SmallErrorSet = foo();
-    _ = x;
-}
-fn foo() anyerror {
-    return error.B;
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:3:31: error: expected type 'SmallErrorSet', found 'anyerror'
-// tmp.zig:3:31: note: cannot cast global error set into smaller set
diff --git a/test/compile_errors/stage1/obj/cast_negative_integer_literal_to_usize.zig b/test/compile_errors/stage1/obj/cast_negative_integer_literal_to_usize.zig
deleted file mode 100644
index 763e0c8a238ecf83aaa354f2652088fd819360cd..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/cast_negative_integer_literal_to_usize.zig
+++ /dev/null
@@ -1,10 +0,0 @@
-export fn entry() void {
-    const x = @as(usize, -10);
-    _ = x;
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:2:26: error: cannot cast negative value -10 to unsigned integer type 'usize'
diff --git a/test/compile_errors/stage1/obj/cast_negative_value_to_unsigned_integer.zig b/test/compile_errors/stage1/obj/cast_negative_value_to_unsigned_integer.zig
deleted file mode 100644
index d2e318714054f8265defd34dad989ac64baac418..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/cast_negative_value_to_unsigned_integer.zig
+++ /dev/null
@@ -1,17 +0,0 @@
-comptime {
-    const value: i32 = -1;
-    const unsigned = @intCast(u32, value);
-    _ = unsigned;
-}
-export fn entry1() void {
-    const value: i32 = -1;
-    const unsigned: u32 = value;
-    _ = unsigned;
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:3:22: error: attempt to cast negative value to unsigned integer
-// tmp.zig:8:27: error: cannot cast negative value -1 to unsigned integer type 'u32'
diff --git a/test/compile_errors/stage1/obj/cast_unreachable.zig b/test/compile_errors/stage1/obj/cast_unreachable.zig
deleted file mode 100644
index b043108737805b841e274e1787145796448b94c7..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/cast_unreachable.zig
+++ /dev/null
@@ -1,11 +0,0 @@
-fn f() i32 {
-    return @as(i32, return 1);
-}
-export fn entry() void { _ = f(); }
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:2:12: error: unreachable code
-// tmp.zig:2:21: note: control flow is diverted here
diff --git a/test/compile_errors/stage1/obj/casting_bit_offset_pointer_to_regular_pointer.zig b/test/compile_errors/stage1/obj/casting_bit_offset_pointer_to_regular_pointer.zig
deleted file mode 100644
index f109cdf2955bf947976dd16b1f5de07bec3d4216..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/casting_bit_offset_pointer_to_regular_pointer.zig
+++ /dev/null
@@ -1,21 +0,0 @@
-const BitField = packed struct {
-    a: u3,
-    b: u3,
-    c: u2,
-};
-
-fn foo(bit_field: *const BitField) u3 {
-    return bar(&bit_field.b);
-}
-
-fn bar(x: *const u3) u3 {
-    return x.*;
-}
-
-export fn entry() usize { return @sizeOf(@TypeOf(foo)); }
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:8:26: error: expected type '*const u3', found '*align(:3:1) const u3'
diff --git a/test/compile_errors/stage1/obj/catch_on_undefined_value.zig b/test/compile_errors/stage1/obj/catch_on_undefined_value.zig
deleted file mode 100644
index 53a5f1c2a958df64ecd574fd082b91ec9439fada..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/catch_on_undefined_value.zig
+++ /dev/null
@@ -1,10 +0,0 @@
-comptime {
-    var a: anyerror!bool = undefined;
-    _ = a catch false;
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:3:11: error: use of undefined value here causes undefined behavior
diff --git a/test/compile_errors/stage1/obj/chained_comparison_operators.zig b/test/compile_errors/stage1/obj/chained_comparison_operators.zig
deleted file mode 100644
index 1e4ed8d82e1b7dcb925f05ac6f5ec443f94cfb45..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/chained_comparison_operators.zig
+++ /dev/null
@@ -1,9 +0,0 @@
-export fn a(value: u32) bool {
-    return 1 < value < 1000;
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:2:22: error: comparison operators cannot be chained
diff --git a/test/compile_errors/stage1/obj/cmpxchg_with_float.zig b/test/compile_errors/stage1/obj/cmpxchg_with_float.zig
deleted file mode 100644
index 11f2dc21c31bf50b88373242f696da9c903ddd08..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/cmpxchg_with_float.zig
+++ /dev/null
@@ -1,10 +0,0 @@
-export fn entry() void {
-    var x: f32 = 0;
-    _ = @cmpxchgWeak(f32, &x, 1, 2, .SeqCst, .SeqCst);
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:3:22: error: expected bool, integer, enum or pointer type, found 'f32'
diff --git a/test/compile_errors/stage1/obj/colliding_invalid_top_level_functions.zig b/test/compile_errors/stage1/obj/colliding_invalid_top_level_functions.zig
deleted file mode 100644
index 344edbaa9fa2fbd73a93f00e9a8a067b4e61a00f..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/colliding_invalid_top_level_functions.zig
+++ /dev/null
@@ -1,10 +0,0 @@
-fn func() bogus {}
-fn func() bogus {}
-export fn entry() usize { return @sizeOf(@TypeOf(func)); }
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:2:1: error: redeclaration of 'func'
-// tmp.zig:1:1: note: other declaration here
diff --git a/test/compile_errors/stage1/obj/compare_optional_to_non-optional_with_invalid_types.zig b/test/compile_errors/stage1/obj/compare_optional_to_non-optional_with_invalid_types.zig
deleted file mode 100644
index 32e1fe9b246381a8b09016ac565d9ac36655b298..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/compare_optional_to_non-optional_with_invalid_types.zig
+++ /dev/null
@@ -1,35 +0,0 @@
-export fn inconsistentChildType() void {
-    var x: ?i32 = undefined;
-    const y: comptime_int = 10;
-    _ = (x == y);
-}
-
-export fn optionalToOptional() void {
-    var x: ?i32 = undefined;
-    var y: ?i32 = undefined;
-    _ = (x == y);
-}
-
-export fn optionalVector() void {
-    var x: ?@Vector(10, i32) = undefined;
-    var y: @Vector(10, i32) = undefined;
-    _ = (x == y);
-}
-
-export fn invalidChildType() void {
-    var x: ?[3]i32 = undefined;
-    var y: [3]i32 = undefined;
-    _ = (x == y);
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// :4:12: error: cannot compare types '?i32' and 'comptime_int'
-// :4:12: note: optional child type 'i32' must be the same as non-optional type 'comptime_int'
-// :10:12: error: cannot compare types '?i32' and '?i32'
-// :10:12: note: optional to optional comparison is only supported for optional pointer types
-// :16:12: error: TODO add comparison of optional vector
-// :22:12: error: cannot compare types '?[3]i32' and '[3]i32'
-// :22:12: note: operator not supported for type '[3]i32'
diff --git a/test/compile_errors/stage1/obj/comparing_a_non-optional_pointer_against_null.zig b/test/compile_errors/stage1/obj/comparing_a_non-optional_pointer_against_null.zig
deleted file mode 100644
index 62b570803494ef8c4cb2ec15a8388b762e4960b8..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/comparing_a_non-optional_pointer_against_null.zig
+++ /dev/null
@@ -1,10 +0,0 @@
-export fn entry() void {
-    var x: i32 = 1;
-    _ = &x == null;
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:3:12: error: comparison of '*i32' with null
diff --git a/test/compile_errors/stage1/obj/comparing_against_undefined_produces_undefined_value.zig b/test/compile_errors/stage1/obj/comparing_against_undefined_produces_undefined_value.zig
deleted file mode 100644
index 8bad61e6d1d6321166386d17fe4c60db4800c623..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/comparing_against_undefined_produces_undefined_value.zig
+++ /dev/null
@@ -1,9 +0,0 @@
-export fn entry() void {
-    if (2 == undefined) {}
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:2:11: error: use of undefined value here causes undefined behavior
diff --git a/test/compile_errors/stage1/obj/comparison_operators_with_undefined_value.zig b/test/compile_errors/stage1/obj/comparison_operators_with_undefined_value.zig
deleted file mode 100644
index 818a575fc8b30cfd26929eb61b6923f9a5cd85bb..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/comparison_operators_with_undefined_value.zig
+++ /dev/null
@@ -1,47 +0,0 @@
-// operator ==
-comptime {
-    var a: i64 = undefined;
-    var x: i32 = 0;
-    if (a == a) x += 1;
-}
-// operator !=
-comptime {
-    var a: i64 = undefined;
-    var x: i32 = 0;
-    if (a != a) x += 1;
-}
-// operator >
-comptime {
-    var a: i64 = undefined;
-    var x: i32 = 0;
-    if (a > a) x += 1;
-}
-// operator <
-comptime {
-    var a: i64 = undefined;
-    var x: i32 = 0;
-    if (a < a) x += 1;
-}
-// operator >=
-comptime {
-    var a: i64 = undefined;
-    var x: i32 = 0;
-    if (a >= a) x += 1;
-}
-// operator <=
-comptime {
-    var a: i64 = undefined;
-    var x: i32 = 0;
-    if (a <= a) x += 1;
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:5:11: error: use of undefined value here causes undefined behavior
-// tmp.zig:11:11: error: use of undefined value here causes undefined behavior
-// tmp.zig:17:11: error: use of undefined value here causes undefined behavior
-// tmp.zig:23:11: error: use of undefined value here causes undefined behavior
-// tmp.zig:29:11: error: use of undefined value here causes undefined behavior
-// tmp.zig:35:11: error: use of undefined value here causes undefined behavior
diff --git a/test/compile_errors/stage1/obj/comparison_with_error_union_and_error_value.zig b/test/compile_errors/stage1/obj/comparison_with_error_union_and_error_value.zig
deleted file mode 100644
index 16f3b21c3d39a539fb324f9f62e4874eb028ba79..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/comparison_with_error_union_and_error_value.zig
+++ /dev/null
@@ -1,10 +0,0 @@
-export fn entry() void {
-    var number_or_error: anyerror!i32 = error.SomethingAwful;
-    _ = number_or_error == error.SomethingAwful;
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:3:25: error: operator not allowed for type 'anyerror!i32'
diff --git a/test/compile_errors/stage1/obj/compile-time_division_by_zero.zig b/test/compile_errors/stage1/obj/compile-time_division_by_zero.zig
deleted file mode 100644
index e16f5f8cf40daa97aa8da6e62898055520129cc3..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/compile-time_division_by_zero.zig
+++ /dev/null
@@ -1,12 +0,0 @@
-comptime {
-    const a: i32 = 1;
-    const b: i32 = 0;
-    const c = a / b;
-    _ = c;
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:4:17: error: division by zero
diff --git a/test/compile_errors/stage1/obj/compile-time_remainder_division_by_zero.zig b/test/compile_errors/stage1/obj/compile-time_remainder_division_by_zero.zig
deleted file mode 100644
index 63f0def52c1e50e85118461ba84a00e30559ce31..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/compile-time_remainder_division_by_zero.zig
+++ /dev/null
@@ -1,12 +0,0 @@
-comptime {
-    const a: i32 = 1;
-    const b: i32 = 0;
-    const c = a % b;
-    _ = c;
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:4:17: error: division by zero
diff --git a/test/compile_errors/stage1/obj/compileError_shows_traceback_of_references_that_caused_it.zig b/test/compile_errors/stage1/obj/compileError_shows_traceback_of_references_that_caused_it.zig
deleted file mode 100644
index c58e9b77680998a77442bc2900d396b5337df346..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/compileError_shows_traceback_of_references_that_caused_it.zig
+++ /dev/null
@@ -1,14 +0,0 @@
-const foo = @compileError("aoeu",);
-
-const bar = baz + foo;
-const baz = 1;
-
-export fn entry() i32 {
-    return bar;
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:1:13: error: aoeu
diff --git a/test/compile_errors/stage1/obj/compileLog_of_tagged_enum_doesnt_crash_the_compiler.zig b/test/compile_errors/stage1/obj/compileLog_of_tagged_enum_doesnt_crash_the_compiler.zig
deleted file mode 100644
index 36e1ee111850e05b7be54c3017c49bbc61d94205..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/compileLog_of_tagged_enum_doesnt_crash_the_compiler.zig
+++ /dev/null
@@ -1,17 +0,0 @@
-const Bar = union(enum(u32)) {
-    X: i32 = 1
-};
-
-fn testCompileLog(x: Bar) void {
-    @compileLog(x);
-}
-
-pub fn main () void {
-    comptime testCompileLog(Bar{.X = 123});
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:6:5: error: found compile log statement
diff --git a/test/compile_errors/stage1/obj/compile_error_in_struct_init_expression.zig b/test/compile_errors/stage1/obj/compile_error_in_struct_init_expression.zig
deleted file mode 100644
index 041d09b0026eff658af85697258f1bfcd6abcfdb..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/compile_error_in_struct_init_expression.zig
+++ /dev/null
@@ -1,16 +0,0 @@
-const Foo = struct {
-    a: i32 = crap,
-    b: i32,
-};
-export fn entry() void {
-    var x = Foo{
-        .b = 5,
-    };
-    _ = x;
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:2:14: error: use of undeclared identifier 'crap'
diff --git a/test/compile_errors/stage1/obj/compile_error_when_evaluating_return_type_of_inferred_error_set.zig b/test/compile_errors/stage1/obj/compile_error_when_evaluating_return_type_of_inferred_error_set.zig
deleted file mode 100644
index 7b1d11b0a43962a9af927bd4e6b719142cc8e8b3..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/compile_error_when_evaluating_return_type_of_inferred_error_set.zig
+++ /dev/null
@@ -1,14 +0,0 @@
-const Car = struct {
-    foo: *SymbolThatDoesNotExist,
-    pub fn init() !Car {}
-};
-export fn entry() void {
-    const car = Car.init();
-    _ = car;
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:2:11: error: use of undeclared identifier 'SymbolThatDoesNotExist'
diff --git a/test/compile_errors/stage1/obj/compile_log.zig b/test/compile_errors/stage1/obj/compile_log.zig
deleted file mode 100644
index 7f5d52240769afe7e61eb9f70ed52ef8f9c6f6fb..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/compile_log.zig
+++ /dev/null
@@ -1,16 +0,0 @@
-export fn foo() void {
-    comptime bar(12, "hi",);
-}
-fn bar(a: i32, b: []const u8) void {
-    @compileLog("begin",);
-    @compileLog("a", a, "b", b);
-    @compileLog("end",);
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:5:5: error: found compile log statement
-// tmp.zig:6:5: error: found compile log statement
-// tmp.zig:7:5: error: found compile log statement
diff --git a/test/compile_errors/stage1/obj/compile_log_a_pointer_to_an_opaque_value.zig b/test/compile_errors/stage1/obj/compile_log_a_pointer_to_an_opaque_value.zig
deleted file mode 100644
index d585712b8ac4752808d6ade84a270bb917b250fd..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/compile_log_a_pointer_to_an_opaque_value.zig
+++ /dev/null
@@ -1,9 +0,0 @@
-export fn entry() void {
-    @compileLog(@ptrCast(*const anyopaque, &entry));
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:2:5: error: found compile log statement
diff --git a/test/compile_errors/stage1/obj/compile_log_statement_inside_function_which_must_be_comptime_evaluated.zig b/test/compile_errors/stage1/obj/compile_log_statement_inside_function_which_must_be_comptime_evaluated.zig
deleted file mode 100644
index 19b96048cb90dd9857a26f57ee8a77e8d757edf7..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/compile_log_statement_inside_function_which_must_be_comptime_evaluated.zig
+++ /dev/null
@@ -1,14 +0,0 @@
-fn Foo(comptime T: type) type {
-    @compileLog(@typeName(T));
-    return T;
-}
-export fn entry() void {
-    _ = Foo(i32);
-    _ = @typeName(Foo(i32));
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:2:5: error: found compile log statement
diff --git a/test/compile_errors/stage1/obj/compile_log_statement_warning_deduplication_in_generic_fn.zig b/test/compile_errors/stage1/obj/compile_log_statement_warning_deduplication_in_generic_fn.zig
deleted file mode 100644
index 991021932de33be551079056aae4ee8060183a7d..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/compile_log_statement_warning_deduplication_in_generic_fn.zig
+++ /dev/null
@@ -1,14 +0,0 @@
-export fn entry() void {
-    inner(1);
-    inner(2);
-}
-fn inner(comptime n: usize) void {
-    comptime var i = 0;
-    inline while (i < n) : (i += 1) { @compileLog("!@#$"); }
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:7:39: error: found compile log statement
diff --git a/test/compile_errors/stage1/obj/compile_time_division_by_zero.zig b/test/compile_errors/stage1/obj/compile_time_division_by_zero.zig
deleted file mode 100644
index 7f7e168f027cc4221584ed770602b8a86b937c7a..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/compile_time_division_by_zero.zig
+++ /dev/null
@@ -1,12 +0,0 @@
-const y = foo(0);
-fn foo(x: u32) u32 {
-    return 1 / x;
-}
-
-export fn entry() usize { return @sizeOf(@TypeOf(y)); }
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:3:14: error: division by zero
diff --git a/test/compile_errors/stage1/obj/comptime_cast_enum_to_union_but_field_has_payload.zig b/test/compile_errors/stage1/obj/comptime_cast_enum_to_union_but_field_has_payload.zig
deleted file mode 100644
index c3cf9e76e5029a8d274d43ddfecfc2e12dd40b70..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/comptime_cast_enum_to_union_but_field_has_payload.zig
+++ /dev/null
@@ -1,17 +0,0 @@
-const Letter = enum { A, B, C };
-const Value = union(Letter) {
-    A: i32,
-    B,
-    C,
-};
-export fn entry() void {
-    var x: Value = Letter.A;
-    _ = x;
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:8:26: error: cast to union 'Value' must initialize 'i32' field 'A'
-// tmp.zig:3:5: note: field 'A' declared here
diff --git a/test/compile_errors/stage1/obj/comptime_continue_inside_runtime_catch.zig b/test/compile_errors/stage1/obj/comptime_continue_inside_runtime_catch.zig
deleted file mode 100644
index 7eefeb80b4a1f31c3855d85811752a4e970ee104..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/comptime_continue_inside_runtime_catch.zig
+++ /dev/null
@@ -1,16 +0,0 @@
-export fn entry() void {
-    const ints = [_]u8{ 1, 2 };
-    inline for (ints) |_| {
-        bad() catch continue;
-    }
-}
-fn bad() !void {
-    return error.Bad;
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:4:21: error: comptime control flow inside runtime block
-// tmp.zig:4:15: note: runtime block created here
diff --git a/test/compile_errors/stage1/obj/comptime_continue_inside_runtime_if_bool.zig b/test/compile_errors/stage1/obj/comptime_continue_inside_runtime_if_bool.zig
deleted file mode 100644
index 9ace5ddceb6513056031aa183fdcff5070c31245..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/comptime_continue_inside_runtime_if_bool.zig
+++ /dev/null
@@ -1,15 +0,0 @@
-export fn entry() void {
-    var p: usize = undefined;
-    comptime var q = true;
-    inline while (q) {
-        if (p == 11) continue;
-        q = false;
-    }
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:5:22: error: comptime control flow inside runtime block
-// tmp.zig:5:9: note: runtime block created here
diff --git a/test/compile_errors/stage1/obj/comptime_continue_inside_runtime_if_error.zig b/test/compile_errors/stage1/obj/comptime_continue_inside_runtime_if_error.zig
deleted file mode 100644
index 554ba3c43e5ab55e5855acaf1a24269d87b85d77..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/comptime_continue_inside_runtime_if_error.zig
+++ /dev/null
@@ -1,15 +0,0 @@
-export fn entry() void {
-    var p: anyerror!i32 = undefined;
-    comptime var q = true;
-    inline while (q) {
-        if (p) |_| continue else |_| {}
-        q = false;
-    }
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:5:20: error: comptime control flow inside runtime block
-// tmp.zig:5:9: note: runtime block created here
diff --git a/test/compile_errors/stage1/obj/comptime_continue_inside_runtime_if_optional.zig b/test/compile_errors/stage1/obj/comptime_continue_inside_runtime_if_optional.zig
deleted file mode 100644
index 32c71e5c7751725196a0e809f43e369ff24dec41..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/comptime_continue_inside_runtime_if_optional.zig
+++ /dev/null
@@ -1,15 +0,0 @@
-export fn entry() void {
-    var p: ?i32 = undefined;
-    comptime var q = true;
-    inline while (q) {
-        if (p) |_| continue;
-        q = false;
-    }
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:5:20: error: comptime control flow inside runtime block
-// tmp.zig:5:9: note: runtime block created here
diff --git a/test/compile_errors/stage1/obj/comptime_continue_inside_runtime_switch.zig b/test/compile_errors/stage1/obj/comptime_continue_inside_runtime_switch.zig
deleted file mode 100644
index d145897b4167ff3892fcd35e0e87100759bbdcc2..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/comptime_continue_inside_runtime_switch.zig
+++ /dev/null
@@ -1,18 +0,0 @@
-export fn entry() void {
-    var p: i32 = undefined;
-    comptime var q = true;
-    inline while (q) {
-        switch (p) {
-            11 => continue,
-            else => {},
-        }
-        q = false;
-    }
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:6:19: error: comptime control flow inside runtime block
-// tmp.zig:5:9: note: runtime block created here
diff --git a/test/compile_errors/stage1/obj/comptime_continue_inside_runtime_while_bool.zig b/test/compile_errors/stage1/obj/comptime_continue_inside_runtime_while_bool.zig
deleted file mode 100644
index 8e57854728208344098e268d501647199e51106c..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/comptime_continue_inside_runtime_while_bool.zig
+++ /dev/null
@@ -1,15 +0,0 @@
-export fn entry() void {
-    var p: usize = undefined;
-    comptime var q = true;
-    outer: inline while (q) {
-        while (p == 11) continue :outer;
-        q = false;
-    }
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:5:25: error: comptime control flow inside runtime block
-// tmp.zig:5:9: note: runtime block created here
diff --git a/test/compile_errors/stage1/obj/comptime_continue_inside_runtime_while_error.zig b/test/compile_errors/stage1/obj/comptime_continue_inside_runtime_while_error.zig
deleted file mode 100644
index 818455c3540bb7ae27e552703411a5ce023540d2..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/comptime_continue_inside_runtime_while_error.zig
+++ /dev/null
@@ -1,17 +0,0 @@
-export fn entry() void {
-    var p: anyerror!usize = undefined;
-    comptime var q = true;
-    outer: inline while (q) {
-        while (p) |_| {
-            continue :outer;
-        } else |_| {}
-        q = false;
-    }
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:6:13: error: comptime control flow inside runtime block
-// tmp.zig:5:9: note: runtime block created here
diff --git a/test/compile_errors/stage1/obj/comptime_continue_inside_runtime_while_optional.zig b/test/compile_errors/stage1/obj/comptime_continue_inside_runtime_while_optional.zig
deleted file mode 100644
index ed22cc2cacc6573104293ab240be3e39413303ed..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/comptime_continue_inside_runtime_while_optional.zig
+++ /dev/null
@@ -1,15 +0,0 @@
-export fn entry() void {
-    var p: ?usize = undefined;
-    comptime var q = true;
-    outer: inline while (q) {
-        while (p) |_| continue :outer;
-        q = false;
-    }
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:5:23: error: comptime control flow inside runtime block
-// tmp.zig:5:9: note: runtime block created here
diff --git a/test/compile_errors/stage1/obj/comptime_float_in_asm_input.zig b/test/compile_errors/stage1/obj/comptime_float_in_asm_input.zig
deleted file mode 100644
index 92ffadc4f7b6431ae6985ae0e6ae45932c2be649..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/comptime_float_in_asm_input.zig
+++ /dev/null
@@ -1,9 +0,0 @@
-export fn foo() void {
-    asm volatile ("" : : [bar]"r"(3.17) : "");
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:2:35: error: expected sized integer or sized float, found comptime_float
diff --git a/test/compile_errors/stage1/obj/comptime_implicit_cast_f64_to_f32.zig b/test/compile_errors/stage1/obj/comptime_implicit_cast_f64_to_f32.zig
deleted file mode 100644
index af5d49c7cbf4a139206d2493864621b4dea3edd8..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/comptime_implicit_cast_f64_to_f32.zig
+++ /dev/null
@@ -1,11 +0,0 @@
-export fn entry() void {
-    const x: f64 = 16777217;
-    const y: f32 = x;
-    _ = y;
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:3:20: error: cast of value 16777217.000000 to type 'f32' loses information
diff --git a/test/compile_errors/stage1/obj/comptime_int_in_asm_input.zig b/test/compile_errors/stage1/obj/comptime_int_in_asm_input.zig
deleted file mode 100644
index 3e3ccf8c2738073424d8e735b2f9ed14edc0a6dc..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/comptime_int_in_asm_input.zig
+++ /dev/null
@@ -1,9 +0,0 @@
-export fn foo() void {
-    asm volatile ("" : : [bar]"r"(3) : "");
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:2:35: error: expected sized integer or sized float, found comptime_int
diff --git a/test/compile_errors/stage1/obj/comptime_ptrcast_of_zero-sized_type.zig b/test/compile_errors/stage1/obj/comptime_ptrcast_of_zero-sized_type.zig
deleted file mode 100644
index 231e735cfa4d58e356123505bb6c8f7134146963..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/comptime_ptrcast_of_zero-sized_type.zig
+++ /dev/null
@@ -1,12 +0,0 @@
-fn foo() void {
-    const node: struct {} = undefined;
-    const vla_ptr = @ptrCast([*]const u8, &node);
-    _ = vla_ptr;
-}
-comptime { foo(); }
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:3:21: error: '*const struct:2:17' and '[*]const u8' do not have the same in-memory representation
diff --git a/test/compile_errors/stage1/obj/comptime_slice-sentinel_does_not_match_memory_at_target_index_terminated.zig b/test/compile_errors/stage1/obj/comptime_slice-sentinel_does_not_match_memory_at_target_index_terminated.zig
deleted file mode 100644
index 598d23a305ba1c9e28f9f1e8fd2379ebbc5a3863..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/comptime_slice-sentinel_does_not_match_memory_at_target_index_terminated.zig
+++ /dev/null
@@ -1,67 +0,0 @@
-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 {
-    comptime {
-        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 {
-    comptime {
-        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 {
-    comptime {
-        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 {
-    comptime {
-        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 {
-    comptime {
-        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 {
-    comptime {
-        var buf = [_:0]u8{ 'a', 'b', 'c', 'd' } ++ [_]u8{undefined} ** 10;
-        var target: []u8 = &buf;
-        const slice = target[0..3 :0];
-        _ = slice;
-    }
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// :4:29: error: slice-sentinel does not match memory at target index
-// :12:29: error: slice-sentinel does not match memory at target index
-// :20:29: error: slice-sentinel does not match memory at target index
-// :28:29: error: slice-sentinel does not match memory at target index
-// :36:29: error: slice-sentinel does not match memory at target index
-// :44:29: error: slice-sentinel does not match memory at target index
-// :52:29: error: slice-sentinel does not match memory at target index
diff --git a/test/compile_errors/stage1/obj/comptime_slice-sentinel_does_not_match_memory_at_target_index_unterminated.zig b/test/compile_errors/stage1/obj/comptime_slice-sentinel_does_not_match_memory_at_target_index_unterminated.zig
deleted file mode 100644
index d6b469aaf164d55a85c886799aff7cb033866391..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/comptime_slice-sentinel_does_not_match_memory_at_target_index_unterminated.zig
+++ /dev/null
@@ -1,67 +0,0 @@
-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 {
-    comptime {
-        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 {
-    comptime {
-        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 {
-    comptime {
-        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 {
-    comptime {
-        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 {
-    comptime {
-        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 {
-    comptime {
-        var buf = [_]u8{ 'a', 'b', 'c', 'd' } ++ [_]u8{undefined} ** 10;
-        var target: []u8 = &buf;
-        const slice = target[0..3 :0];
-        _ = slice;
-    }
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// :4:29: error: slice-sentinel does not match memory at target index
-// :12:29: error: slice-sentinel does not match memory at target index
-// :20:29: error: slice-sentinel does not match memory at target index
-// :28:29: error: slice-sentinel does not match memory at target index
-// :36:29: error: slice-sentinel does not match memory at target index
-// :44:29: error: slice-sentinel does not match memory at target index
-// :52:29: error: slice-sentinel does not match memory at target index
diff --git a/test/compile_errors/stage1/obj/comptime_slice-sentinel_does_not_match_target-sentinel.zig b/test/compile_errors/stage1/obj/comptime_slice-sentinel_does_not_match_target-sentinel.zig
deleted file mode 100644
index b204cfc6840d6bc557585665348883f063e63730..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/comptime_slice-sentinel_does_not_match_target-sentinel.zig
+++ /dev/null
@@ -1,67 +0,0 @@
-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 {
-    comptime {
-        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 {
-    comptime {
-        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 {
-    comptime {
-        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 {
-    comptime {
-        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 {
-    comptime {
-        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 {
-    comptime {
-        var buf = [_:0]u8{ 'a', 'b', 'c', 'd' } ++ [_]u8{undefined} ** 10;
-        var target: []u8 = &buf;
-        const slice = target[0..14 :255];
-        _ = slice;
-    }
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// :4:29: error: slice-sentinel does not match target-sentinel
-// :12:29: error: slice-sentinel does not match target-sentinel
-// :20:29: error: slice-sentinel does not match target-sentinel
-// :28:29: error: slice-sentinel does not match target-sentinel
-// :36:29: error: slice-sentinel does not match target-sentinel
-// :44:29: error: slice-sentinel does not match target-sentinel
-// :52:29: error: slice-sentinel does not match target-sentinel
diff --git a/test/compile_errors/stage1/obj/comptime_slice-sentinel_is_out_of_bounds_terminated.zig b/test/compile_errors/stage1/obj/comptime_slice-sentinel_is_out_of_bounds_terminated.zig
deleted file mode 100644
index 82c19126c0bc97729cde29149e6fa79e0c099e44..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/comptime_slice-sentinel_is_out_of_bounds_terminated.zig
+++ /dev/null
@@ -1,67 +0,0 @@
-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 {
-    comptime {
-        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 {
-    comptime {
-        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 {
-    comptime {
-        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 {
-    comptime {
-        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 {
-    comptime {
-        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 {
-    comptime {
-        var buf = [_:0]u8{ 'a', 'b', 'c', 'd' } ++ [_]u8{undefined} ** 10;
-        var target: []u8 = &buf;
-        const slice = target[0..15 :0];
-        _ = slice;
-    }
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// :4:29: error: out of bounds slice
-// :12:29: error: out of bounds slice
-// :20:29: error: out of bounds slice
-// :28:29: error: out of bounds slice
-// :36:29: error: out of bounds slice
-// :44:29: error: out of bounds slice
-// :52:29: error: out of bounds slice
diff --git a/test/compile_errors/stage1/obj/comptime_slice-sentinel_is_out_of_bounds_unterminated.zig b/test/compile_errors/stage1/obj/comptime_slice-sentinel_is_out_of_bounds_unterminated.zig
deleted file mode 100644
index 952b17600a80e7b4503152802cb5a930ddc05634..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/comptime_slice-sentinel_is_out_of_bounds_unterminated.zig
+++ /dev/null
@@ -1,67 +0,0 @@
-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 {
-    comptime {
-        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 {
-    comptime {
-        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 {
-    comptime {
-        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 {
-    comptime {
-        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 {
-    comptime {
-        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 {
-    comptime {
-        var buf = [_]u8{ 'a', 'b', 'c', 'd' } ++ [_]u8{undefined} ** 10;
-        var target: []u8 = &buf;
-        const slice = target[0..14 :0];
-        _ = slice;
-    }
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// :4:29: error: slice-sentinel is out of bounds
-// :12:29: error: slice-sentinel is out of bounds
-// :20:29: error: slice-sentinel is out of bounds
-// :28:29: error: slice-sentinel is out of bounds
-// :36:29: error: slice-sentinel is out of bounds
-// :44:29: error: slice-sentinel is out of bounds
-// :52:29: error: slice-sentinel is out of bounds
diff --git a/test/compile_errors/stage1/obj/comptime_slice_of_an_undefined_slice.zig b/test/compile_errors/stage1/obj/comptime_slice_of_an_undefined_slice.zig
deleted file mode 100644
index 4aa519f41ee031d2f7a103ab5505cfde1a887599..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/comptime_slice_of_an_undefined_slice.zig
+++ /dev/null
@@ -1,11 +0,0 @@
-comptime {
-    var a: []u8 = undefined;
-    var b = a[0..10];
-    _ = b;
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:3:14: error: slice of undefined
diff --git a/test/compile_errors/stage1/obj/comptime_slice_of_undefined_pointer_non-zero_len.zig b/test/compile_errors/stage1/obj/comptime_slice_of_undefined_pointer_non-zero_len.zig
deleted file mode 100644
index ec7fbdc6e2d7f8badd0fbae6c4ee71d245cbef64..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/comptime_slice_of_undefined_pointer_non-zero_len.zig
+++ /dev/null
@@ -1,10 +0,0 @@
-export fn entry() void {
-    const slice = @as([*]i32, undefined)[0..1];
-    _ = slice;
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:2:41: error: non-zero length slice of undefined pointer
diff --git a/test/compile_errors/stage1/obj/comptime_struct_field_no_init_value.zig b/test/compile_errors/stage1/obj/comptime_struct_field_no_init_value.zig
deleted file mode 100644
index b889911a4dcf253ec2e00941ef50e47494a93717..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/comptime_struct_field_no_init_value.zig
+++ /dev/null
@@ -1,13 +0,0 @@
-const Foo = struct {
-    comptime b: i32,
-};
-export fn entry() void {
-    var f: Foo = undefined;
-    _ = f;
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:2:5: error: comptime field without default initialization value
diff --git a/test/compile_errors/stage1/obj/const_frame_cast_to_anyframe.zig b/test/compile_errors/stage1/obj/const_frame_cast_to_anyframe.zig
deleted file mode 100644
index affdb953d72f317ea094a806b6c08aa05c135256..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/const_frame_cast_to_anyframe.zig
+++ /dev/null
@@ -1,19 +0,0 @@
-export fn a() void {
-    const f = async func();
-    resume f;
-}
-export fn b() void {
-    const f = async func();
-    var x: anyframe = &f;
-    _ = x;
-}
-fn func() void {
-    suspend {}
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:3:12: error: expected type 'anyframe', found '*const @Frame(func)'
-// tmp.zig:7:24: error: expected type 'anyframe', found '*const @Frame(func)'
diff --git a/test/compile_errors/stage1/obj/const_is_a_statement_not_an_expression.zig b/test/compile_errors/stage1/obj/const_is_a_statement_not_an_expression.zig
deleted file mode 100644
index b90878abeb653a690cc8e018f9c6fd5f8a13d9f2..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/const_is_a_statement_not_an_expression.zig
+++ /dev/null
@@ -1,9 +0,0 @@
-export fn f() void {
-    (const a = 0);
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:2:6: error: expected expression, found 'const'
diff --git a/test/compile_errors/stage1/obj/container_init_with_non-type.zig b/test/compile_errors/stage1/obj/container_init_with_non-type.zig
deleted file mode 100644
index 3364b2f5b61e1f08e1ca3e0b28b2355a069eaba5..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/container_init_with_non-type.zig
+++ /dev/null
@@ -1,10 +0,0 @@
-const zero: i32 = 0;
-const a = zero{1};
-
-export fn entry() usize { return @sizeOf(@TypeOf(a)); }
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:2:11: error: expected type 'type', found 'i32'
diff --git a/test/compile_errors/stage1/obj/control_flow_uses_comptime_var_at_runtime.zig b/test/compile_errors/stage1/obj/control_flow_uses_comptime_var_at_runtime.zig
deleted file mode 100644
index cb2c3e9f6eed4abb8a31959366ff92c7bbc6d6b8..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/control_flow_uses_comptime_var_at_runtime.zig
+++ /dev/null
@@ -1,15 +0,0 @@
-export fn foo() void {
-    comptime var i = 0;
-    while (i < 5) : (i += 1) {
-        bar();
-    }
-}
-
-fn bar() void { }
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:3:5: error: control flow attempts to use compile-time variable at runtime
-// tmp.zig:3:24: note: compile-time variable assigned here
diff --git a/test/compile_errors/stage1/obj/control_reaches_end_of_non-void_function.zig b/test/compile_errors/stage1/obj/control_reaches_end_of_non-void_function.zig
deleted file mode 100644
index e15c1bd40bcb827a1d99c629de9f9ecc381cccde..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/control_reaches_end_of_non-void_function.zig
+++ /dev/null
@@ -1,8 +0,0 @@
-fn a() i32 {}
-export fn entry() void { _ = a(); }
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:1:12: error: expected type 'i32', found 'void'
diff --git a/test/compile_errors/stage1/obj/declaration_between_fields.zig b/test/compile_errors/stage1/obj/declaration_between_fields.zig
deleted file mode 100644
index 25a1ff5abc7450a896cdd73605b2b6d523f12d78..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/declaration_between_fields.zig
+++ /dev/null
@@ -1,24 +0,0 @@
-const S = struct {
-    const foo = 2;
-    const bar = 2;
-    const baz = 2;
-    a: struct {
-        a: u32,
-        b: u32,
-    },
-    const foo1 = 2;
-    const bar1 = 2;
-    const baz1 = 2;
-    b: usize,
-};
-comptime {
-    _ = S;
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:9:5: error: declarations are not allowed between container fields
-// tmp.zig:5:5: note: field before declarations here
-// tmp.zig:12:5: note: field after declarations here
diff --git a/test/compile_errors/stage1/obj/declaration_with_same_name_as_primitive_must_use_special_syntax.zig b/test/compile_errors/stage1/obj/declaration_with_same_name_as_primitive_must_use_special_syntax.zig
deleted file mode 100644
index 46b0257ed5673fa2e417dd0ac159ad736f33ec7d..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/declaration_with_same_name_as_primitive_must_use_special_syntax.zig
+++ /dev/null
@@ -1,12 +0,0 @@
-const u8 = u16;
-export fn entry() void {
-    const a: u8 = 300;
-    _ = a;
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:1:7: error: name shadows primitive 'u8'
-// tmp.zig:1:7: note: consider using @"u8" to disambiguate
diff --git a/test/compile_errors/stage1/obj/deduplicate_undeclared_identifier.zig b/test/compile_errors/stage1/obj/deduplicate_undeclared_identifier.zig
deleted file mode 100644
index 1e3b3bf6db35bab027549f97f8d93b781541eee6..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/deduplicate_undeclared_identifier.zig
+++ /dev/null
@@ -1,12 +0,0 @@
-export fn a() void {
-    x += 1;
-}
-export fn b() void {
-    x += 1;
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:2:5: error: use of undeclared identifier 'x'
diff --git a/test/compile_errors/stage1/obj/deref_on_undefined_value.zig b/test/compile_errors/stage1/obj/deref_on_undefined_value.zig
deleted file mode 100644
index f64d567a26c242685a23f91fb3752134f97b4940..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/deref_on_undefined_value.zig
+++ /dev/null
@@ -1,10 +0,0 @@
-comptime {
-    var a: *u8 = undefined;
-    _ = a.*;
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:3:9: error: attempt to dereference undefined value
diff --git a/test/compile_errors/stage1/obj/deref_slice_and_get_len_field.zig b/test/compile_errors/stage1/obj/deref_slice_and_get_len_field.zig
deleted file mode 100644
index 98097597cc8f4db61359dd8b2751a63edd4c3dd0..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/deref_slice_and_get_len_field.zig
+++ /dev/null
@@ -1,10 +0,0 @@
-export fn entry() void {
-    var a: []u8 = undefined;
-    _ = a.*.len;
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:3:10: error: attempt to dereference non-pointer type '[]u8'
diff --git a/test/compile_errors/stage1/obj/dereference_an_array.zig b/test/compile_errors/stage1/obj/dereference_an_array.zig
deleted file mode 100644
index 0dd91f70e53aa347ea69ddd58c570dc119e0aa65..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/dereference_an_array.zig
+++ /dev/null
@@ -1,14 +0,0 @@
-var s_buffer: [10]u8 = undefined;
-pub fn pass(in: []u8) []u8 {
-    var out = &s_buffer;
-    out.*.* = in[0];
-    return out.*[0..1];
-}
-
-export fn entry() usize { return @sizeOf(@TypeOf(pass)); }
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:4:10: error: attempt to dereference non-pointer type '[10]u8'
diff --git a/test/compile_errors/stage1/obj/dereference_unknown_length_pointer.zig b/test/compile_errors/stage1/obj/dereference_unknown_length_pointer.zig
deleted file mode 100644
index c305e4bc98abcae6029bd64f708e8ecf2b022a5b..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/dereference_unknown_length_pointer.zig
+++ /dev/null
@@ -1,9 +0,0 @@
-export fn entry(x: [*]i32) i32 {
-    return x.*;
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:2:13: error: index syntax required for unknown-length pointer type '[*]i32'
diff --git a/test/compile_errors/stage1/obj/direct_struct_loop.zig b/test/compile_errors/stage1/obj/direct_struct_loop.zig
deleted file mode 100644
index 3062e617d68ab393aa0238d4575a3c48667fba59..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/direct_struct_loop.zig
+++ /dev/null
@@ -1,8 +0,0 @@
-const A = struct { a : A, };
-export fn entry() usize { return @sizeOf(A); }
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:1:11: error: struct 'A' depends on itself
diff --git a/test/compile_errors/stage1/obj/directly_embedding_opaque_type_in_struct_and_union.zig b/test/compile_errors/stage1/obj/directly_embedding_opaque_type_in_struct_and_union.zig
deleted file mode 100644
index 8b8d84ad2a649ca8977b02a04a50fa88d0fa38d9..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/directly_embedding_opaque_type_in_struct_and_union.zig
+++ /dev/null
@@ -1,29 +0,0 @@
-const O = opaque {};
-const Foo = struct {
-    o: O,
-};
-const Bar = union {
-    One: i32,
-    Two: O,
-};
-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;
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// 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:19:22: error: opaque types have unknown size and therefore cannot be directly embedded in structs
diff --git a/test/compile_errors/stage1/obj/disallow_coercion_from_non-null-terminated_pointer_to_null-terminated_pointer.zig b/test/compile_errors/stage1/obj/disallow_coercion_from_non-null-terminated_pointer_to_null-terminated_pointer.zig
deleted file mode 100644
index 1d0a6216dde20f319ede3315fbd986f4ccd01aa0..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/disallow_coercion_from_non-null-terminated_pointer_to_null-terminated_pointer.zig
+++ /dev/null
@@ -1,12 +0,0 @@
-extern fn puts(s: [*:0]const u8) c_int;
-pub fn main() void {
-    const no_zero_array = [_]u8{'h', 'e', 'l', 'l', 'o'};
-    const no_zero_ptr: [*]const u8 = &no_zero_array;
-    _ = puts(no_zero_ptr);
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:5:14: error: expected type '[*:0]const u8', found '[*]const u8'
diff --git a/test/compile_errors/stage1/obj/discarding_error_value.zig b/test/compile_errors/stage1/obj/discarding_error_value.zig
deleted file mode 100644
index dcfa22e8cb3412e1b2741267973eca6d9e3c3884..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/discarding_error_value.zig
+++ /dev/null
@@ -1,12 +0,0 @@
-export fn entry() void {
-    _ = foo();
-}
-fn foo() !void {
-    return error.OutOfMemory;
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:2:12: error: error is discarded. consider using `try`, `catch`, or `if`
diff --git a/test/compile_errors/stage1/obj/div_assign_on_undefined_value.zig b/test/compile_errors/stage1/obj/div_assign_on_undefined_value.zig
deleted file mode 100644
index 5f18e6286a27390aa974a1c493dd55ccf5de63a6..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/div_assign_on_undefined_value.zig
+++ /dev/null
@@ -1,10 +0,0 @@
-comptime {
-    var a: i64 = undefined;
-    a /= a;
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:3:5: error: use of undefined value here causes undefined behavior
diff --git a/test/compile_errors/stage1/obj/div_on_undefined_value.zig b/test/compile_errors/stage1/obj/div_on_undefined_value.zig
deleted file mode 100644
index 9857b1c77981d947f731c13c8411d215a8a84f80..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/div_on_undefined_value.zig
+++ /dev/null
@@ -1,10 +0,0 @@
-comptime {
-    var a: i64 = undefined;
-    _ = a / a;
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:3:9: error: use of undefined value here causes undefined behavior
diff --git a/test/compile_errors/stage1/obj/division_by_zero.zig b/test/compile_errors/stage1/obj/division_by_zero.zig
deleted file mode 100644
index 3023f0c6f3f729891880630b31d43754fc1957ed..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/division_by_zero.zig
+++ /dev/null
@@ -1,18 +0,0 @@
-const lit_int_x = 1 / 0;
-const lit_float_x = 1.0 / 0.0;
-const int_x = @as(u32, 1) / @as(u32, 0);
-const float_x = @as(f32, 1.0) / @as(f32, 0.0);
-
-export fn entry1() usize { return @sizeOf(@TypeOf(lit_int_x)); }
-export fn entry2() usize { return @sizeOf(@TypeOf(lit_float_x)); }
-export fn entry3() usize { return @sizeOf(@TypeOf(int_x)); }
-export fn entry4() usize { return @sizeOf(@TypeOf(float_x)); }
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:1:21: error: division by zero
-// tmp.zig:2:25: error: division by zero
-// tmp.zig:3:27: error: division by zero
-// tmp.zig:4:31: error: division by zero
diff --git a/test/compile_errors/stage1/obj/dont_implicit_cast_double_pointer_to_anyopaque.zig b/test/compile_errors/stage1/obj/dont_implicit_cast_double_pointer_to_anyopaque.zig
deleted file mode 100644
index f61dec2ee07f86f50a1188d1e8d50697cf997892..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/dont_implicit_cast_double_pointer_to_anyopaque.zig
+++ /dev/null
@@ -1,13 +0,0 @@
-export fn entry() void {
-    var a: u32 = 1;
-    var ptr: *align(@alignOf(u32)) anyopaque = &a;
-    var b: *u32 = @ptrCast(*u32, ptr);
-    var ptr2: *anyopaque = &b;
-    _ = ptr2;
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:5:29: error: expected type '*anyopaque', found '**u32'
diff --git a/test/compile_errors/stage1/obj/double_optional_on_main_return_value.zig b/test/compile_errors/stage1/obj/double_optional_on_main_return_value.zig
deleted file mode 100644
index c61ac400baf048c781f0bee5a4d779696d7583ec..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/double_optional_on_main_return_value.zig
+++ /dev/null
@@ -1,8 +0,0 @@
-pub fn main() ??void {
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// error: expected return type of main to be 'void', '!void', 'noreturn', 'u8', or '!u8'
diff --git a/test/compile_errors/stage1/obj/duplicate_boolean_switch_value.zig b/test/compile_errors/stage1/obj/duplicate_boolean_switch_value.zig
deleted file mode 100644
index 5b85c0a2eb93e20680e5dbc78b27d0890ac37c96..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/duplicate_boolean_switch_value.zig
+++ /dev/null
@@ -1,23 +0,0 @@
-comptime {
-    const x = switch (true) {
-        true => false,
-        false => true,
-        true => false,
-    };
-    _ = x;
-}
-comptime {
-    const x = switch (true) {
-        false => true,
-        true => false,
-        false => true,
-    };
-    _ = x;
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:5:9: error: duplicate switch value
-// tmp.zig:13:9: error: duplicate switch value
diff --git a/test/compile_errors/stage1/obj/duplicate_enum_field.zig b/test/compile_errors/stage1/obj/duplicate_enum_field.zig
deleted file mode 100644
index cd024270bd10f18aefd50c91527404b236c7a45f..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/duplicate_enum_field.zig
+++ /dev/null
@@ -1,16 +0,0 @@
-const Foo = enum {
-    Bar,
-    Bar,
-};
-
-export fn entry() void {
-    const a: Foo = undefined;
-    _ = a;
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:3:5: error: duplicate enum field: 'Bar'
-// tmp.zig:2:5: note: other field here
diff --git a/test/compile_errors/stage1/obj/duplicate_error_in_switch.zig b/test/compile_errors/stage1/obj/duplicate_error_in_switch.zig
deleted file mode 100644
index 140a14ec81969d9d8eb5fb8d12cdce57c607fa09..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/duplicate_error_in_switch.zig
+++ /dev/null
@@ -1,22 +0,0 @@
-export fn entry() void {
-    foo(452) catch |err| switch (err) {
-        error.Foo => {},
-        error.Bar => {},
-        error.Foo => {},
-        else => {},
-    };
-}
-fn foo(x: i32) !void {
-    switch (x) {
-        0 ... 10 => return error.Foo,
-        11 ... 20 => return error.Bar,
-        else => {},
-    }
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// 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 here
diff --git a/test/compile_errors/stage1/obj/duplicate_error_value_in_error_set.zig b/test/compile_errors/stage1/obj/duplicate_error_value_in_error_set.zig
deleted file mode 100644
index 30d3bee8ab9d8f3dbb4ac1f6f0e1191fbade1a8f..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/duplicate_error_value_in_error_set.zig
+++ /dev/null
@@ -1,15 +0,0 @@
-const Foo = error {
-    Bar,
-    Bar,
-};
-export fn entry() void {
-    const a: Foo = undefined;
-    _ = a;
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:3:5: error: duplicate error set field 'Bar'
-// tmp.zig:2:5: note: previous declaration here
diff --git a/test/compile_errors/stage1/obj/duplicate_field_in_struct_value_expression.zig b/test/compile_errors/stage1/obj/duplicate_field_in_struct_value_expression.zig
deleted file mode 100644
index 1c0bac75e2ee9b1ab3a8173dd41059e83379ee7f..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/duplicate_field_in_struct_value_expression.zig
+++ /dev/null
@@ -1,20 +0,0 @@
-const A = struct {
-    x : i32,
-    y : i32,
-    z : i32,
-};
-export fn f() void {
-    const a = A {
-        .z = 1,
-        .y = 2,
-        .x = 3,
-        .z = 4,
-    };
-    _ = a;
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:11:9: error: duplicate field
diff --git a/test/compile_errors/stage1/obj/duplicate_struct_field.zig b/test/compile_errors/stage1/obj/duplicate_struct_field.zig
deleted file mode 100644
index 93afdef70eded4469ec9def53b25ab34a43f7836..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/duplicate_struct_field.zig
+++ /dev/null
@@ -1,15 +0,0 @@
-const Foo = struct {
-    Bar: i32,
-    Bar: usize,
-};
-export fn entry() void {
-    const a: Foo = undefined;
-    _ = a;
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:3:5: error: duplicate struct field: 'Bar'
-// tmp.zig:2:5: note: other field here
diff --git a/test/compile_errors/stage1/obj/duplicate_union_field.zig b/test/compile_errors/stage1/obj/duplicate_union_field.zig
deleted file mode 100644
index 5cbdcb7820a6559e19cd613c45aa52d41d7a76b2..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/duplicate_union_field.zig
+++ /dev/null
@@ -1,15 +0,0 @@
-const Foo = union {
-    Bar: i32,
-    Bar: usize,
-};
-export fn entry() void {
-    const a: Foo = undefined;
-    _ = a;
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:3:5: error: duplicate union field: 'Bar'
-// tmp.zig:2:5: note: other field here
diff --git a/test/compile_errors/stage1/obj/embedFile_with_bogus_file.zig b/test/compile_errors/stage1/obj/embedFile_with_bogus_file.zig
deleted file mode 100644
index a03949b40a4295082f15b68c348738d89cb42f18..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/embedFile_with_bogus_file.zig
+++ /dev/null
@@ -1,9 +0,0 @@
-const resource = @embedFile("bogus.txt",);
-
-export fn entry() usize { return @sizeOf(@TypeOf(resource)); }
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:1:29: error: unable to find '
diff --git a/test/compile_errors/stage1/obj/empty_for_loop_body.zig b/test/compile_errors/stage1/obj/empty_for_loop_body.zig
deleted file mode 100644
index b824c9313181ebd36819aedf1bb1d5f942652743..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/empty_for_loop_body.zig
+++ /dev/null
@@ -1,9 +0,0 @@
-export fn a() void {
-    for(undefined) |x|;
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:2:23: error: expected block or assignment, found ';'
diff --git a/test/compile_errors/stage1/obj/empty_if_body.zig b/test/compile_errors/stage1/obj/empty_if_body.zig
deleted file mode 100644
index 0a7b5b1b8b70a0ab536c4ca97516be800b3b0fab..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/empty_if_body.zig
+++ /dev/null
@@ -1,9 +0,0 @@
-export fn a() void {
-    if(true);
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:2:13: error: expected block or assignment, found ';'
diff --git a/test/compile_errors/stage1/obj/empty_switch_on_an_integer.zig b/test/compile_errors/stage1/obj/empty_switch_on_an_integer.zig
deleted file mode 100644
index a7b8e2a81bd47da183d12713a52efa068450c53d..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/empty_switch_on_an_integer.zig
+++ /dev/null
@@ -1,10 +0,0 @@
-export fn entry() void {
-    var x: u32 = 0;
-    switch(x) {}
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:3:5: error: switch must handle all possibilities
diff --git a/test/compile_errors/stage1/obj/empty_while_loop_body.zig b/test/compile_errors/stage1/obj/empty_while_loop_body.zig
deleted file mode 100644
index 01b21325188cec26a31063713b72f16f7bde2d26..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/empty_while_loop_body.zig
+++ /dev/null
@@ -1,9 +0,0 @@
-export fn a() void {
-    while(true);
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:2:16: error: expected block or assignment, found ';'
diff --git a/test/compile_errors/stage1/obj/endless_loop_in_function_evaluation.zig b/test/compile_errors/stage1/obj/endless_loop_in_function_evaluation.zig
deleted file mode 100644
index 302ee242e094611b64e0dcbee97e895b06016c05..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/endless_loop_in_function_evaluation.zig
+++ /dev/null
@@ -1,12 +0,0 @@
-const seventh_fib_number = fibonacci(7);
-fn fibonacci(x: i32) i32 {
-    return fibonacci(x - 1) + fibonacci(x - 2);
-}
-
-export fn entry() usize { return @sizeOf(@TypeOf(seventh_fib_number)); }
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:3:21: error: evaluation exceeded 1000 backwards branches
diff --git a/test/compile_errors/stage1/obj/enum_field_value_references_enum.zig b/test/compile_errors/stage1/obj/enum_field_value_references_enum.zig
deleted file mode 100644
index ebf32db5e04242bfd89f4a4befda66f347f6451e..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/enum_field_value_references_enum.zig
+++ /dev/null
@@ -1,15 +0,0 @@
-pub const Foo = enum(c_int) {
-    A = Foo.B,
-    C = D,
-};
-export fn entry() void {
-    var s: Foo = Foo.E;
-    _ = s;
-}
-const D = 1;
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:1:17: error: enum 'Foo' depends on itself
diff --git a/test/compile_errors/stage1/obj/enum_in_field_count_range_but_not_matching_tag.zig b/test/compile_errors/stage1/obj/enum_in_field_count_range_but_not_matching_tag.zig
deleted file mode 100644
index e783cbee5293c2d755c32bd167a26e97528d1826..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/enum_in_field_count_range_but_not_matching_tag.zig
+++ /dev/null
@@ -1,15 +0,0 @@
-const Foo = enum(u32) {
-    A = 10,
-    B = 11,
-};
-export fn entry() void {
-    var x = @intToEnum(Foo, 0);
-    _ = x;
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:6:13: error: enum 'Foo' has no tag matching integer value 0
-// tmp.zig:1:13: note: 'Foo' declared here
diff --git a/test/compile_errors/stage1/obj/enum_value_already_taken.zig b/test/compile_errors/stage1/obj/enum_value_already_taken.zig
deleted file mode 100644
index 60e88f0062de86e0d1dad3064773dc338e1fd93c..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/enum_value_already_taken.zig
+++ /dev/null
@@ -1,18 +0,0 @@
-const MultipleChoice = enum(u32) {
-    A = 20,
-    B = 40,
-    C = 60,
-    D = 1000,
-    E = 60,
-};
-export fn entry() void {
-    var x = MultipleChoice.C;
-    _ = x;
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:6:5: error: enum tag value 60 already taken
-// tmp.zig:4:5: note: other occurrence here
diff --git a/test/compile_errors/stage1/obj/enum_with_0_fields.zig b/test/compile_errors/stage1/obj/enum_with_0_fields.zig
deleted file mode 100644
index 9ee18f51ca21c32cb7d35173c0faa9309983e1d2..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/enum_with_0_fields.zig
+++ /dev/null
@@ -1,7 +0,0 @@
-const Foo = enum {};
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:1:13: error: enum declarations must have at least one tag
diff --git a/test/compile_errors/stage1/obj/enum_with_declarations_unavailable_for_reify_type.zig b/test/compile_errors/stage1/obj/enum_with_declarations_unavailable_for_reify_type.zig
deleted file mode 100644
index ffe9a2a78acabed0e4b018e63f88f76e9e4bb74d..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/enum_with_declarations_unavailable_for_reify_type.zig
+++ /dev/null
@@ -1,9 +0,0 @@
-export fn entry() void {
-    _ = @Type(@typeInfo(enum { foo, const bar = 1; }));
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:2:15: error: Type.Enum.decls must be empty for @Type
diff --git a/test/compile_errors/stage1/obj/error_equality_but_sets_have_no_common_members.zig b/test/compile_errors/stage1/obj/error_equality_but_sets_have_no_common_members.zig
deleted file mode 100644
index d42169b5036f40ba0725358de24a370d58b85bc9..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/error_equality_but_sets_have_no_common_members.zig
+++ /dev/null
@@ -1,16 +0,0 @@
-const Set1 = error{A, C};
-const Set2 = error{B, D};
-export fn entry() void {
-    foo(Set1.A);
-}
-fn foo(x: Set1) void {
-    if (x == Set2.B) {
-
-    }
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:7:11: error: error sets 'Set1' and 'Set2' have no common errors
diff --git a/test/compile_errors/stage1/obj/error_not_handled_in_switch.zig b/test/compile_errors/stage1/obj/error_not_handled_in_switch.zig
deleted file mode 100644
index 12ee35daef7d556a854562dc3afdec5bb17ab7d0..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/error_not_handled_in_switch.zig
+++ /dev/null
@@ -1,20 +0,0 @@
-export fn entry() void {
-    foo(452) catch |err| switch (err) {
-        error.Foo => {},
-    };
-}
-fn foo(x: i32) !void {
-    switch (x) {
-        0 ... 10 => return error.Foo,
-        11 ... 20 => return error.Bar,
-        21 ... 30 => return error.Baz,
-        else => {},
-    }
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:2:26: error: error.Baz not handled in switch
-// tmp.zig:2:26: error: error.Bar not handled in switch
diff --git a/test/compile_errors/stage1/obj/error_note_for_function_parameter_incompatibility.zig b/test/compile_errors/stage1/obj/error_note_for_function_parameter_incompatibility.zig
deleted file mode 100644
index edc421d8f43cc25f806dff0f26b73493c8b3d451..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/error_note_for_function_parameter_incompatibility.zig
+++ /dev/null
@@ -1,12 +0,0 @@
-fn do_the_thing(func: fn (arg: i32) void) void { _ = func; }
-fn bar(arg: bool) void { _ = arg; }
-export fn entry() void {
-    do_the_thing(bar);
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// 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'
diff --git a/test/compile_errors/stage1/obj/error_union_operator_with_non_error_set_LHS.zig b/test/compile_errors/stage1/obj/error_union_operator_with_non_error_set_LHS.zig
deleted file mode 100644
index 785e42fb9b6d2bb0cc935964d8c8145ef2c80f33..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/error_union_operator_with_non_error_set_LHS.zig
+++ /dev/null
@@ -1,11 +0,0 @@
-comptime {
-    const z = i32!i32;
-    var x: z = undefined;
-    _ = x;
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:2:15: error: expected error set type, found type 'i32'
diff --git a/test/compile_errors/stage1/obj/error_when_evaluating_return_type.zig b/test/compile_errors/stage1/obj/error_when_evaluating_return_type.zig
deleted file mode 100644
index 60731740b79dfaff5366a283ef4ac2b20d4d1f04..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/error_when_evaluating_return_type.zig
+++ /dev/null
@@ -1,17 +0,0 @@
-const Foo = struct {
-    map: @as(i32, i32),
-
-    fn init() Foo {
-        return undefined;
-    }
-};
-export fn entry() void {
-    var rule_set = try Foo.init();
-    _ = rule_set;
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:2:19: error: expected type 'i32', found 'type'
diff --git a/test/compile_errors/stage1/obj/exceeded_maximum_bit_width_of_integer.zig b/test/compile_errors/stage1/obj/exceeded_maximum_bit_width_of_integer.zig
deleted file mode 100644
index 2a3c795f8187ade0b6ee9b599dd76bad27f079c1..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/exceeded_maximum_bit_width_of_integer.zig
+++ /dev/null
@@ -1,15 +0,0 @@
-export fn entry1() void {
-    const T = u65536;
-    _ = T;
-}
-export fn entry2() void {
-    var x: i65536 = 1;
-    _ = x;
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// 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
diff --git a/test/compile_errors/stage1/obj/explicit_cast_float_literal_to_integer_when_there_is_a_fraction_component.zig b/test/compile_errors/stage1/obj/explicit_cast_float_literal_to_integer_when_there_is_a_fraction_component.zig
deleted file mode 100644
index 696fef57fa83c849e1b776b394fdbb76d592bfb3..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/explicit_cast_float_literal_to_integer_when_there_is_a_fraction_component.zig
+++ /dev/null
@@ -1,9 +0,0 @@
-export fn entry() i32 {
-    return @as(i32, 12.34);
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:2:21: error: fractional component prevents float value 12.340000 from being casted to type 'i32'
diff --git a/test/compile_errors/stage1/obj/explicit_error_set_cast_known_at_comptime_violates_error_sets.zig b/test/compile_errors/stage1/obj/explicit_error_set_cast_known_at_comptime_violates_error_sets.zig
deleted file mode 100644
index 4a41920107e283aa1dae9ae42ae7554cba1e8bd1..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/explicit_error_set_cast_known_at_comptime_violates_error_sets.zig
+++ /dev/null
@@ -1,13 +0,0 @@
-const Set1 = error {A, B};
-const Set2 = error {A, C};
-comptime {
-    var x = Set1.B;
-    var y = @errSetCast(Set2, x);
-    _ = y;
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:5:13: error: error.B not a member of error set 'Set2'
diff --git a/test/compile_errors/stage1/obj/explicitly_casting_non_tag_type_to_enum.zig b/test/compile_errors/stage1/obj/explicitly_casting_non_tag_type_to_enum.zig
deleted file mode 100644
index 1999fd70a7750f7fb0d51ae7b9476d6fe28d99c3..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/explicitly_casting_non_tag_type_to_enum.zig
+++ /dev/null
@@ -1,18 +0,0 @@
-const Small = enum(u2) {
-    One,
-    Two,
-    Three,
-    Four,
-};
-
-export fn entry() void {
-    var y = @as(f32, 3);
-    var x = @intToEnum(Small, y);
-    _ = x;
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:10:31: error: expected integer type, found 'f32'
diff --git a/test/compile_errors/stage1/obj/export_function_with_comptime_parameter.zig b/test/compile_errors/stage1/obj/export_function_with_comptime_parameter.zig
deleted file mode 100644
index ccfda1ba67eb7757532b4f60d597c7864ac77074..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/export_function_with_comptime_parameter.zig
+++ /dev/null
@@ -1,9 +0,0 @@
-export fn foo(comptime x: i32, y: i32) i32{
-    return x + y;
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:1:15: error: comptime parameter not allowed in function with calling convention 'C'
diff --git a/test/compile_errors/stage1/obj/export_generic_function.zig b/test/compile_errors/stage1/obj/export_generic_function.zig
deleted file mode 100644
index 9f6bcd4cf489ab8375e0d63d2ed35c62ff3b7336..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/export_generic_function.zig
+++ /dev/null
@@ -1,10 +0,0 @@
-export fn foo(num: anytype) i32 {
-    _ = num;
-    return 0;
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:1:15: error: parameter of type 'anytype' not allowed in function with calling convention 'C'
diff --git a/test/compile_errors/stage1/obj/exported_async_function.zig b/test/compile_errors/stage1/obj/exported_async_function.zig
deleted file mode 100644
index b9ac591227d95ea9cf01595a357c97d4e00950fb..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/exported_async_function.zig
+++ /dev/null
@@ -1,7 +0,0 @@
-export fn foo() callconv(.Async) void {}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:1:1: error: exported function cannot be async
diff --git a/test/compile_errors/stage1/obj/exported_enum_without_explicit_integer_tag_type.zig b/test/compile_errors/stage1/obj/exported_enum_without_explicit_integer_tag_type.zig
deleted file mode 100644
index c432bedd6b7179ad8988fcfb7b843d54dffc7f1e..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/exported_enum_without_explicit_integer_tag_type.zig
+++ /dev/null
@@ -1,15 +0,0 @@
-const E = enum { one, two };
-comptime {
-    @export(E, .{ .name = "E" });
-}
-const e: E = .two;
-comptime {
-    @export(e, .{ .name = "e" });
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:3:13: error: exported enum without explicit integer tag type
-// tmp.zig:7:13: error: exported enum value without explicit integer tag type
diff --git a/test/compile_errors/stage1/obj/extern_function_pointer_mismatch.zig b/test/compile_errors/stage1/obj/extern_function_pointer_mismatch.zig
deleted file mode 100644
index 888b59a6265fa359aa0d97dd58c037f9d0798c75..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/extern_function_pointer_mismatch.zig
+++ /dev/null
@@ -1,12 +0,0 @@
-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;}
-export fn c(x: i32) i32 {return x + 2;}
-
-export fn entry() usize { return @sizeOf(@TypeOf(fns)); }
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:1:37: error: expected type 'fn(i32) i32', found 'fn(i32) callconv(.C) i32'
diff --git a/test/compile_errors/stage1/obj/extern_function_with_comptime_parameter.zig b/test/compile_errors/stage1/obj/extern_function_with_comptime_parameter.zig
deleted file mode 100644
index 93e26b9543af4b2d63411aa117a2a9698a151987..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/extern_function_with_comptime_parameter.zig
+++ /dev/null
@@ -1,11 +0,0 @@
-extern fn foo(comptime x: i32, y: i32) i32;
-fn f() i32 {
-    return foo(1, 2);
-}
-export fn entry() usize { return @sizeOf(@TypeOf(f)); }
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:1:15: error: comptime parameter not allowed in function with calling convention 'C'
diff --git a/test/compile_errors/stage1/obj/extern_struct_with_extern-compatible_but_inferred_integer_tag_type.zig b/test/compile_errors/stage1/obj/extern_struct_with_extern-compatible_but_inferred_integer_tag_type.zig
deleted file mode 100644
index 8f45a0e5dc2f5e378e5c80fe46d700db7bc9f10b..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/extern_struct_with_extern-compatible_but_inferred_integer_tag_type.zig
+++ /dev/null
@@ -1,43 +0,0 @@
-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",
-@"24",@"25",@"26",@"27",@"28",@"29",@"30",@"31",@"32",@"33",@"34",
-@"35",@"36",@"37",@"38",@"39",@"40",@"41",@"42",@"43",@"44",@"45",
-@"46",@"47",@"48",@"49",@"50",@"51",@"52",@"53",@"54",@"55",@"56",
-@"57",@"58",@"59",@"60",@"61",@"62",@"63",@"64",@"65",@"66",@"67",
-@"68",@"69",@"70",@"71",@"72",@"73",@"74",@"75",@"76",@"77",@"78",
-@"79",@"80",@"81",@"82",@"83",@"84",@"85",@"86",@"87",@"88",@"89",
-@"90",@"91",@"92",@"93",@"94",@"95",@"96",@"97",@"98",@"99",@"100",
-@"101",@"102",@"103",@"104",@"105",@"106",@"107",@"108",@"109",
-@"110",@"111",@"112",@"113",@"114",@"115",@"116",@"117",@"118",
-@"119",@"120",@"121",@"122",@"123",@"124",@"125",@"126",@"127",
-@"128",@"129",@"130",@"131",@"132",@"133",@"134",@"135",@"136",
-@"137",@"138",@"139",@"140",@"141",@"142",@"143",@"144",@"145",
-@"146",@"147",@"148",@"149",@"150",@"151",@"152",@"153",@"154",
-@"155",@"156",@"157",@"158",@"159",@"160",@"161",@"162",@"163",
-@"164",@"165",@"166",@"167",@"168",@"169",@"170",@"171",@"172",
-@"173",@"174",@"175",@"176",@"177",@"178",@"179",@"180",@"181",
-@"182",@"183",@"184",@"185",@"186",@"187",@"188",@"189",@"190",
-@"191",@"192",@"193",@"194",@"195",@"196",@"197",@"198",@"199",
-@"200",@"201",@"202",@"203",@"204",@"205",@"206",@"207",@"208",
-@"209",@"210",@"211",@"212",@"213",@"214",@"215",@"216",@"217",
-@"218",@"219",@"220",@"221",@"222",@"223",@"224",@"225",@"226",
-@"227",@"228",@"229",@"230",@"231",@"232",@"233",@"234",@"235",
-@"236",@"237",@"238",@"239",@"240",@"241",@"242",@"243",@"244",
-@"245",@"246",@"247",@"248",@"249",@"250",@"251",@"252",@"253",
-@"254",@"255"
-};
-pub const S = extern struct {
-    e: E,
-};
-export fn entry() void {
-    if (@typeInfo(E).Enum.tag_type != u8) @compileError("did not infer u8 tag type");
-    const s: S = undefined;
-    _ = s;
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:31:5: error: extern structs cannot contain fields of type 'E'
diff --git a/test/compile_errors/stage1/obj/extern_struct_with_non-extern-compatible_integer_tag_type.zig b/test/compile_errors/stage1/obj/extern_struct_with_non-extern-compatible_integer_tag_type.zig
deleted file mode 100644
index aa508056a192627c3ae7cb35509b6996f40010a2..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/extern_struct_with_non-extern-compatible_integer_tag_type.zig
+++ /dev/null
@@ -1,14 +0,0 @@
-pub const E = enum(u31) { A, B, C };
-pub const S = extern struct {
-    e: E,
-};
-export fn entry() void {
-    const s: S = undefined;
-    _ = s;
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:3:5: error: extern structs cannot contain fields of type 'E'
diff --git a/test/compile_errors/stage1/obj/extern_union_field_missing_type.zig b/test/compile_errors/stage1/obj/extern_union_field_missing_type.zig
deleted file mode 100644
index 9d8532f8a1dfd622a6003514537fa05f684a5d47..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/extern_union_field_missing_type.zig
+++ /dev/null
@@ -1,13 +0,0 @@
-const Letter = extern union {
-    A,
-};
-export fn entry() void {
-    var a = Letter { .A = {} };
-    _ = a;
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:2:5: error: union field missing type
diff --git a/test/compile_errors/stage1/obj/extern_union_given_enum_tag_type.zig b/test/compile_errors/stage1/obj/extern_union_given_enum_tag_type.zig
deleted file mode 100644
index 86ac42cccf6891c91542a079ca389ea0939eeb12..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/extern_union_given_enum_tag_type.zig
+++ /dev/null
@@ -1,20 +0,0 @@
-const Letter = enum {
-    A,
-    B,
-    C,
-};
-const Payload = extern union(Letter) {
-    A: i32,
-    B: f64,
-    C: bool,
-};
-export fn entry() void {
-    var a = Payload { .A = 1234 };
-    _ = a;
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:6:30: error: extern union does not support enum tag type
diff --git a/test/compile_errors/stage1/obj/extern_variable_has_no_type.zig b/test/compile_errors/stage1/obj/extern_variable_has_no_type.zig
deleted file mode 100644
index 58d67f14e110d2937b53765a83b86a34fadd593a..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/extern_variable_has_no_type.zig
+++ /dev/null
@@ -1,10 +0,0 @@
-extern var foo;
-pub export fn entry() void {
-    foo;
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:1:8: error: unable to infer variable type
diff --git a/test/compile_errors/stage1/obj/fieldParentPtr-bad_field_name.zig b/test/compile_errors/stage1/obj/fieldParentPtr-bad_field_name.zig
deleted file mode 100644
index 73022167f51b481cc5e3c1964560d180f783a04e..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/fieldParentPtr-bad_field_name.zig
+++ /dev/null
@@ -1,12 +0,0 @@
-const Foo = extern struct {
-    derp: i32,
-};
-export fn foo(a: *i32) *Foo {
-    return @fieldParentPtr(Foo, "a", a);
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:5:33: error: struct 'Foo' has no field 'a'
diff --git a/test/compile_errors/stage1/obj/fieldParentPtr-comptime_field_ptr_not_based_on_struct.zig b/test/compile_errors/stage1/obj/fieldParentPtr-comptime_field_ptr_not_based_on_struct.zig
deleted file mode 100644
index 9375f4639a020f37f1f1320d0978f131279303df..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/fieldParentPtr-comptime_field_ptr_not_based_on_struct.zig
+++ /dev/null
@@ -1,17 +0,0 @@
-const Foo = struct {
-    a: i32,
-    b: i32,
-};
-const foo = Foo { .a = 1, .b = 2, };
-
-comptime {
-    const field_ptr = @intToPtr(*i32, 0x1234);
-    const another_foo_ptr = @fieldParentPtr(Foo, "b", field_ptr);
-    _ = another_foo_ptr;
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:9:55: error: pointer value not based on parent struct
diff --git a/test/compile_errors/stage1/obj/fieldParentPtr-comptime_wrong_field_index.zig b/test/compile_errors/stage1/obj/fieldParentPtr-comptime_wrong_field_index.zig
deleted file mode 100644
index c322543dc01886dc35b4f455ffce8fe92a8aed12..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/fieldParentPtr-comptime_wrong_field_index.zig
+++ /dev/null
@@ -1,16 +0,0 @@
-const Foo = struct {
-    a: i32,
-    b: i32,
-};
-const foo = Foo { .a = 1, .b = 2, };
-
-comptime {
-    const another_foo_ptr = @fieldParentPtr(Foo, "b", &foo.a);
-    _ = another_foo_ptr;
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:8:29: error: field 'b' has index 1 but pointer value is index 0 of struct 'Foo'
diff --git a/test/compile_errors/stage1/obj/fieldParentPtr-field_pointer_is_not_pointer.zig b/test/compile_errors/stage1/obj/fieldParentPtr-field_pointer_is_not_pointer.zig
deleted file mode 100644
index 71360e56810662e40958a553e4f180c82248db8c..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/fieldParentPtr-field_pointer_is_not_pointer.zig
+++ /dev/null
@@ -1,12 +0,0 @@
-const Foo = extern struct {
-    a: i32,
-};
-export fn foo(a: i32) *Foo {
-    return @fieldParentPtr(Foo, "a", a);
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:5:38: error: expected pointer, found 'i32'
diff --git a/test/compile_errors/stage1/obj/fieldParentPtr-non_struct.zig b/test/compile_errors/stage1/obj/fieldParentPtr-non_struct.zig
deleted file mode 100644
index 16b9a9b3328caaae919dc651d4c01f88b7d578a2..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/fieldParentPtr-non_struct.zig
+++ /dev/null
@@ -1,10 +0,0 @@
-const Foo = i32;
-export fn foo(a: *i32) *Foo {
-    return @fieldParentPtr(Foo, "a", a);
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:3:28: error: expected struct type, found 'i32'
diff --git a/test/compile_errors/stage1/obj/field_access_of_opaque_type.zig b/test/compile_errors/stage1/obj/field_access_of_opaque_type.zig
deleted file mode 100644
index 963c89dafe79b6ac6b7c0d63c11f30dd458725a2..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/field_access_of_opaque_type.zig
+++ /dev/null
@@ -1,16 +0,0 @@
-const MyType = opaque {};
-
-export fn entry() bool {
-    var x: i32 = 1;
-    return bar(@ptrCast(*MyType, &x));
-}
-
-fn bar(x: *MyType) bool {
-    return x.blah;
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:9:13: error: no member named 'blah' in opaque type 'MyType'
diff --git a/test/compile_errors/stage1/obj/field_access_of_slices.zig b/test/compile_errors/stage1/obj/field_access_of_slices.zig
deleted file mode 100644
index 45ca7113674e923e0c53ea970f518ac96e8cd8ba..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/field_access_of_slices.zig
+++ /dev/null
@@ -1,11 +0,0 @@
-export fn entry() void {
-    var slice: []i32 = undefined;
-    const info = @TypeOf(slice).unknown;
-    _ = info;
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:3:32: error: type 'type' does not support field access
diff --git a/test/compile_errors/stage1/obj/field_access_of_unknown_length_pointer.zig b/test/compile_errors/stage1/obj/field_access_of_unknown_length_pointer.zig
deleted file mode 100644
index f9a37cabccbe99a588faf9f1e1237eb46322dcd8..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/field_access_of_unknown_length_pointer.zig
+++ /dev/null
@@ -1,13 +0,0 @@
-const Foo = extern struct {
-    a: i32,
-};
-
-export fn entry(foo: [*]Foo) void {
-    foo.a += 1;
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:6:8: error: type '[*]Foo' does not support field access
diff --git a/test/compile_errors/stage1/obj/field_type_supplied_in_an_enum.zig b/test/compile_errors/stage1/obj/field_type_supplied_in_an_enum.zig
deleted file mode 100644
index d6ba214c0ccb145003d52e6ee9d4d63ffa2cece6..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/field_type_supplied_in_an_enum.zig
+++ /dev/null
@@ -1,12 +0,0 @@
-const Letter = enum {
-    A: void,
-    B,
-    C,
-};
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:2:8: error: enum fields do not have types
-// tmp.zig:1:16: note: consider 'union(enum)' here to make it a tagged union
diff --git a/test/compile_errors/stage1/obj/floatToInt_comptime_safety.zig b/test/compile_errors/stage1/obj/floatToInt_comptime_safety.zig
deleted file mode 100644
index 1e5fa746a14b4fff82df228d6d28ad5a5ff19169..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/floatToInt_comptime_safety.zig
+++ /dev/null
@@ -1,17 +0,0 @@
-comptime {
-    _ = @floatToInt(i8, @as(f32, -129.1));
-}
-comptime {
-    _ = @floatToInt(u8, @as(f32, -1.1));
-}
-comptime {
-    _ = @floatToInt(u8, @as(f32, 256.1));
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:2:9: error: integer value '-129' cannot be stored in type 'i8'
-// tmp.zig:5:9: error: integer value '-1' cannot be stored in type 'u8'
-// tmp.zig:8:9: error: integer value '256' cannot be stored in type 'u8'
diff --git a/test/compile_errors/stage1/obj/float_literal_too_large_error.zig b/test/compile_errors/stage1/obj/float_literal_too_large_error.zig
deleted file mode 100644
index c3865c31108cadfed1a77490a6a23ea861e6ee79..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/float_literal_too_large_error.zig
+++ /dev/null
@@ -1,10 +0,0 @@
-comptime {
-    const a = 0x1.0p18495;
-    _ = a;
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:2:15: error: float literal out of range of any type
diff --git a/test/compile_errors/stage1/obj/float_literal_too_small_error_denormal.zig b/test/compile_errors/stage1/obj/float_literal_too_small_error_denormal.zig
deleted file mode 100644
index 0b0bfee1de541f72fbbe2f9913449ca9dde3bb8b..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/float_literal_too_small_error_denormal.zig
+++ /dev/null
@@ -1,10 +0,0 @@
-comptime {
-    const a = 0x1.0p-19000;
-    _ = a;
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:2:15: error: float literal out of range of any type
diff --git a/test/compile_errors/stage1/obj/for_loop_body_expression_ignored.zig b/test/compile_errors/stage1/obj/for_loop_body_expression_ignored.zig
deleted file mode 100644
index 6281d4b276f702179d5a44cf6d67302ecc0aec78..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/for_loop_body_expression_ignored.zig
+++ /dev/null
@@ -1,18 +0,0 @@
-fn returns() usize {
-    return 2;
-}
-export fn f1() void {
-    for ("hello") |_| returns();
-}
-export fn f2() void {
-    var x: anyerror!i32 = error.Bad;
-    for ("hello") |_| returns() else unreachable;
-    _ = x;
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:5:30: error: expression value is ignored
-// tmp.zig:9:30: error: expression value is ignored
diff --git a/test/compile_errors/stage1/obj/frame_called_outside_of_function_definition.zig b/test/compile_errors/stage1/obj/frame_called_outside_of_function_definition.zig
deleted file mode 100644
index d14099815287f35321510c87104e0a5831a970a6..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/frame_called_outside_of_function_definition.zig
+++ /dev/null
@@ -1,11 +0,0 @@
-var handle_undef: anyframe = undefined;
-var handle_dummy: anyframe = @frame();
-export fn entry() bool {
-    return handle_undef == handle_dummy;
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:2:30: error: @frame() called outside of function definition
diff --git a/test/compile_errors/stage1/obj/frame_causes_function_to_be_async.zig b/test/compile_errors/stage1/obj/frame_causes_function_to_be_async.zig
deleted file mode 100644
index f8493b08b2c9e3374ee9c5c8297601c397964dea..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/frame_causes_function_to_be_async.zig
+++ /dev/null
@@ -1,13 +0,0 @@
-export fn entry() void {
-    func();
-}
-fn func() void {
-    _ = @frame();
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:1:1: error: function with calling convention 'C' cannot be async
-// tmp.zig:5:9: note: @frame() causes function to be async
diff --git a/test/compile_errors/stage1/obj/function_alignment_non_power_of_2.zig b/test/compile_errors/stage1/obj/function_alignment_non_power_of_2.zig
deleted file mode 100644
index 617939a120fc6275ce1b9a486f75ab4e90541a76..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/function_alignment_non_power_of_2.zig
+++ /dev/null
@@ -1,8 +0,0 @@
-extern fn foo() align(3) void;
-export fn entry() void { return foo(); }
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:1:23: error: alignment value 3 is not a power of 2
diff --git a/test/compile_errors/stage1/obj/function_call_assigned_to_incorrect_type.zig b/test/compile_errors/stage1/obj/function_call_assigned_to_incorrect_type.zig
deleted file mode 100644
index 51bc82ffb867bb9f670aa99021c02767f6d1b159..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/function_call_assigned_to_incorrect_type.zig
+++ /dev/null
@@ -1,13 +0,0 @@
-export fn entry() void {
-    var arr: [4]f32 = undefined;
-    arr = concat();
-}
-fn concat() [16]f32 {
-    return [1]f32{0}**16;
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:3:17: error: expected type '[4]f32', found '[16]f32'
diff --git a/test/compile_errors/stage1/obj/function_parameter_is_opaque.zig b/test/compile_errors/stage1/obj/function_parameter_is_opaque.zig
deleted file mode 100644
index 5b52370d868e8e6e28fd7a40d070c8d3bce995da..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/function_parameter_is_opaque.zig
+++ /dev/null
@@ -1,29 +0,0 @@
-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 {_ = p;}
-export fn entry3() void {
-    _ = foo;
-}
-
-fn bar(p: @TypeOf(null)) void {_ = p;}
-export fn entry4() void {
-    _ = bar;
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:3:28: error: parameter of opaque type 'FooType' not allowed
-// tmp.zig:8:28: error: parameter of type '@Type(.Null)' not allowed
-// tmp.zig:12:11: error: parameter of opaque type 'FooType' not allowed
-// tmp.zig:17:11: error: parameter of type '@Type(.Null)' not allowed
diff --git a/test/compile_errors/stage1/obj/function_prototype_with_no_body.zig b/test/compile_errors/stage1/obj/function_prototype_with_no_body.zig
deleted file mode 100644
index 7926faaa4435863b2c5ad4d477e7fd6f1a697ce8..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/function_prototype_with_no_body.zig
+++ /dev/null
@@ -1,10 +0,0 @@
-fn foo() void;
-export fn entry() void {
-    foo();
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:1:1: error: non-extern function has no body
diff --git a/test/compile_errors/stage1/obj/function_returning_opaque_type.zig b/test/compile_errors/stage1/obj/function_returning_opaque_type.zig
deleted file mode 100644
index e2c084b517f9437deca2b81981d57d004fe1c6ca..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/function_returning_opaque_type.zig
+++ /dev/null
@@ -1,19 +0,0 @@
-const FooType = opaque {};
-export fn bar() !FooType {
-    return error.InvalidValue;
-}
-export fn bav() !@TypeOf(null) {
-    return error.InvalidValue;
-}
-export fn baz() !@TypeOf(undefined) {
-    return error.InvalidValue;
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:2:18: error: Opaque return type 'FooType' not allowed
-// tmp.zig:1:1: note: type declared here
-// tmp.zig:5:18: error: Null return type '@Type(.Null)' not allowed
-// tmp.zig:8:18: error: Undefined return type '@Type(.Undefined)' not allowed
diff --git a/test/compile_errors/stage1/obj/function_with_ccc_indirectly_calling_async_function.zig b/test/compile_errors/stage1/obj/function_with_ccc_indirectly_calling_async_function.zig
deleted file mode 100644
index 9fadb992b4c68407ab3c65c208d968b29123bf7a..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/function_with_ccc_indirectly_calling_async_function.zig
+++ /dev/null
@@ -1,18 +0,0 @@
-export fn entry() void {
-    foo();
-}
-fn foo() void {
-    bar();
-}
-fn bar() void {
-    suspend {}
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:1:1: error: function with calling convention 'C' cannot be async
-// tmp.zig:2:8: note: async function call here
-// tmp.zig:5:8: note: async function call here
-// tmp.zig:8:5: note: suspends here
diff --git a/test/compile_errors/stage1/obj/function_with_invalid_return_type.zig b/test/compile_errors/stage1/obj/function_with_invalid_return_type.zig
deleted file mode 100644
index 897b298a3d346c38f6b509530ec0c264bbfe4e6f..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/function_with_invalid_return_type.zig
+++ /dev/null
@@ -1,7 +0,0 @@
-export fn foo() boid {}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:1:17: error: use of undeclared identifier 'boid'
diff --git a/test/compile_errors/stage1/obj/function_with_non-extern_non-packed_enum_parameter.zig b/test/compile_errors/stage1/obj/function_with_non-extern_non-packed_enum_parameter.zig
deleted file mode 100644
index 8de26c08b84a4fcef12222ee24e0adbf5a573118..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/function_with_non-extern_non-packed_enum_parameter.zig
+++ /dev/null
@@ -1,8 +0,0 @@
-const Foo = enum { A, B, C };
-export fn entry(foo: Foo) void { _ = foo; }
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:2:22: error: parameter of type 'Foo' not allowed in function with calling convention 'C'
diff --git a/test/compile_errors/stage1/obj/function_with_non-extern_non-packed_struct_parameter.zig b/test/compile_errors/stage1/obj/function_with_non-extern_non-packed_struct_parameter.zig
deleted file mode 100644
index ecb4a3626723eb8d281c2c83821d1e09d8384844..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/function_with_non-extern_non-packed_struct_parameter.zig
+++ /dev/null
@@ -1,12 +0,0 @@
-const Foo = struct {
-    A: i32,
-    B: f32,
-    C: bool,
-};
-export fn entry(foo: Foo) void { _ = foo; }
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:6:22: error: parameter of type 'Foo' not allowed in function with calling convention 'C'
diff --git a/test/compile_errors/stage1/obj/function_with_non-extern_non-packed_union_parameter.zig b/test/compile_errors/stage1/obj/function_with_non-extern_non-packed_union_parameter.zig
deleted file mode 100644
index bfe2dc6cfa6114959a15aeab842523783bc94d35..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/function_with_non-extern_non-packed_union_parameter.zig
+++ /dev/null
@@ -1,12 +0,0 @@
-const Foo = union {
-    A: i32,
-    B: f32,
-    C: bool,
-};
-export fn entry(foo: Foo) void { _ = foo; }
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:6:22: error: parameter of type 'Foo' not allowed in function with calling convention 'C'
diff --git a/test/compile_errors/stage1/obj/generic_fn_as_parameter_without_comptime_keyword.zig b/test/compile_errors/stage1/obj/generic_fn_as_parameter_without_comptime_keyword.zig
deleted file mode 100644
index 72e27e3a0d57babdf71017a0ff6c9767ed598ae2..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/generic_fn_as_parameter_without_comptime_keyword.zig
+++ /dev/null
@@ -1,11 +0,0 @@
-fn f(_: fn (anytype) void) void {}
-fn g(_: anytype) void {}
-export fn entry() void {
-    f(g);
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:1:9: error: parameter of type 'fn(anytype) anytype' must be declared comptime
diff --git a/test/compile_errors/stage1/obj/generic_function_call_assigned_to_incorrect_type.zig b/test/compile_errors/stage1/obj/generic_function_call_assigned_to_incorrect_type.zig
deleted file mode 100644
index 72ed66b20aba928f16594e677958dece3d809d2c..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/generic_function_call_assigned_to_incorrect_type.zig
+++ /dev/null
@@ -1,13 +0,0 @@
-pub export fn entry() void {
-    var res: []i32 = undefined;
-    res = myAlloc(i32);
-}
-fn myAlloc(comptime arg: type) anyerror!arg{
-    unreachable;
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:3:18: error: expected type '[]i32', found 'anyerror!i32
diff --git a/test/compile_errors/stage1/obj/generic_function_instance_with_non-constant_expression.zig b/test/compile_errors/stage1/obj/generic_function_instance_with_non-constant_expression.zig
deleted file mode 100644
index 9cdd653766149fe4321fa470bc23a3f2af4f4106..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/generic_function_instance_with_non-constant_expression.zig
+++ /dev/null
@@ -1,12 +0,0 @@
-fn foo(comptime x: i32, y: i32) i32 { return x + y; }
-fn test1(a: i32, b: i32) i32 {
-    return foo(a, b);
-}
-
-export fn entry() usize { return @sizeOf(@TypeOf(test1)); }
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:3:16: error: runtime value cannot be passed to comptime arg
diff --git a/test/compile_errors/stage1/obj/generic_function_returning_opaque_type.zig b/test/compile_errors/stage1/obj/generic_function_returning_opaque_type.zig
deleted file mode 100644
index 247c1a49bf8a06a7fae2278195e58573a03349b9..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/generic_function_returning_opaque_type.zig
+++ /dev/null
@@ -1,25 +0,0 @@
-const FooType = opaque {};
-fn generic(comptime T: type) !T {
-    return undefined;
-}
-export fn bar() void {
-    _ = generic(FooType);
-}
-export fn bav() void {
-    _ = generic(@TypeOf(null));
-}
-export fn baz() void {
-    _ = generic(@TypeOf(undefined));
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:6:16: error: call to generic function with Opaque return type 'FooType' not allowed
-// tmp.zig:2:1: note: function declared here
-// tmp.zig:1:1: note: type declared here
-// tmp.zig:9:16: error: call to generic function with Null return type '@Type(.Null)' not allowed
-// tmp.zig:2:1: note: function declared here
-// tmp.zig:12:16: error: call to generic function with Undefined return type '@Type(.Undefined)' not allowed
-// tmp.zig:2:1: note: function declared here
diff --git a/test/compile_errors/stage1/obj/generic_function_where_return_type_is_self-referenced.zig b/test/compile_errors/stage1/obj/generic_function_where_return_type_is_self-referenced.zig
deleted file mode 100644
index c8d31ec8dfac0e0e5880d56738d235ecb3eb7533..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/generic_function_where_return_type_is_self-referenced.zig
+++ /dev/null
@@ -1,15 +0,0 @@
-fn Foo(comptime T: type) Foo(T) {
-    return struct{ x: T };
-}
-export fn entry() void {
-    const t = Foo(u32) {
-      .x = 1
-    };
-    _ = t;
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:1:29: error: evaluation exceeded 1000 backwards branches
diff --git a/test/compile_errors/stage1/obj/global_variable_alignment_non_power_of_2.zig b/test/compile_errors/stage1/obj/global_variable_alignment_non_power_of_2.zig
deleted file mode 100644
index f23f340b1600632d508c78afa7e3553416db0b14..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/global_variable_alignment_non_power_of_2.zig
+++ /dev/null
@@ -1,8 +0,0 @@
-const some_data: [100]u8 align(3) = undefined;
-export fn entry() usize { return @sizeOf(@TypeOf(some_data)); }
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:1:32: error: alignment value 3 is not a power of 2
diff --git a/test/compile_errors/stage1/obj/global_variable_initializer_must_be_constant_expression.zig b/test/compile_errors/stage1/obj/global_variable_initializer_must_be_constant_expression.zig
deleted file mode 100644
index d01e828da66600207d8932b4996c898bc5b8d69f..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/global_variable_initializer_must_be_constant_expression.zig
+++ /dev/null
@@ -1,9 +0,0 @@
-extern fn foo() i32;
-const x = foo();
-export fn entry() i32 { return x; }
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:2:11: error: unable to evaluate constant expression
diff --git a/test/compile_errors/stage1/obj/hasDecl_with_non-container.zig b/test/compile_errors/stage1/obj/hasDecl_with_non-container.zig
deleted file mode 100644
index e9aeacdd4e9d054a694d86b86707112f094769dd..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/hasDecl_with_non-container.zig
+++ /dev/null
@@ -1,9 +0,0 @@
-export fn entry() void {
-    _ = @hasDecl(i32, "hi");
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:2:18: error: expected struct, enum, or union; found 'i32'
diff --git a/test/compile_errors/stage1/obj/if_condition_is_bool_not_int.zig b/test/compile_errors/stage1/obj/if_condition_is_bool_not_int.zig
deleted file mode 100644
index 53afb2792a004d85f0bb8697364ae677812b304f..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/if_condition_is_bool_not_int.zig
+++ /dev/null
@@ -1,9 +0,0 @@
-export fn f() void {
-    if (0) {}
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:2:9: error: expected type 'bool', found 'comptime_int'
diff --git a/test/compile_errors/stage1/obj/ignored_assert-err-ok_return_value.zig b/test/compile_errors/stage1/obj/ignored_assert-err-ok_return_value.zig
deleted file mode 100644
index 4d45ae13043e5589212b4b617bd9685bcaee3196..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/ignored_assert-err-ok_return_value.zig
+++ /dev/null
@@ -1,10 +0,0 @@
-export fn foo() void {
-    bar() catch unreachable;
-}
-fn bar() anyerror!i32 { return 0; }
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:2:11: error: expression value is ignored
diff --git a/test/compile_errors/stage1/obj/ignored_comptime_statement_value.zig b/test/compile_errors/stage1/obj/ignored_comptime_statement_value.zig
deleted file mode 100644
index 0e82c9ae3ea439da7bd0b886412e8b1654600d43..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/ignored_comptime_statement_value.zig
+++ /dev/null
@@ -1,9 +0,0 @@
-export fn foo() void {
-    comptime {1;}
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:2:15: error: expression value is ignored
diff --git a/test/compile_errors/stage1/obj/ignored_comptime_value.zig b/test/compile_errors/stage1/obj/ignored_comptime_value.zig
deleted file mode 100644
index 0306ea72ff14e0a826f6093af8cf9021aab7cd6d..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/ignored_comptime_value.zig
+++ /dev/null
@@ -1,9 +0,0 @@
-export fn foo() void {
-    comptime 1;
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:2:5: error: expression value is ignored
diff --git a/test/compile_errors/stage1/obj/ignored_deferred_function_call.zig b/test/compile_errors/stage1/obj/ignored_deferred_function_call.zig
deleted file mode 100644
index 41812bfda93ba61d3fbfb34415b96463ceba6d59..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/ignored_deferred_function_call.zig
+++ /dev/null
@@ -1,10 +0,0 @@
-export fn foo() void {
-    defer bar();
-}
-fn bar() anyerror!i32 { return 0; }
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:2:14: error: error is ignored. consider using `try`, `catch`, or `if`
diff --git a/test/compile_errors/stage1/obj/ignored_deferred_statement_value.zig b/test/compile_errors/stage1/obj/ignored_deferred_statement_value.zig
deleted file mode 100644
index 1042c4f40a20ebcc6d49abb1631b8b25ca482724..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/ignored_deferred_statement_value.zig
+++ /dev/null
@@ -1,9 +0,0 @@
-export fn foo() void {
-    defer {1;}
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:2:12: error: expression value is ignored
diff --git a/test/compile_errors/stage1/obj/ignored_expression_in_while_continuation.zig b/test/compile_errors/stage1/obj/ignored_expression_in_while_continuation.zig
deleted file mode 100644
index 43f3713fc670e731c73a6a7b89e923c59e757038..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/ignored_expression_in_while_continuation.zig
+++ /dev/null
@@ -1,22 +0,0 @@
-export fn a() void {
-    while (true) : (bad()) {}
-}
-export fn b() void {
-    var x: anyerror!i32 = 1234;
-    while (x) |_| : (bad()) {} else |_| {}
-}
-export fn c() void {
-    var x: ?i32 = 1234;
-    while (x) |_| : (bad()) {}
-}
-fn bad() anyerror!void {
-    return error.Bad;
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:2:24: error: error is ignored. consider using `try`, `catch`, or `if`
-// tmp.zig:6:25: error: error is ignored. consider using `try`, `catch`, or `if`
-// tmp.zig:10:25: error: error is ignored. consider using `try`, `catch`, or `if`
diff --git a/test/compile_errors/stage1/obj/ignored_return_value.zig b/test/compile_errors/stage1/obj/ignored_return_value.zig
deleted file mode 100644
index b918523b372f9967965a7f41aa7611569063eb67..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/ignored_return_value.zig
+++ /dev/null
@@ -1,10 +0,0 @@
-export fn foo() void {
-    bar();
-}
-fn bar() i32 { return 0; }
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:2:8: error: expression value is ignored
diff --git a/test/compile_errors/stage1/obj/ignored_statement_value.zig b/test/compile_errors/stage1/obj/ignored_statement_value.zig
deleted file mode 100644
index a0e540a92b08239192950a1ba2a1abeda95ae37e..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/ignored_statement_value.zig
+++ /dev/null
@@ -1,9 +0,0 @@
-export fn foo() void {
-    1;
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:2:5: error: expression value is ignored
diff --git a/test/compile_errors/stage1/obj/illegal_comparison_of_types.zig b/test/compile_errors/stage1/obj/illegal_comparison_of_types.zig
deleted file mode 100644
index d04eaec3b52c0f4c53864a3c80e63edc5c440579..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/illegal_comparison_of_types.zig
+++ /dev/null
@@ -1,20 +0,0 @@
-fn bad_eql_1(a: []u8, b: []u8) bool {
-    return a == b;
-}
-const EnumWithData = union(enum) {
-    One: void,
-    Two: i32,
-};
-fn bad_eql_2(a: *const EnumWithData, b: *const EnumWithData) bool {
-    return a.* == b.*;
-}
-
-export fn entry1() usize { return @sizeOf(@TypeOf(bad_eql_1)); }
-export fn entry2() usize { return @sizeOf(@TypeOf(bad_eql_2)); }
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:2:14: error: operator not allowed for type '[]u8'
-// tmp.zig:9:16: error: operator not allowed for type 'EnumWithData'
diff --git a/test/compile_errors/stage1/obj/implicit_cast_between_C_pointer_and_Zig_pointer-bad_const-align-child.zig b/test/compile_errors/stage1/obj/implicit_cast_between_C_pointer_and_Zig_pointer-bad_const-align-child.zig
deleted file mode 100644
index 6ff155b591ba476f582fff263cedb3b89e010f52..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/implicit_cast_between_C_pointer_and_Zig_pointer-bad_const-align-child.zig
+++ /dev/null
@@ -1,42 +0,0 @@
-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;
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:3:27: error: cast increases pointer alignment
-// tmp.zig:8:18: error: cast discards const qualifier
-// tmp.zig:13:19: error: expected type '*u32', found '[*c]u8'
-// tmp.zig:13:19: note: pointer type child 'u8' cannot cast into pointer type child 'u32'
-// tmp.zig:18:22: error: cast increases pointer alignment
-// tmp.zig:23:21: error: cast discards const qualifier
-// tmp.zig:28:22: error: expected type '[*c]u32', found '*u8'
diff --git a/test/compile_errors/stage1/obj/implicit_cast_const_array_to_mutable_slice.zig b/test/compile_errors/stage1/obj/implicit_cast_const_array_to_mutable_slice.zig
deleted file mode 100644
index 3f22cbed6b471071702ba6cc43b25bd03a591893..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/implicit_cast_const_array_to_mutable_slice.zig
+++ /dev/null
@@ -1,12 +0,0 @@
-export fn entry() void {
-    const buffer: [1]u8 = [_]u8{8};
-    const sliceA: []u8 = &buffer;
-    _ = sliceA;
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:3:27: error: cannot cast pointer to array literal to slice type '[]u8'
-// tmp.zig:3:27: note: cast discards const qualifier
diff --git a/test/compile_errors/stage1/obj/implicit_cast_from_array_to_mutable_slice.zig b/test/compile_errors/stage1/obj/implicit_cast_from_array_to_mutable_slice.zig
deleted file mode 100644
index 012555928c1dd29cdc42a963052c675c15092854..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/implicit_cast_from_array_to_mutable_slice.zig
+++ /dev/null
@@ -1,11 +0,0 @@
-var global_array: [10]i32 = undefined;
-fn foo(param: []i32) void {_ = param;}
-export fn entry() void {
-    foo(global_array);
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:4:9: error: expected type '[]i32', found '[10]i32'
diff --git a/test/compile_errors/stage1/obj/implicit_cast_from_f64_to_f32.zig b/test/compile_errors/stage1/obj/implicit_cast_from_f64_to_f32.zig
deleted file mode 100644
index f18a46b7f51c2be13c0792ee3ff5dda84700da0f..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/implicit_cast_from_f64_to_f32.zig
+++ /dev/null
@@ -1,10 +0,0 @@
-var x: f64 = 1.0;
-var y: f32 = x;
-
-export fn entry() usize { return @sizeOf(@TypeOf(y)); }
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:2:14: error: expected type 'f32', found 'f64'
diff --git a/test/compile_errors/stage1/obj/implicit_cast_of_error_set_not_a_subset.zig b/test/compile_errors/stage1/obj/implicit_cast_of_error_set_not_a_subset.zig
deleted file mode 100644
index 5958a4163930319e654571e75eab2d4d84d0afeb..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/implicit_cast_of_error_set_not_a_subset.zig
+++ /dev/null
@@ -1,16 +0,0 @@
-const Set1 = error{A, B};
-const Set2 = error{A, C};
-export fn entry() void {
-    foo(Set1.B);
-}
-fn foo(set1: Set1) void {
-    var x: Set2 = set1;
-    _ = x;
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:7:19: error: expected type 'Set2', found 'Set1'
-// tmp.zig:1:23: note: 'error.B' not a member of destination error set
diff --git a/test/compile_errors/stage1/obj/implicit_casting_C_pointers_which_would_mess_up_null_semantics.zig b/test/compile_errors/stage1/obj/implicit_casting_C_pointers_which_would_mess_up_null_semantics.zig
deleted file mode 100644
index 760bab41da07b3bbb9a510692ab35141d798a38f..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/implicit_casting_C_pointers_which_would_mess_up_null_semantics.zig
+++ /dev/null
@@ -1,26 +0,0 @@
-export fn entry() void {
-    var slice: []const u8 = "aoeu";
-    const opt_many_ptr: [*]const u8 = slice.ptr;
-    var ptr_opt_many_ptr = &opt_many_ptr;
-    var c_ptr: [*c]const [*c]const u8 = ptr_opt_many_ptr;
-    ptr_opt_many_ptr = c_ptr;
-}
-export fn entry2() void {
-    var buf: [4]u8 = "aoeu".*;
-    var slice: []u8 = &buf;
-    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;
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:6:24: error: expected type '*const [*]const u8', found '[*c]const [*c]const u8'
-// tmp.zig:6:24: note: pointer type child '[*c]const u8' cannot cast into pointer type child '[*]const u8'
-// tmp.zig:6:24: note: '[*c]const u8' could have null values which are illegal in type '[*]const u8'
-// tmp.zig:13:35: error: expected type '[*c][*c]const u8', found '*[*]u8'
-// tmp.zig:13:35: note: pointer type child '[*]u8' cannot cast into pointer type child '[*c]const u8'
-// tmp.zig:13:35: note: mutable '[*c]const u8' allows illegal null values stored to type '[*]u8'
diff --git a/test/compile_errors/stage1/obj/implicit_casting_null_c_pointer_to_zig_pointer.zig b/test/compile_errors/stage1/obj/implicit_casting_null_c_pointer_to_zig_pointer.zig
deleted file mode 100644
index 0bd38d868b9bdf2c4f86bff0dec84d06b32b6ee3..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/implicit_casting_null_c_pointer_to_zig_pointer.zig
+++ /dev/null
@@ -1,11 +0,0 @@
-comptime {
-    var c_ptr: [*c]u8 = 0;
-    var zig_ptr: *u8 = c_ptr;
-    _ = zig_ptr;
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:3:24: error: null pointer casted to type '*u8'
diff --git a/test/compile_errors/stage1/obj/implicit_casting_too_big_integers_to_C_pointers.zig b/test/compile_errors/stage1/obj/implicit_casting_too_big_integers_to_C_pointers.zig
deleted file mode 100644
index f142540ff6a13d2143962f9c8fa91249d3b17139..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/implicit_casting_too_big_integers_to_C_pointers.zig
+++ /dev/null
@@ -1,16 +0,0 @@
-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;
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:2:33: error: integer value 18446744073709551617 cannot be coerced to type 'usize'
-// tmp.zig:7:23: error: integer type 'u65' too big for implicit @intToPtr to type '[*c]u8'
diff --git a/test/compile_errors/stage1/obj/implicit_casting_undefined_c_pointer_to_zig_pointer.zig b/test/compile_errors/stage1/obj/implicit_casting_undefined_c_pointer_to_zig_pointer.zig
deleted file mode 100644
index 5554146fa57dd3278dcb1ed933220dd098bf9943..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/implicit_casting_undefined_c_pointer_to_zig_pointer.zig
+++ /dev/null
@@ -1,11 +0,0 @@
-comptime {
-    var c_ptr: [*c]u8 = undefined;
-    var zig_ptr: *u8 = c_ptr;
-    _ = zig_ptr;
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:3:24: error: use of undefined value here causes undefined behavior
diff --git a/test/compile_errors/stage1/obj/implicit_dependency_on_libc.zig b/test/compile_errors/stage1/obj/implicit_dependency_on_libc.zig
deleted file mode 100644
index f069f785517177e26570acbf6665a8d46add25e5..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/implicit_dependency_on_libc.zig
+++ /dev/null
@@ -1,11 +0,0 @@
-extern "c" fn exit(u8) void;
-export fn entry() void {
-    exit(0);
-}
-
-// error
-// backend=stage1
-// target=native-linux
-// is_test=1
-//
-// tmp.zig:3:5: error: dependency on libc must be explicitly specified in the build command
diff --git a/test/compile_errors/stage1/obj/implicit_semicolon-block_expr.zig b/test/compile_errors/stage1/obj/implicit_semicolon-block_expr.zig
deleted file mode 100644
index a57da8ac0bcd7f39226eda704706f9def164a95f..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/implicit_semicolon-block_expr.zig
+++ /dev/null
@@ -1,12 +0,0 @@
-export fn entry() void {
-    _ = {};
-    var good = {};
-    _ = {}
-    var bad = {};
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:4:11: error: expected ';' after statement
diff --git a/test/compile_errors/stage1/obj/implicit_semicolon-block_statement.zig b/test/compile_errors/stage1/obj/implicit_semicolon-block_statement.zig
deleted file mode 100644
index 2d9d850e75d68c19d3b2b949d0440323241e54e6..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/implicit_semicolon-block_statement.zig
+++ /dev/null
@@ -1,12 +0,0 @@
-export fn entry() void {
-    {}
-    var good = {};
-    ({})
-    var bad = {};
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:4:9: error: expected ';' after statement
diff --git a/test/compile_errors/stage1/obj/implicit_semicolon-comptime_expression.zig b/test/compile_errors/stage1/obj/implicit_semicolon-comptime_expression.zig
deleted file mode 100644
index b4cd4de849d90921b1484950ffc05a1715c876bb..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/implicit_semicolon-comptime_expression.zig
+++ /dev/null
@@ -1,12 +0,0 @@
-export fn entry() void {
-    _ = comptime {};
-    var good = {};
-    _ = comptime {}
-    var bad = {};
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:4:20: error: expected ';' after statement
diff --git a/test/compile_errors/stage1/obj/implicit_semicolon-comptime_statement.zig b/test/compile_errors/stage1/obj/implicit_semicolon-comptime_statement.zig
deleted file mode 100644
index 3b83ef92eba02aca1fed39d6f949390bc34756cd..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/implicit_semicolon-comptime_statement.zig
+++ /dev/null
@@ -1,12 +0,0 @@
-export fn entry() void {
-    comptime {}
-    var good = {};
-    comptime ({})
-    var bad = {};
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:4:18: error: expected ';' after statement
diff --git a/test/compile_errors/stage1/obj/implicit_semicolon-defer.zig b/test/compile_errors/stage1/obj/implicit_semicolon-defer.zig
deleted file mode 100644
index 0ded4fcf262b0ae5651cdb52b799dd45f16b4cb8..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/implicit_semicolon-defer.zig
+++ /dev/null
@@ -1,12 +0,0 @@
-export fn entry() void {
-    defer {}
-    var good = {};
-    defer ({})
-    var bad = {};
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:4:15: error: expected ';' after statement
diff --git a/test/compile_errors/stage1/obj/implicit_semicolon-for_expression.zig b/test/compile_errors/stage1/obj/implicit_semicolon-for_expression.zig
deleted file mode 100644
index 964a48d30b9d48d9c5ebcfc60db500ad481d7c0a..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/implicit_semicolon-for_expression.zig
+++ /dev/null
@@ -1,12 +0,0 @@
-export fn entry() void {
-    _ = for(foo()) |_| {};
-    var good = {};
-    _ = for(foo()) |_| {}
-    var bad = {};
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:4:26: error: expected ';' after statement
diff --git a/test/compile_errors/stage1/obj/implicit_semicolon-for_statement.zig b/test/compile_errors/stage1/obj/implicit_semicolon-for_statement.zig
deleted file mode 100644
index 1320e4cc465d2a4926073206c206cb704f114086..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/implicit_semicolon-for_statement.zig
+++ /dev/null
@@ -1,12 +0,0 @@
-export fn entry() void {
-    for(foo()) |_| {}
-    var good = {};
-    for(foo()) |_| ({})
-    var bad = {};
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:4:24: error: expected ';' or 'else' after statement
diff --git a/test/compile_errors/stage1/obj/implicit_semicolon-if-else-if-else_expression.zig b/test/compile_errors/stage1/obj/implicit_semicolon-if-else-if-else_expression.zig
deleted file mode 100644
index 40b1a33d7842ec87537984df767d7dbd299c4fb2..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/implicit_semicolon-if-else-if-else_expression.zig
+++ /dev/null
@@ -1,12 +0,0 @@
-export fn entry() void {
-    _ = if(true) {} else if(true) {} else {};
-    var good = {};
-    _ = if(true) {} else if(true) {} else {}
-    var bad = {};
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:4:45: error: expected ';' after statement
diff --git a/test/compile_errors/stage1/obj/implicit_semicolon-if-else-if-else_statement.zig b/test/compile_errors/stage1/obj/implicit_semicolon-if-else-if-else_statement.zig
deleted file mode 100644
index 8444fe654d528f156f3ef6218c4d6df6ee8440cd..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/implicit_semicolon-if-else-if-else_statement.zig
+++ /dev/null
@@ -1,12 +0,0 @@
-export fn entry() void {
-    if(true) {} else if(true) {} else {}
-    var good = {};
-    if(true) ({}) else if(true) ({}) else ({})
-    var bad = {};
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:4:47: error: expected ';' after statement
diff --git a/test/compile_errors/stage1/obj/implicit_semicolon-if-else-if_expression.zig b/test/compile_errors/stage1/obj/implicit_semicolon-if-else-if_expression.zig
deleted file mode 100644
index 7466d646915b29987f3c79d9e1c7e6b1c3e252dc..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/implicit_semicolon-if-else-if_expression.zig
+++ /dev/null
@@ -1,12 +0,0 @@
-export fn entry() void {
-    _ = if(true) {} else if(true) {};
-    var good = {};
-    _ = if(true) {} else if(true) {}
-    var bad = {};
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:4:37: error: expected ';' after statement
diff --git a/test/compile_errors/stage1/obj/implicit_semicolon-if-else-if_statement.zig b/test/compile_errors/stage1/obj/implicit_semicolon-if-else-if_statement.zig
deleted file mode 100644
index 34e116b3f7840cf552e37ae0e064ef7527e2b51d..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/implicit_semicolon-if-else-if_statement.zig
+++ /dev/null
@@ -1,12 +0,0 @@
-export fn entry() void {
-    if(true) {} else if(true) {}
-    var good = {};
-    if(true) ({}) else if(true) ({})
-    var bad = {};
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:4:37: error: expected ';' or 'else' after statement
diff --git a/test/compile_errors/stage1/obj/implicit_semicolon-if-else_expression.zig b/test/compile_errors/stage1/obj/implicit_semicolon-if-else_expression.zig
deleted file mode 100644
index 3c1e0add62bc1519a6ed4e83ea7f96c7896dcf58..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/implicit_semicolon-if-else_expression.zig
+++ /dev/null
@@ -1,12 +0,0 @@
-export fn entry() void {
-    _ = if(true) {} else {};
-    var good = {};
-    _ = if(true) {} else {}
-    var bad = {};
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:4:28: error: expected ';' after statement
diff --git a/test/compile_errors/stage1/obj/implicit_semicolon-if-else_statement.zig b/test/compile_errors/stage1/obj/implicit_semicolon-if-else_statement.zig
deleted file mode 100644
index e9c52fb6bb36f96388e9cd9f14904a6e31b36354..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/implicit_semicolon-if-else_statement.zig
+++ /dev/null
@@ -1,12 +0,0 @@
-export fn entry() void {
-    if(true) {} else {}
-    var good = {};
-    if(true) ({}) else ({})
-    var bad = {};
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:4:28: error: expected ';' after statement
diff --git a/test/compile_errors/stage1/obj/implicit_semicolon-if_expression.zig b/test/compile_errors/stage1/obj/implicit_semicolon-if_expression.zig
deleted file mode 100644
index 2082588e0e9ab0a99fd4d42a3887f7172eda5bd8..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/implicit_semicolon-if_expression.zig
+++ /dev/null
@@ -1,12 +0,0 @@
-export fn entry() void {
-    _ = if(true) {};
-    var good = {};
-    _ = if(true) {}
-    var bad = {};
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:4:20: error: expected ';' after statement
diff --git a/test/compile_errors/stage1/obj/implicit_semicolon-if_statement.zig b/test/compile_errors/stage1/obj/implicit_semicolon-if_statement.zig
deleted file mode 100644
index 26cefd0237836ea9434f7e2675a93ab86b02f16c..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/implicit_semicolon-if_statement.zig
+++ /dev/null
@@ -1,12 +0,0 @@
-export fn entry() void {
-    if(true) {}
-    var good = {};
-    if(true) ({})
-    var bad = {};
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:4:18: error: expected ';' or 'else' after statement
diff --git a/test/compile_errors/stage1/obj/implicit_semicolon-test_expression.zig b/test/compile_errors/stage1/obj/implicit_semicolon-test_expression.zig
deleted file mode 100644
index c31f3520c1b57738f6e1613f0a05baa65d7dc45f..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/implicit_semicolon-test_expression.zig
+++ /dev/null
@@ -1,12 +0,0 @@
-export fn entry() void {
-    _ = if (foo()) |_| {};
-    var good = {};
-    _ = if (foo()) |_| {}
-    var bad = {};
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:4:26: error: expected ';' after statement
diff --git a/test/compile_errors/stage1/obj/implicit_semicolon-test_statement.zig b/test/compile_errors/stage1/obj/implicit_semicolon-test_statement.zig
deleted file mode 100644
index 8abb1cbcb1ee34fc719e8b5b02e34c1efbb13b7b..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/implicit_semicolon-test_statement.zig
+++ /dev/null
@@ -1,12 +0,0 @@
-export fn entry() void {
-    if (foo()) |_| {}
-    var good = {};
-    if (foo()) |_| ({})
-    var bad = {};
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:4:24: error: expected ';' or 'else' after statement
diff --git a/test/compile_errors/stage1/obj/implicit_semicolon-while-continue_expression.zig b/test/compile_errors/stage1/obj/implicit_semicolon-while-continue_expression.zig
deleted file mode 100644
index 4d3219eb66b8f67129d3485ff6f620eadd86af5f..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/implicit_semicolon-while-continue_expression.zig
+++ /dev/null
@@ -1,12 +0,0 @@
-export fn entry() void {
-    _ = while(true):({}) {};
-    var good = {};
-    _ = while(true):({}) {}
-    var bad = {};
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:4:28: error: expected ';' after statement
diff --git a/test/compile_errors/stage1/obj/implicit_semicolon-while-continue_statement.zig b/test/compile_errors/stage1/obj/implicit_semicolon-while-continue_statement.zig
deleted file mode 100644
index c0b3370357204bb007ae7d3e15e621be46b00d2a..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/implicit_semicolon-while-continue_statement.zig
+++ /dev/null
@@ -1,12 +0,0 @@
-export fn entry() void {
-    while(true):({}) {}
-    var good = {};
-    while(true):({}) ({})
-    var bad = {};
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:4:26: error: expected ';' or 'else' after statement
diff --git a/test/compile_errors/stage1/obj/implicit_semicolon-while_expression.zig b/test/compile_errors/stage1/obj/implicit_semicolon-while_expression.zig
deleted file mode 100644
index 39f49319d5044ae5cdb1f90534783ca30c711203..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/implicit_semicolon-while_expression.zig
+++ /dev/null
@@ -1,12 +0,0 @@
-export fn entry() void {
-    _ = while(true) {};
-    var good = {};
-    _ = while(true) {}
-    var bad = {};
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:4:23: error: expected ';' after statement
diff --git a/test/compile_errors/stage1/obj/implicit_semicolon-while_statement.zig b/test/compile_errors/stage1/obj/implicit_semicolon-while_statement.zig
deleted file mode 100644
index 6c253ecf56374e9fa886a1c87f7f167555d991e0..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/implicit_semicolon-while_statement.zig
+++ /dev/null
@@ -1,12 +0,0 @@
-export fn entry() void {
-    while(true) {}
-    var good = {};
-    while(true) 1
-    var bad = {};
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:4:18: error: expected ';' or 'else' after statement
diff --git a/test/compile_errors/stage1/obj/implicitly_casting_enum_to_tag_type.zig b/test/compile_errors/stage1/obj/implicitly_casting_enum_to_tag_type.zig
deleted file mode 100644
index a40615f99b09a5cd0a92372454c33244967c7e29..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/implicitly_casting_enum_to_tag_type.zig
+++ /dev/null
@@ -1,17 +0,0 @@
-const Small = enum(u2) {
-    One,
-    Two,
-    Three,
-    Four,
-};
-
-export fn entry() void {
-    var x: u2 = Small.Two;
-    _ = x;
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:9:22: error: expected type 'u2', found 'Small'
diff --git a/test/compile_errors/stage1/obj/implicitly_increasing_pointer_alignment.zig b/test/compile_errors/stage1/obj/implicitly_increasing_pointer_alignment.zig
deleted file mode 100644
index 3743eef0b2fceebbf3c4e5149b8a2cd3fc642b5e..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/implicitly_increasing_pointer_alignment.zig
+++ /dev/null
@@ -1,19 +0,0 @@
-const Foo = packed struct {
-    a: u8,
-    b: u32,
-};
-
-export fn entry() void {
-    var foo = Foo { .a = 1, .b = 10 };
-    bar(&foo.b);
-}
-
-fn bar(x: *u32) void {
-    x.* += 1;
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:8:13: error: expected type '*u32', found '*align(1) u32'
diff --git a/test/compile_errors/stage1/obj/implicitly_increasing_slice_alignment.zig b/test/compile_errors/stage1/obj/implicitly_increasing_slice_alignment.zig
deleted file mode 100644
index 2e5c201b5dac591e401bdd68358a7dceeeeff877..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/implicitly_increasing_slice_alignment.zig
+++ /dev/null
@@ -1,22 +0,0 @@
-const Foo = packed struct {
-    a: u8,
-    b: u32,
-};
-
-export fn entry() void {
-    var foo = Foo { .a = 1, .b = 10 };
-    foo.b += 1;
-    bar(@as(*[1]u32, &foo.b)[0..]);
-}
-
-fn bar(x: []u32) void {
-    x[0] += 1;
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:9:26: error: cast increases pointer alignment
-// tmp.zig:9:26: note: '*align(1) u32' has alignment 1
-// tmp.zig:9:26: note: '*[1]u32' has alignment 4
diff --git a/test/compile_errors/stage1/obj/import_outside_package_path.zig b/test/compile_errors/stage1/obj/import_outside_package_path.zig
deleted file mode 100644
index 5a712c2e0116dfb3ebce9c1b9db79859941897d2..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/import_outside_package_path.zig
+++ /dev/null
@@ -1,9 +0,0 @@
-comptime{
-    _ = @import("../a.zig");
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:2:9: error: import of file outside package path: '../a.zig'
diff --git a/test/compile_errors/stage1/obj/incompatible_sentinels.zig b/test/compile_errors/stage1/obj/incompatible_sentinels.zig
deleted file mode 100644
index a292ae3d7c9700713c4037ef3333560cda91d672..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/incompatible_sentinels.zig
+++ /dev/null
@@ -1,29 +0,0 @@
-// 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.
-export fn entry1(ptr: [*:255]u8) [*:0]u8 {
-    return ptr;
-}
-export fn entry2(ptr: [*]u8) [*:0]u8 {
-    return ptr;
-}
-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;
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:4:12: error: expected type '[*:0]u8', found '[*:255]u8'
-// tmp.zig:4:12: note: destination pointer requires a terminating '0' sentinel, but source pointer has a terminating '255' sentinel
-// tmp.zig:7:12: error: expected type '[*:0]u8', found '[*]u8'
-// tmp.zig:7:12: note: destination pointer requires a terminating '0' sentinel
-// tmp.zig:10:35: error: expected type '[2:255]u8', found '[2:0]u8'
-// tmp.zig:10:35: note: destination array requires a terminating '255' sentinel, but source array has a terminating '0' sentinel
-// tmp.zig:14:31: error: expected type '[2:0]u8', found '[2]u8'
-// tmp.zig:14:31: note: destination array requires a terminating '0' sentinel
diff --git a/test/compile_errors/stage1/obj/incorrect_return_type.zig b/test/compile_errors/stage1/obj/incorrect_return_type.zig
deleted file mode 100644
index b25e2a8ea46a8cfd0768cd782cd047f93d442c02..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/incorrect_return_type.zig
+++ /dev/null
@@ -1,21 +0,0 @@
- pub export fn entry() void{
-     _ = foo();
- }
- const A = struct {
-     a: u32,
- };
- fn foo() A {
-     return bar();
- }
- const B = struct {
-     a: u32,
- };
- fn bar() B {
-     unreachable;
- }
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:8:16: error: expected type 'A', found 'B'
diff --git a/test/compile_errors/stage1/obj/increase_pointer_alignment_in_ptrCast.zig b/test/compile_errors/stage1/obj/increase_pointer_alignment_in_ptrCast.zig
deleted file mode 100644
index f3f67ca4c657f43eba8741833e83ad469610f3c9..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/increase_pointer_alignment_in_ptrCast.zig
+++ /dev/null
@@ -1,13 +0,0 @@
-export fn entry() u32 {
-    var bytes: [4]u8 = [_]u8{0x01, 0x02, 0x03, 0x04};
-    const ptr = @ptrCast(*u32, &bytes[0]);
-    return ptr.*;
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:3:17: error: cast increases pointer alignment
-// tmp.zig:3:38: note: '*u8' has alignment 1
-// tmp.zig:3:26: note: '*u32' has alignment 4
diff --git a/test/compile_errors/stage1/obj/indexing_a_undefined_slice_at_comptime.zig b/test/compile_errors/stage1/obj/indexing_a_undefined_slice_at_comptime.zig
deleted file mode 100644
index 70b0c68658578c3d677a82cabe80c492eac2453a..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/indexing_a_undefined_slice_at_comptime.zig
+++ /dev/null
@@ -1,10 +0,0 @@
-comptime {
-    var slice: []u8 = undefined;
-    slice[0] = 2;
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:3:10: error: index 0 outside slice of size 0
diff --git a/test/compile_errors/stage1/obj/indexing_an_array_of_size_zero.zig b/test/compile_errors/stage1/obj/indexing_an_array_of_size_zero.zig
deleted file mode 100644
index dfb2e7c1c314a1202f7f3348218b3b0064ed27d6..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/indexing_an_array_of_size_zero.zig
+++ /dev/null
@@ -1,11 +0,0 @@
-const array = [_]u8{};
-export fn foo() void {
-    const pointer = &array[0];
-    _ = pointer;
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:3:27: error: accessing a zero length array is not allowed
diff --git a/test/compile_errors/stage1/obj/indexing_an_array_of_size_zero_with_runtime_index.zig b/test/compile_errors/stage1/obj/indexing_an_array_of_size_zero_with_runtime_index.zig
deleted file mode 100644
index f50931312e6e50e0f1dfe40463f2fe6b53c6bab1..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/indexing_an_array_of_size_zero_with_runtime_index.zig
+++ /dev/null
@@ -1,12 +0,0 @@
-const array = [_]u8{};
-export fn foo() void {
-    var index: usize = 0;
-    const pointer = &array[index];
-    _ = pointer;
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:4:27: error: accessing a zero length array is not allowed
diff --git a/test/compile_errors/stage1/obj/indexing_single-item_pointer.zig b/test/compile_errors/stage1/obj/indexing_single-item_pointer.zig
deleted file mode 100644
index bc7951ec963c0076ca7fdb19816ce4c72ff28368..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/indexing_single-item_pointer.zig
+++ /dev/null
@@ -1,9 +0,0 @@
-export fn entry(ptr: *i32) i32 {
-    return ptr[1];
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:2:15: error: index of single-item pointer
diff --git a/test/compile_errors/stage1/obj/indirect_recursion_of_async_functions_detected.zig b/test/compile_errors/stage1/obj/indirect_recursion_of_async_functions_detected.zig
deleted file mode 100644
index d845dc7930a73e4c85f24b57f9c6432a64bae4d3..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/indirect_recursion_of_async_functions_detected.zig
+++ /dev/null
@@ -1,36 +0,0 @@
-var frame: ?anyframe = null;
-
-export fn a() void {
-    _ = async rangeSum(10);
-    while (frame) |f| resume f;
-}
-
-fn rangeSum(x: i32) i32 {
-    suspend {
-        frame = @frame();
-    }
-    frame = null;
-
-    if (x == 0) return 0;
-    var child = rangeSumIndirect(x - 1);
-    return child + 1;
-}
-
-fn rangeSumIndirect(x: i32) i32 {
-    suspend {
-        frame = @frame();
-    }
-    frame = null;
-
-    if (x == 0) return 0;
-    var child = rangeSum(x - 1);
-    return child + 1;
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:8:1: error: '@Frame(rangeSum)' depends on itself
-// tmp.zig:15:33: note: when analyzing type '@Frame(rangeSum)' here
-// tmp.zig:26:25: note: when analyzing type '@Frame(rangeSumIndirect)' here
diff --git a/test/compile_errors/stage1/obj/indirect_struct_loop.zig b/test/compile_errors/stage1/obj/indirect_struct_loop.zig
deleted file mode 100644
index 12214923d089e642631c4b8c169153eccd23b5e1..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/indirect_struct_loop.zig
+++ /dev/null
@@ -1,10 +0,0 @@
-const A = struct { b : B, };
-const B = struct { c : C, };
-const C = struct { a : A, };
-export fn entry() usize { return @sizeOf(A); }
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:1:11: error: struct 'A' depends on itself
diff --git a/test/compile_errors/stage1/obj/inferred_array_size_invalid_here.zig b/test/compile_errors/stage1/obj/inferred_array_size_invalid_here.zig
deleted file mode 100644
index 2b2d944eab15d5a6cff927d91cb2c8ffc679dbc1..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/inferred_array_size_invalid_here.zig
+++ /dev/null
@@ -1,16 +0,0 @@
-export fn entry() void {
-    const x = [_]u8;
-    _ = x;
-}
-export fn entry2() void {
-    const S = struct { a: *const [_]u8 };
-    var a = .{ S{} };
-    _ = a;
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:2:16: error: unable to infer array size
-// tmp.zig:6:35: error: unable to infer array size
diff --git a/test/compile_errors/stage1/obj/inferring_error_set_of_function_pointer.zig b/test/compile_errors/stage1/obj/inferring_error_set_of_function_pointer.zig
deleted file mode 100644
index b91242322d46db9edca71c412c9d46de7176d604..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/inferring_error_set_of_function_pointer.zig
+++ /dev/null
@@ -1,9 +0,0 @@
-comptime {
-    const z: ?fn()!void = null;
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:2:19: error: function prototype may not have inferred error set
diff --git a/test/compile_errors/stage1/obj/initializing_array_with_struct_syntax.zig b/test/compile_errors/stage1/obj/initializing_array_with_struct_syntax.zig
deleted file mode 100644
index 2884c6193e53fccb46f4fe6bf3bbc91561a2b3b4..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/initializing_array_with_struct_syntax.zig
+++ /dev/null
@@ -1,10 +0,0 @@
-export fn entry() void {
-    const x = [_]u8{ .y = 2 };
-    _ = x;
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:2:15: error: initializing array with struct syntax
diff --git a/test/compile_errors/stage1/obj/instantiating_an_undefined_value_for_an_invalid_struct_that_contains_itself.zig b/test/compile_errors/stage1/obj/instantiating_an_undefined_value_for_an_invalid_struct_that_contains_itself.zig
deleted file mode 100644
index dd6909b1c22a2db543f7f1390dfc96a1fc3186b0..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/instantiating_an_undefined_value_for_an_invalid_struct_that_contains_itself.zig
+++ /dev/null
@@ -1,15 +0,0 @@
-const Foo = struct {
-    x: Foo,
-};
-
-var foo: Foo = undefined;
-
-export fn entry() usize {
-    return @sizeOf(@TypeOf(foo.x));
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:1:13: error: struct 'Foo' depends on itself
diff --git a/test/compile_errors/stage1/obj/intToPtr_with_misaligned_address.zig b/test/compile_errors/stage1/obj/intToPtr_with_misaligned_address.zig
deleted file mode 100644
index 16b6bf565e0d20f69b490bc66d81fc2e17e5106b..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/intToPtr_with_misaligned_address.zig
+++ /dev/null
@@ -1,10 +0,0 @@
-pub fn main() void {
-    var y = @intToPtr([*]align(4) u8, 5);
-    _ = y;
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:2:13: error: pointer type '[*]align(4) u8' requires aligned address
diff --git a/test/compile_errors/stage1/obj/int_to_err_global_invalid_number.zig b/test/compile_errors/stage1/obj/int_to_err_global_invalid_number.zig
deleted file mode 100644
index 5c078a751cc9d89c0ac97b969bc653afb6d0bc56..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/int_to_err_global_invalid_number.zig
+++ /dev/null
@@ -1,15 +0,0 @@
-const Set1 = error{
-    A,
-    B,
-};
-comptime {
-    var x: u16 = 3;
-    var y = @intToError(x);
-    _ = y;
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:7:13: error: integer value 3 represents no error
diff --git a/test/compile_errors/stage1/obj/int_to_err_non_global_invalid_number.zig b/test/compile_errors/stage1/obj/int_to_err_non_global_invalid_number.zig
deleted file mode 100644
index 8c1e547746efb84b01daaa858b437ea861076bbd..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/int_to_err_non_global_invalid_number.zig
+++ /dev/null
@@ -1,19 +0,0 @@
-const Set1 = error{
-    A,
-    B,
-};
-const Set2 = error{
-    A,
-    C,
-};
-comptime {
-    var x = @errorToInt(Set1.B);
-    var y = @errSetCast(Set2, @intToError(x));
-    _ = y;
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:11:13: error: error.B not a member of error set 'Set2'
diff --git a/test/compile_errors/stage1/obj/int_to_ptr_of_0_bits.zig b/test/compile_errors/stage1/obj/int_to_ptr_of_0_bits.zig
deleted file mode 100644
index 7b65cdf836eb711121f72c81f20697d8d4dc413c..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/int_to_ptr_of_0_bits.zig
+++ /dev/null
@@ -1,11 +0,0 @@
-export fn foo() void {
-    var x: usize = 0x1000;
-    var y: *void = @intToPtr(*void, x);
-    _ = y;
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:3:30: error: type '*void' has 0 bits and cannot store information
diff --git a/test/compile_errors/stage1/obj/integer_cast_truncates_bits.zig b/test/compile_errors/stage1/obj/integer_cast_truncates_bits.zig
deleted file mode 100644
index e8ef41862430fc667c6e63c74298519c4caa5a94..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/integer_cast_truncates_bits.zig
+++ /dev/null
@@ -1,31 +0,0 @@
-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;
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:3:18: error: cast from 'u16' to 'u8' truncates bits
-// tmp.zig:8:22: error: integer value 300 cannot be coerced to type 'u8'
-// tmp.zig:13:20: error: expected type 'u8', found 'u16'
-// tmp.zig:13:20: note: unsigned 8-bit int cannot represent all possible unsigned 16-bit values
-// tmp.zig:18:25: error: expected type 'u64', found 'i8'
-// tmp.zig:18:25: note: unsigned 64-bit int cannot represent all possible signed 8-bit values
diff --git a/test/compile_errors/stage1/obj/integer_overflow_error.zig b/test/compile_errors/stage1/obj/integer_overflow_error.zig
deleted file mode 100644
index 117d77ed938c8a4d0d7b5986fc50bf38999b26ba..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/integer_overflow_error.zig
+++ /dev/null
@@ -1,8 +0,0 @@
-const x : u8 = 300;
-export fn entry() usize { return @sizeOf(@TypeOf(x)); }
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:1:16: error: integer value 300 cannot be coerced to type 'u8'
diff --git a/test/compile_errors/stage1/obj/integer_underflow_error.zig b/test/compile_errors/stage1/obj/integer_underflow_error.zig
deleted file mode 100644
index 15bd4c472bd3e9979908188e28bf7d7054f1ad26..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/integer_underflow_error.zig
+++ /dev/null
@@ -1,9 +0,0 @@
-export fn entry() void {
-    _ = @intToPtr(*anyopaque, ~@as(usize, @import("std").math.maxInt(usize)) - 1);
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// :2:78: error: operation caused overflow
diff --git a/test/compile_errors/stage1/obj/invalid_break_expression.zig b/test/compile_errors/stage1/obj/invalid_break_expression.zig
deleted file mode 100644
index efb76a34f7b7d5b434a4376e892d6874ce8bb413..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/invalid_break_expression.zig
+++ /dev/null
@@ -1,9 +0,0 @@
-export fn f() void {
-    break;
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:2:5: error: break expression outside loop
diff --git a/test/compile_errors/stage1/obj/invalid_builtin_fn.zig b/test/compile_errors/stage1/obj/invalid_builtin_fn.zig
deleted file mode 100644
index 8f0e3633bb35a07a91e65d3242470c4ed655d0c8..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/invalid_builtin_fn.zig
+++ /dev/null
@@ -1,9 +0,0 @@
-fn f() @bogus(foo) {
-}
-export fn entry() void { _ = f(); }
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:1:8: error: invalid builtin function: '@bogus'
diff --git a/test/compile_errors/stage1/obj/invalid_cast_from_integral_type_to_enum.zig b/test/compile_errors/stage1/obj/invalid_cast_from_integral_type_to_enum.zig
deleted file mode 100644
index 81dbd88e3b1b24a2a4019cb4bf9b90a879f50916..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/invalid_cast_from_integral_type_to_enum.zig
+++ /dev/null
@@ -1,17 +0,0 @@
-const E = enum(usize) { One, Two };
-
-export fn entry() void {
-    foo(1);
-}
-
-fn foo(x: usize) void {
-    switch (x) {
-        E.One => {},
-    }
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:9:10: error: expected type 'usize', found 'E'
diff --git a/test/compile_errors/stage1/obj/invalid_comparison_for_function_pointers.zig b/test/compile_errors/stage1/obj/invalid_comparison_for_function_pointers.zig
deleted file mode 100644
index 6d64b6cdaf938620f99f05c5be8e77ee5239d19c..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/invalid_comparison_for_function_pointers.zig
+++ /dev/null
@@ -1,10 +0,0 @@
-fn foo() void {}
-const invalid = foo > foo;
-
-export fn entry() usize { return @sizeOf(@TypeOf(invalid)); }
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:2:21: error: operator not allowed for type 'fn() void'
diff --git a/test/compile_errors/stage1/obj/invalid_continue_expression.zig b/test/compile_errors/stage1/obj/invalid_continue_expression.zig
deleted file mode 100644
index 00f3c5a3d56f4b7d8c67112e670c62f5da41a3b2..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/invalid_continue_expression.zig
+++ /dev/null
@@ -1,9 +0,0 @@
-export fn f() void {
-    continue;
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:2:5: error: continue expression outside loop
diff --git a/test/compile_errors/stage1/obj/invalid_deref_on_switch_target.zig b/test/compile_errors/stage1/obj/invalid_deref_on_switch_target.zig
deleted file mode 100644
index 966a881543304a501d5a9f5b0db62d93e9caa65d..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/invalid_deref_on_switch_target.zig
+++ /dev/null
@@ -1,17 +0,0 @@
-comptime {
-    var tile = Tile.Empty;
-    switch (tile.*) {
-        Tile.Empty => {},
-        Tile.Filled => {},
-    }
-}
-const Tile = enum {
-    Empty,
-    Filled,
-};
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:3:17: error: attempt to dereference non-pointer type 'Tile'
diff --git a/test/compile_errors/stage1/obj/invalid_empty_unicode_escape.zig b/test/compile_errors/stage1/obj/invalid_empty_unicode_escape.zig
deleted file mode 100644
index 57dd16a63def4ef8e2197786f4d0f7d05d8b3f0d..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/invalid_empty_unicode_escape.zig
+++ /dev/null
@@ -1,9 +0,0 @@
-export fn entry() void {
-    const a = '\u{}';
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:2:19: error: empty unicode escape sequence
diff --git a/test/compile_errors/stage1/obj/invalid_exponent_in_float_literal-1.zig b/test/compile_errors/stage1/obj/invalid_exponent_in_float_literal-1.zig
deleted file mode 100644
index 431401c53421868fcb5e7087b57e2a5fd57cee58..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/invalid_exponent_in_float_literal-1.zig
+++ /dev/null
@@ -1,11 +0,0 @@
-fn main() void {
-    var bad: f128 = 0x1.0p1ab1;
-    _ = bad;
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:2:21: error: expected expression, found 'invalid bytes'
-// tmp.zig:2:28: note: invalid byte: 'a'
diff --git a/test/compile_errors/stage1/obj/invalid_exponent_in_float_literal-2.zig b/test/compile_errors/stage1/obj/invalid_exponent_in_float_literal-2.zig
deleted file mode 100644
index 088b43546c64a1aa67af3d734f22dbcc9267dae2..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/invalid_exponent_in_float_literal-2.zig
+++ /dev/null
@@ -1,11 +0,0 @@
-fn main() void {
-    var bad: f128 = 0x1.0p50F;
-    _ = bad;
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:2:21: error: expected expression, found 'invalid bytes'
-// tmp.zig:2:29: note: invalid byte: 'F'
diff --git a/test/compile_errors/stage1/obj/invalid_field_access_in_comptime.zig b/test/compile_errors/stage1/obj/invalid_field_access_in_comptime.zig
deleted file mode 100644
index 2630a704ed49224a36ae7972196dc8f7a416a573..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/invalid_field_access_in_comptime.zig
+++ /dev/null
@@ -1,7 +0,0 @@
-comptime { var x = doesnt_exist.whatever; _ = x; }
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:1:20: error: use of undeclared identifier 'doesnt_exist'
diff --git a/test/compile_errors/stage1/obj/invalid_field_in_struct_value_expression.zig b/test/compile_errors/stage1/obj/invalid_field_in_struct_value_expression.zig
deleted file mode 100644
index fae0a90b518cc0c701edbd144cb6d7077b472beb..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/invalid_field_in_struct_value_expression.zig
+++ /dev/null
@@ -1,19 +0,0 @@
-const A = struct {
-    x : i32,
-    y : i32,
-    z : i32,
-};
-export fn f() void {
-    const a = A {
-        .z = 4,
-        .y = 2,
-        .foo = 42,
-    };
-    _ = a;
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:10:9: error: no member named 'foo' in struct 'A'
diff --git a/test/compile_errors/stage1/obj/invalid_float_literal.zig b/test/compile_errors/stage1/obj/invalid_float_literal.zig
deleted file mode 100644
index 709609a027a5ebf4464aa21f4f29a351d121d70b..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/invalid_float_literal.zig
+++ /dev/null
@@ -1,13 +0,0 @@
-const std = @import("std");
-
-pub fn main() void {
-    var bad_float :f32 = 0.0;
-    bad_float = bad_float + .20;
-    std.debug.assert(bad_float < 1.0);
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:5:29: error: expected expression, found '.'
diff --git a/test/compile_errors/stage1/obj/invalid_legacy_unicode_escape.zig b/test/compile_errors/stage1/obj/invalid_legacy_unicode_escape.zig
deleted file mode 100644
index b81a814a604ac77c001f133b611b539bb1a55ec0..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/invalid_legacy_unicode_escape.zig
+++ /dev/null
@@ -1,10 +0,0 @@
-export fn entry() void {
-    const a = '\U1234';
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:2:15: error: expected expression, found 'invalid bytes'
-// tmp.zig:2:18: note: invalid byte: '1'
diff --git a/test/compile_errors/stage1/obj/invalid_maybe_type.zig b/test/compile_errors/stage1/obj/invalid_maybe_type.zig
deleted file mode 100644
index cb075c36b7139b2fce5fcc688d646e848971fa16..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/invalid_maybe_type.zig
+++ /dev/null
@@ -1,9 +0,0 @@
-export fn f() void {
-    if (true) |x| { _ = x; }
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:2:9: error: expected optional type, found 'bool'
diff --git a/test/compile_errors/stage1/obj/invalid_member_of_builtin_enum.zig b/test/compile_errors/stage1/obj/invalid_member_of_builtin_enum.zig
deleted file mode 100644
index 166ebfc78260858195378552ce4464c49967c7b0..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/invalid_member_of_builtin_enum.zig
+++ /dev/null
@@ -1,11 +0,0 @@
-const builtin = @import("std").builtin;
-export fn entry() void {
-    const foo = builtin.Mode.x86;
-    _ = foo;
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:3:29: error: container 'std.builtin.Mode' has no member called 'x86'
diff --git a/test/compile_errors/stage1/obj/invalid_multiple_dereferences.zig b/test/compile_errors/stage1/obj/invalid_multiple_dereferences.zig
deleted file mode 100644
index f8a0b8013f0ccbaa8e1519cf013932b0ce607a18..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/invalid_multiple_dereferences.zig
+++ /dev/null
@@ -1,19 +0,0 @@
-export fn a() void {
-    var box = Box{ .field = 0 };
-    box.*.field = 1;
-}
-export fn b() void {
-    var box = Box{ .field = 0 };
-    var boxPtr = &box;
-    boxPtr.*.*.field = 1;
-}
-pub const Box = struct {
-    field: i32,
-};
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:3:8: error: attempt to dereference non-pointer type 'Box'
-// tmp.zig:8:13: error: attempt to dereference non-pointer type 'Box'
diff --git a/test/compile_errors/stage1/obj/invalid_optional_type_in_extern_struct.zig b/test/compile_errors/stage1/obj/invalid_optional_type_in_extern_struct.zig
deleted file mode 100644
index dc2e2690b8cf539a80c86089f2ee34c029c888ca..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/invalid_optional_type_in_extern_struct.zig
+++ /dev/null
@@ -1,10 +0,0 @@
-const stroo = extern struct {
-    moo: ?[*c]u8,
-};
-export fn testf(fluff: *stroo) void { _ = fluff; }
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:2:5: error: extern structs cannot contain fields of type '?[*c]u8'
diff --git a/test/compile_errors/stage1/obj/invalid_pointer_for_var_type.zig b/test/compile_errors/stage1/obj/invalid_pointer_for_var_type.zig
deleted file mode 100644
index caf8c707975612901866ee4d53836b491436258d..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/invalid_pointer_for_var_type.zig
+++ /dev/null
@@ -1,13 +0,0 @@
-extern fn ext() usize;
-var bytes: [ext()]u8 = undefined;
-export fn f() void {
-    for (bytes) |*b, i| {
-        b.* = @as(u8, i);
-    }
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:2:13: error: unable to evaluate constant expression
diff --git a/test/compile_errors/stage1/obj/invalid_pointer_syntax.zig b/test/compile_errors/stage1/obj/invalid_pointer_syntax.zig
deleted file mode 100644
index a4c823bde1a755b70782643ab988ff2a9db6bfb7..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/invalid_pointer_syntax.zig
+++ /dev/null
@@ -1,9 +0,0 @@
-export fn foo() void {
-    var guid: *:0 const u8 = undefined;
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:2:16: error: expected type expression, found ':'
diff --git a/test/compile_errors/stage1/obj/invalid_shift_amount_error.zig b/test/compile_errors/stage1/obj/invalid_shift_amount_error.zig
deleted file mode 100644
index 7c84f2db38d98bdd31b22600e299233499810bf9..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/invalid_shift_amount_error.zig
+++ /dev/null
@@ -1,11 +0,0 @@
-const x : u8 = 2;
-fn f() u16 {
-    return x << 8;
-}
-export fn entry() u16 { return f(); }
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:3:17: error: integer value 8 cannot be coerced to type 'u3'
diff --git a/test/compile_errors/stage1/obj/invalid_struct_field.zig b/test/compile_errors/stage1/obj/invalid_struct_field.zig
deleted file mode 100644
index 6264125bca531e2e83e0c9b908842441e11ddf95..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/invalid_struct_field.zig
+++ /dev/null
@@ -1,19 +0,0 @@
-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;
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:4:6: error: no member named 'foo' in struct 'A'
-// tmp.zig:10:16: error: no member named 'bar' in struct 'A'
diff --git a/test/compile_errors/stage1/obj/invalid_suspend_in_exported_function.zig b/test/compile_errors/stage1/obj/invalid_suspend_in_exported_function.zig
deleted file mode 100644
index cfcbfba889dfd57b1260ee14df08d354f4973de4..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/invalid_suspend_in_exported_function.zig
+++ /dev/null
@@ -1,15 +0,0 @@
-export fn entry() void {
-    var frame = async func();
-    var result = await frame;
-    _ = result;
-}
-fn func() void {
-    suspend {}
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:1:1: error: function with calling convention 'C' cannot be async
-// tmp.zig:3:18: note: await here is a suspend point
diff --git a/test/compile_errors/stage1/obj/invalid_type.zig b/test/compile_errors/stage1/obj/invalid_type.zig
deleted file mode 100644
index 8a2952e5f2c32346811eb3a50dd399b7046a0a52..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/invalid_type.zig
+++ /dev/null
@@ -1,8 +0,0 @@
-fn a() bogus {}
-export fn entry() void { _ = a(); }
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:1:8: error: use of undeclared identifier 'bogus'
diff --git a/test/compile_errors/stage1/obj/invalid_type_used_in_array_type.zig b/test/compile_errors/stage1/obj/invalid_type_used_in_array_type.zig
deleted file mode 100644
index 3a7bc4272c04807cdd437948bc6b2af9021e4362..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/invalid_type_used_in_array_type.zig
+++ /dev/null
@@ -1,14 +0,0 @@
-const Item = struct {
-    field: SomeNonexistentType,
-};
-var items: [100]Item = undefined;
-export fn entry() void {
-    const a = items[0];
-    _ = a;
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:2:12: error: use of undeclared identifier 'SomeNonexistentType'
diff --git a/test/compile_errors/stage1/obj/invalid_underscore_placement_in_float_literal-1.zig b/test/compile_errors/stage1/obj/invalid_underscore_placement_in_float_literal-1.zig
deleted file mode 100644
index a3e2827f3141bd39c163dffcf77ec5061d782301..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/invalid_underscore_placement_in_float_literal-1.zig
+++ /dev/null
@@ -1,11 +0,0 @@
-fn main() void {
-    var bad: f128 = 0._0;
-    _ = bad;
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:2:21: error: expected expression, found 'invalid bytes'
-// tmp.zig:2:23: note: invalid byte: '_'
diff --git a/test/compile_errors/stage1/obj/invalid_underscore_placement_in_float_literal-10.zig b/test/compile_errors/stage1/obj/invalid_underscore_placement_in_float_literal-10.zig
deleted file mode 100644
index 7d33244483322d15183a2388740db14d4147dbdd..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/invalid_underscore_placement_in_float_literal-10.zig
+++ /dev/null
@@ -1,11 +0,0 @@
-fn main() void {
-    var bad: f128 = 1.0__0e-1;
-    _ = bad;
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:2:21: error: expected expression, found 'invalid bytes'
-// tmp.zig:2:25: note: invalid byte: '_'
diff --git a/test/compile_errors/stage1/obj/invalid_underscore_placement_in_float_literal-11.zig b/test/compile_errors/stage1/obj/invalid_underscore_placement_in_float_literal-11.zig
deleted file mode 100644
index fa4f5b8975f619a123e2c9a297d9a09c5587b981..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/invalid_underscore_placement_in_float_literal-11.zig
+++ /dev/null
@@ -1,11 +0,0 @@
-fn main() void {
-    var bad: f128 = 1.0e-1__0;
-    _ = bad;
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:2:21: error: expected expression, found 'invalid bytes'
-// tmp.zig:2:28: note: invalid byte: '_'
diff --git a/test/compile_errors/stage1/obj/invalid_underscore_placement_in_float_literal-12.zig b/test/compile_errors/stage1/obj/invalid_underscore_placement_in_float_literal-12.zig
deleted file mode 100644
index 2d36187711738ac775525c2818d8469fb62d0ba7..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/invalid_underscore_placement_in_float_literal-12.zig
+++ /dev/null
@@ -1,11 +0,0 @@
-fn main() void {
-    var bad: f128 = 0_x0.0;
-    _ = bad;
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:2:21: error: expected expression, found 'invalid bytes'
-// tmp.zig:2:23: note: invalid byte: 'x'
diff --git a/test/compile_errors/stage1/obj/invalid_underscore_placement_in_float_literal-13.zig b/test/compile_errors/stage1/obj/invalid_underscore_placement_in_float_literal-13.zig
deleted file mode 100644
index 21b044121c9cfcbbf1ac2b1cfdeeb5a1f9140d2d..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/invalid_underscore_placement_in_float_literal-13.zig
+++ /dev/null
@@ -1,11 +0,0 @@
-fn main() void {
-    var bad: f128 = 0x_0.0;
-    _ = bad;
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:2:21: error: expected expression, found 'invalid bytes'
-// tmp.zig:2:23: note: invalid byte: '_'
diff --git a/test/compile_errors/stage1/obj/invalid_underscore_placement_in_float_literal-14.zig b/test/compile_errors/stage1/obj/invalid_underscore_placement_in_float_literal-14.zig
deleted file mode 100644
index adb0727eba7f1822d8916a7c81a6f04042d9fb1c..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/invalid_underscore_placement_in_float_literal-14.zig
+++ /dev/null
@@ -1,11 +0,0 @@
-fn main() void {
-    var bad: f128 = 0x0.0_p1;
-    _ = bad;
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:2:21: error: expected expression, found 'invalid bytes'
-// tmp.zig:2:27: note: invalid byte: 'p'
diff --git a/test/compile_errors/stage1/obj/invalid_underscore_placement_in_float_literal-2.zig b/test/compile_errors/stage1/obj/invalid_underscore_placement_in_float_literal-2.zig
deleted file mode 100644
index 16618c6a18b18f49ded416ae2cf0bc0ab8438a9d..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/invalid_underscore_placement_in_float_literal-2.zig
+++ /dev/null
@@ -1,11 +0,0 @@
-fn main() void {
-    var bad: f128 = 0_.0;
-    _ = bad;
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:2:21: error: expected expression, found 'invalid bytes'
-// tmp.zig:2:23: note: invalid byte: '.'
diff --git a/test/compile_errors/stage1/obj/invalid_underscore_placement_in_float_literal-3.zig b/test/compile_errors/stage1/obj/invalid_underscore_placement_in_float_literal-3.zig
deleted file mode 100644
index 09e9e20b4b607af0e83801e7404de60619ef4af6..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/invalid_underscore_placement_in_float_literal-3.zig
+++ /dev/null
@@ -1,11 +0,0 @@
-fn main() void {
-    var bad: f128 = 0.0_;
-    _ = bad;
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:2:21: error: expected expression, found 'invalid bytes'
-// tmp.zig:2:25: note: invalid byte: ';'
diff --git a/test/compile_errors/stage1/obj/invalid_underscore_placement_in_float_literal-4.zig b/test/compile_errors/stage1/obj/invalid_underscore_placement_in_float_literal-4.zig
deleted file mode 100644
index 278ee35f5f2130fbf8a4490b3730645e24d639c1..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/invalid_underscore_placement_in_float_literal-4.zig
+++ /dev/null
@@ -1,11 +0,0 @@
-fn main() void {
-    var bad: f128 = 1.0e_1;
-    _ = bad;
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:2:21: error: expected expression, found 'invalid bytes'
-// tmp.zig:2:25: note: invalid byte: '_'
diff --git a/test/compile_errors/stage1/obj/invalid_underscore_placement_in_float_literal-5.zig b/test/compile_errors/stage1/obj/invalid_underscore_placement_in_float_literal-5.zig
deleted file mode 100644
index 4912c15e504e4874775def6e859f278c1b628e65..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/invalid_underscore_placement_in_float_literal-5.zig
+++ /dev/null
@@ -1,11 +0,0 @@
-fn main() void {
-    var bad: f128 = 1.0e+_1;
-    _ = bad;
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:2:21: error: expected expression, found 'invalid bytes'
-// tmp.zig:2:26: note: invalid byte: '_'
diff --git a/test/compile_errors/stage1/obj/invalid_underscore_placement_in_float_literal-6.zig b/test/compile_errors/stage1/obj/invalid_underscore_placement_in_float_literal-6.zig
deleted file mode 100644
index 3386c860b93278e6322434bf58d5b2ed756a3220..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/invalid_underscore_placement_in_float_literal-6.zig
+++ /dev/null
@@ -1,11 +0,0 @@
-fn main() void {
-    var bad: f128 = 1.0e-_1;
-    _ = bad;
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:2:21: error: expected expression, found 'invalid bytes'
-// tmp.zig:2:26: note: invalid byte: '_'
diff --git a/test/compile_errors/stage1/obj/invalid_underscore_placement_in_float_literal-7.zig b/test/compile_errors/stage1/obj/invalid_underscore_placement_in_float_literal-7.zig
deleted file mode 100644
index c0e57424a948fa2b50b2ed88f4d00223386f5a40..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/invalid_underscore_placement_in_float_literal-7.zig
+++ /dev/null
@@ -1,11 +0,0 @@
-fn main() void {
-    var bad: f128 = 1.0e-1_;
-    _ = bad;
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:2:21: error: expected expression, found 'invalid bytes'
-// tmp.zig:2:28: note: invalid byte: ';'
diff --git a/test/compile_errors/stage1/obj/invalid_underscore_placement_in_float_literal-9.zig b/test/compile_errors/stage1/obj/invalid_underscore_placement_in_float_literal-9.zig
deleted file mode 100644
index f7475332c1540149e921c03079cabb056ef5fc11..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/invalid_underscore_placement_in_float_literal-9.zig
+++ /dev/null
@@ -1,11 +0,0 @@
-fn main() void {
-    var bad: f128 = 1__0.0e-1;
-    _ = bad;
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:2:21: error: expected expression, found 'invalid bytes'
-// tmp.zig:2:23: note: invalid byte: '_'
diff --git a/test/compile_errors/stage1/obj/invalid_underscore_placement_in_int_literal-1.zig b/test/compile_errors/stage1/obj/invalid_underscore_placement_in_int_literal-1.zig
deleted file mode 100644
index 9cea337db46ceb33d12386fb64c57aa4f3a64635..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/invalid_underscore_placement_in_int_literal-1.zig
+++ /dev/null
@@ -1,11 +0,0 @@
-fn main() void {
-    var bad: u128 = 0010_;
-    _ = bad;
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:2:21: error: expected expression, found 'invalid bytes'
-// tmp.zig:2:26: note: invalid byte: ';'
diff --git a/test/compile_errors/stage1/obj/invalid_underscore_placement_in_int_literal-2.zig b/test/compile_errors/stage1/obj/invalid_underscore_placement_in_int_literal-2.zig
deleted file mode 100644
index 5f02479f2e7d6b68de0a8323ffa1f91ccd934b2a..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/invalid_underscore_placement_in_int_literal-2.zig
+++ /dev/null
@@ -1,11 +0,0 @@
-fn main() void {
-    var bad: u128 = 0b0010_;
-    _ = bad;
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:2:21: error: expected expression, found 'invalid bytes'
-// tmp.zig:2:28: note: invalid byte: ';'
diff --git a/test/compile_errors/stage1/obj/invalid_underscore_placement_in_int_literal-3.zig b/test/compile_errors/stage1/obj/invalid_underscore_placement_in_int_literal-3.zig
deleted file mode 100644
index aed4cb90687f9394dfbf14664baa502ce0bf465d..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/invalid_underscore_placement_in_int_literal-3.zig
+++ /dev/null
@@ -1,11 +0,0 @@
-fn main() void {
-    var bad: u128 = 0o0010_;
-    _ = bad;
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:2:21: error: expected expression, found 'invalid bytes'
-// tmp.zig:2:28: note: invalid byte: ';'
diff --git a/test/compile_errors/stage1/obj/invalid_underscore_placement_in_int_literal-4.zig b/test/compile_errors/stage1/obj/invalid_underscore_placement_in_int_literal-4.zig
deleted file mode 100644
index dce2771048c9baf8e2c1d452cb331e6fa3927267..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/invalid_underscore_placement_in_int_literal-4.zig
+++ /dev/null
@@ -1,11 +0,0 @@
-fn main() void {
-    var bad: u128 = 0x0010_;
-    _ = bad;
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:2:21: error: expected expression, found 'invalid bytes'
-// tmp.zig:2:28: note: invalid byte: ';'
diff --git a/test/compile_errors/stage1/obj/invalid_union_field_access_in_comptime.zig b/test/compile_errors/stage1/obj/invalid_union_field_access_in_comptime.zig
deleted file mode 100644
index 6d55f3b04fb3c0dcfde90f94d70023ae81a053c5..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/invalid_union_field_access_in_comptime.zig
+++ /dev/null
@@ -1,15 +0,0 @@
-const Foo = union {
-    Bar: u8,
-    Baz: void,
-};
-comptime {
-    var foo = Foo {.Baz = {}};
-    const bar_val = foo.Bar;
-    _ = bar_val;
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:7:24: error: accessing union field 'Bar' while field 'Baz' is set
diff --git a/test/compile_errors/stage1/obj/issue_2032_compile_diagnostic_string_for_top_level_decl_type.zig b/test/compile_errors/stage1/obj/issue_2032_compile_diagnostic_string_for_top_level_decl_type.zig
deleted file mode 100644
index c742cb9b7756546712193dc0f72db5e307b3ed6a..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/issue_2032_compile_diagnostic_string_for_top_level_decl_type.zig
+++ /dev/null
@@ -1,10 +0,0 @@
-export fn entry() void {
-    var foo: u32 = @This(){};
-    _ = foo;
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:2:27: error: type 'u32' does not support array initialization
diff --git a/test/compile_errors/stage1/obj/issue_2687_coerce_from_undefined_array_pointer_to_slice.zig b/test/compile_errors/stage1/obj/issue_2687_coerce_from_undefined_array_pointer_to_slice.zig
deleted file mode 100644
index 21fbb6b4fe94a065781e911e13b83359e0125bb4..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/issue_2687_coerce_from_undefined_array_pointer_to_slice.zig
+++ /dev/null
@@ -1,27 +0,0 @@
-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;
-    }
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:3:19: error: use of undefined value here causes undefined behavior
-// tmp.zig:9:23: error: use of undefined value here causes undefined behavior
-// tmp.zig:16:23: error: use of undefined value here causes undefined behavior
diff --git a/test/compile_errors/stage1/obj/issue_3818_bitcast_from_parray-slice_to_u16.zig b/test/compile_errors/stage1/obj/issue_3818_bitcast_from_parray-slice_to_u16.zig
deleted file mode 100644
index cdc1def677920f15211808b80741d89965f5f960..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/issue_3818_bitcast_from_parray-slice_to_u16.zig
+++ /dev/null
@@ -1,17 +0,0 @@
-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;
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:3:42: error: unable to @bitCast from pointer type '*[2]u8'
-// tmp.zig:8:32: error: destination type 'u16' has size 2 but source type '[]const u8' has size 16
diff --git a/test/compile_errors/stage1/obj/issue_4207_coerce_from_non-terminated-slice_to_terminated-pointer.zig b/test/compile_errors/stage1/obj/issue_4207_coerce_from_non-terminated-slice_to_terminated-pointer.zig
deleted file mode 100644
index d53f7731a091272165cdd221ecc5e3be024764b3..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/issue_4207_coerce_from_non-terminated-slice_to_terminated-pointer.zig
+++ /dev/null
@@ -1,11 +0,0 @@
-export fn foo() [*:0]const u8 {
-    var buffer: [64]u8 = undefined;
-    return buffer[0..];
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// :3:18: error: expected type '[*:0]const u8', found '*[64]u8'
-// :3:18: note: destination pointer requires a terminating '0' sentinel
diff --git a/test/compile_errors/stage1/obj/issue_5221_invalid_struct_init_type_referenced_by_typeInfo_and_passed_into_function.zig b/test/compile_errors/stage1/obj/issue_5221_invalid_struct_init_type_referenced_by_typeInfo_and_passed_into_function.zig
deleted file mode 100644
index a622ceb44e0abf38d9131ed19eed8a4b9895cf73..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/issue_5221_invalid_struct_init_type_referenced_by_typeInfo_and_passed_into_function.zig
+++ /dev/null
@@ -1,16 +0,0 @@
-fn ignore(comptime param: anytype) void {_ = param;}
-
-export fn foo() void {
-    const MyStruct = struct {
-        wrong_type: []u8 = "foo",
-    };
-
-    comptime ignore(@typeInfo(MyStruct).Struct.fields[0]);
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// :5:28: error: cannot cast pointer to array literal to slice type '[]u8'
-// :5:28: note: cast discards const qualifier
diff --git a/test/compile_errors/stage1/obj/issue_5618_coercion_of_optional_anyopaque_to_anyopaque_must_fail.zig b/test/compile_errors/stage1/obj/issue_5618_coercion_of_optional_anyopaque_to_anyopaque_must_fail.zig
deleted file mode 100644
index 9ba991083865b84cbe56ebfcc6fd8503b2ce5bc6..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/issue_5618_coercion_of_optional_anyopaque_to_anyopaque_must_fail.zig
+++ /dev/null
@@ -1,11 +0,0 @@
-export fn foo() void {
-    var u: ?*anyopaque = null;
-    var v: *anyopaque = undefined;
-    v = u;
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:4:9: error: cannot convert optional to payload type. consider using `.?`, `orelse`, or `if`. expected type '*anyopaque', found '?*anyopaque'
diff --git a/test/compile_errors/stage1/obj/issue_7810-comptime_slice-len_increment_beyond_bounds.zig b/test/compile_errors/stage1/obj/issue_7810-comptime_slice-len_increment_beyond_bounds.zig
deleted file mode 100644
index c8b2f0b09e9310836c7c7e0766c9f99f20f36e9e..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/issue_7810-comptime_slice-len_increment_beyond_bounds.zig
+++ /dev/null
@@ -1,14 +0,0 @@
-export fn foo_slice_len_increment_beyond_bounds() void {
-    comptime {
-        var buf_storage: [8]u8 = undefined;
-        var buf: []const u8 = buf_storage[0..];
-        buf.len += 1;
-        buf[8] = 42;
-    }
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// :6:12: error: out of bounds slice
diff --git a/test/compile_errors/stage1/obj/issue_9346_return_outside_of_function_scope.zig b/test/compile_errors/stage1/obj/issue_9346_return_outside_of_function_scope.zig
deleted file mode 100644
index d12bff2b49c542ef7b07e4832e606c23c247c616..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/issue_9346_return_outside_of_function_scope.zig
+++ /dev/null
@@ -1,7 +0,0 @@
-pub const empty = return 1;
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:1:19: error: 'return' outside function scope
diff --git a/test/compile_errors/stage1/obj/labeled_break_not_found.zig b/test/compile_errors/stage1/obj/labeled_break_not_found.zig
deleted file mode 100644
index 754e1864b096a6c76fcbdb3359c2dba8452da8c2..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/labeled_break_not_found.zig
+++ /dev/null
@@ -1,13 +0,0 @@
-export fn entry() void {
-    blah: while (true) {
-        while (true) {
-            break :outer;
-        }
-    }
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:4:20: error: label not found: 'outer'
diff --git a/test/compile_errors/stage1/obj/labeled_continue_not_found.zig b/test/compile_errors/stage1/obj/labeled_continue_not_found.zig
deleted file mode 100644
index b112e9b3557ffc9b463a1d6a3221151820e37490..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/labeled_continue_not_found.zig
+++ /dev/null
@@ -1,14 +0,0 @@
-export fn entry() void {
-    var i: usize = 0;
-    blah: while (i < 10) : (i += 1) {
-        while (true) {
-            continue :outer;
-        }
-    }
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:5:23: error: label not found: 'outer'
diff --git a/test/compile_errors/stage1/obj/lazy_pointer_with_undefined_element_type.zig b/test/compile_errors/stage1/obj/lazy_pointer_with_undefined_element_type.zig
deleted file mode 100644
index 733a3ca2dd89d1b97050473303a5d90cd7747c8e..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/lazy_pointer_with_undefined_element_type.zig
+++ /dev/null
@@ -1,12 +0,0 @@
-export fn foo() void {
-    comptime var T: type = undefined;
-    const S = struct { x: *T };
-    const I = @typeInfo(S);
-    _ = I;
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// :3:28: error: use of undefined value here causes undefined behavior
diff --git a/test/compile_errors/stage1/obj/libc_headers_note.zig b/test/compile_errors/stage1/obj/libc_headers_note.zig
deleted file mode 100644
index c8d9a9cbf3aff757f4b5ce532beb1ef430f37c72..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/libc_headers_note.zig
+++ /dev/null
@@ -1,12 +0,0 @@
-const c = @cImport(@cInclude("stdio.h"));
-export fn entry() void {
-    _ = c.printf("hello, world!\n");
-}
-
-// error
-// backend=stage1
-// is_test=1
-// target=native-linux
-//
-// tmp.zig:1:11: error: C import failed
-// tmp.zig:1:11: note: libc headers not available; compilation does not link against libc
diff --git a/test/compile_errors/stage1/obj/load_too_many_bytes_from_comptime_reinterpreted_pointer.zig b/test/compile_errors/stage1/obj/load_too_many_bytes_from_comptime_reinterpreted_pointer.zig
deleted file mode 100644
index b275dbbeedbef7f25a3ec42a3c9a3e3c757542bc..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/load_too_many_bytes_from_comptime_reinterpreted_pointer.zig
+++ /dev/null
@@ -1,13 +0,0 @@
-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;
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:5:28: error: attempt to read 8 bytes from pointer to f32 which is 4 bytes
diff --git a/test/compile_errors/stage1/obj/load_vector_pointer_with_unknown_runtime_index.zig b/test/compile_errors/stage1/obj/load_vector_pointer_with_unknown_runtime_index.zig
deleted file mode 100644
index 8d703b09e6c6c9a1a370badaade02aeebc252abe..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/load_vector_pointer_with_unknown_runtime_index.zig
+++ /dev/null
@@ -1,17 +0,0 @@
-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.*;
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:10:12: error: unable to determine vector element index of type '*align(16:0:4:?) i32
diff --git a/test/compile_errors/stage1/obj/local_shadows_global_that_occurs_later.zig b/test/compile_errors/stage1/obj/local_shadows_global_that_occurs_later.zig
deleted file mode 100644
index 4b9b58871ff0e689880772d357e433597f16275e..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/local_shadows_global_that_occurs_later.zig
+++ /dev/null
@@ -1,12 +0,0 @@
-pub fn main() void {
-    var foo = true;
-    _ = foo;
-}
-fn foo() void {}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:2:9: error: local shadows declaration of 'foo'
-// tmp.zig:5:1: note: declared here
diff --git a/test/compile_errors/stage1/obj/local_variable_redeclaration.zig b/test/compile_errors/stage1/obj/local_variable_redeclaration.zig
deleted file mode 100644
index 79eba0d4288233f7dd4f4d2ceba0f8b076d2b8eb..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/local_variable_redeclaration.zig
+++ /dev/null
@@ -1,11 +0,0 @@
-export fn f() void {
-    const a : i32 = 0;
-    var a = 0;
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:3:9: error: redeclaration of local constant 'a'
-// tmp.zig:2:11: note: previous declaration here
diff --git a/test/compile_errors/stage1/obj/local_variable_redeclares_parameter.zig b/test/compile_errors/stage1/obj/local_variable_redeclares_parameter.zig
deleted file mode 100644
index 854ef080c526909f13f0fc442303b6fc579a3bcd..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/local_variable_redeclares_parameter.zig
+++ /dev/null
@@ -1,11 +0,0 @@
-fn f(a : i32) void {
-    const a = 0;
-}
-export fn entry() void { f(1); }
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:2:11: error: redeclaration of function parameter 'a'
-// tmp.zig:1:6: note: previous declaration here
diff --git a/test/compile_errors/stage1/obj/local_variable_shadowing_global.zig b/test/compile_errors/stage1/obj/local_variable_shadowing_global.zig
deleted file mode 100644
index 3f1af3a4cb891aab5048a4f5218f62489a557d8d..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/local_variable_shadowing_global.zig
+++ /dev/null
@@ -1,14 +0,0 @@
-const Foo = struct {};
-const Bar = struct {};
-
-export fn entry() void {
-    var Bar : i32 = undefined;
-    _ = Bar;
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:5:9: error: local shadows declaration of 'Bar'
-// tmp.zig:2:1: note: declared here
diff --git a/test/compile_errors/stage1/obj/locally_shadowing_a_primitive_type.zig b/test/compile_errors/stage1/obj/locally_shadowing_a_primitive_type.zig
deleted file mode 100644
index e66a2082ea87fbf27a9338a7a5c7cfcda12e13c5..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/locally_shadowing_a_primitive_type.zig
+++ /dev/null
@@ -1,12 +0,0 @@
-export fn foo() void {
-    const u8 = u16;
-    const a: u8 = 300;
-    _ = a;
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:2:11: error: name shadows primitive 'u8'
-// tmp.zig:2:11: note: consider using @"u8" to disambiguate
diff --git a/test/compile_errors/stage1/obj/main_function_with_bogus_args_type.zig b/test/compile_errors/stage1/obj/main_function_with_bogus_args_type.zig
deleted file mode 100644
index 5808ab90ecc7b10d2587e6186a9ab28ecc6ff88b..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/main_function_with_bogus_args_type.zig
+++ /dev/null
@@ -1,7 +0,0 @@
-pub fn main(args: [][]bogus) !void {_ = args;}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:1:23: error: use of undeclared identifier 'bogus'
diff --git a/test/compile_errors/stage1/obj/method_call_with_first_arg_type_primitive.zig b/test/compile_errors/stage1/obj/method_call_with_first_arg_type_primitive.zig
deleted file mode 100644
index 316be2d899f08ce8e1bb12e4e0dfc8550ddec941..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/method_call_with_first_arg_type_primitive.zig
+++ /dev/null
@@ -1,21 +0,0 @@
-const Foo = struct {
-    x: i32,
-
-    fn init(x: i32) Foo {
-        return Foo {
-            .x = x,
-        };
-    }
-};
-
-export fn f() void {
-    const derp = Foo.init(3);
-
-    derp.init();
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:14:5: error: expected type 'i32', found 'Foo'
diff --git a/test/compile_errors/stage1/obj/method_call_with_first_arg_type_wrong_container.zig b/test/compile_errors/stage1/obj/method_call_with_first_arg_type_wrong_container.zig
deleted file mode 100644
index 04ab89fb6ca76262d9b51f8b311196270071c296..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/method_call_with_first_arg_type_wrong_container.zig
+++ /dev/null
@@ -1,30 +0,0 @@
-pub const List = struct {
-    len: usize,
-    allocator: *Allocator,
-
-    pub fn init(allocator: *Allocator) List {
-        return List {
-            .len = 0,
-            .allocator = allocator,
-        };
-    }
-};
-
-pub var global_allocator = Allocator {
-    .field = 1234,
-};
-
-pub const Allocator = struct {
-    field: i32,
-};
-
-export fn foo() void {
-    var x = List.init(&global_allocator);
-    x.init();
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:23:5: error: expected type '*Allocator', found '*List'
diff --git a/test/compile_errors/stage1/obj/missing_boolean_switch_value.zig b/test/compile_errors/stage1/obj/missing_boolean_switch_value.zig
deleted file mode 100644
index 2e9d4b48ce3f0ced8088ab957f22e995fc170054..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/missing_boolean_switch_value.zig
+++ /dev/null
@@ -1,19 +0,0 @@
-comptime {
-    const x = switch (true) {
-        true => false,
-    };
-    _ = x;
-}
-comptime {
-    const x = switch (true) {
-        false => true,
-    };
-    _ = x;
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:2:15: error: switch must handle all possibilities
-// tmp.zig:8:15: error: switch must handle all possibilities
diff --git a/test/compile_errors/stage1/obj/missing_const_in_slice_with_nested_array_type.zig b/test/compile_errors/stage1/obj/missing_const_in_slice_with_nested_array_type.zig
deleted file mode 100644
index af9d690d438316d9e3da093387302760c64aa9e7..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/missing_const_in_slice_with_nested_array_type.zig
+++ /dev/null
@@ -1,18 +0,0 @@
-const Geo3DTex2D = struct { vertices: [][2]f32 };
-pub fn getGeo3DTex2D() Geo3DTex2D {
-    return Geo3DTex2D{
-        .vertices = [_][2]f32{
-            [_]f32{ -0.5, -0.5},
-        },
-    };
-}
-export fn entry() void {
-    var geo_data = getGeo3DTex2D();
-    _ = geo_data;
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:4:30: error: array literal requires address-of operator (&) to coerce to slice type '[][2]f32'
diff --git a/test/compile_errors/stage1/obj/missing_else_clause.zig b/test/compile_errors/stage1/obj/missing_else_clause.zig
deleted file mode 100644
index f331933437f2579377b6f3b29d607fa68787d5af..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/missing_else_clause.zig
+++ /dev/null
@@ -1,16 +0,0 @@
-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); }
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:2:21: error: expected type 'i32', found 'void'
-// tmp.zig:6:15: error: incompatible types: 'i32' and 'void'
diff --git a/test/compile_errors/stage1/obj/missing_field_in_struct_value_expression.zig b/test/compile_errors/stage1/obj/missing_field_in_struct_value_expression.zig
deleted file mode 100644
index 9eb4246c8f76fa40b7901040d43e321514a5b375..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/missing_field_in_struct_value_expression.zig
+++ /dev/null
@@ -1,20 +0,0 @@
-const A = struct {
-    x : i32,
-    y : i32,
-    z : i32,
-};
-export fn f() void {
-    // we want the error on the '{' not the 'A' because
-    // the A could be a complicated expression
-    const a = A {
-        .z = 4,
-        .y = 2,
-    };
-    _ = a;
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:9:17: error: missing field: 'x'
diff --git a/test/compile_errors/stage1/obj/missing_function_call_param.zig b/test/compile_errors/stage1/obj/missing_function_call_param.zig
deleted file mode 100644
index 9e08ed7140c6a50a6a19e79a42b1357a714958a4..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/missing_function_call_param.zig
+++ /dev/null
@@ -1,31 +0,0 @@
-const Foo = struct {
-    a: i32,
-    b: i32,
-
-    fn member_a(foo: *const Foo) i32 {
-        return foo.a;
-    }
-    fn member_b(foo: *const Foo) i32 {
-        return foo.b;
-    }
-};
-
-const member_fn_type = @TypeOf(Foo.member_a);
-const members = [_]member_fn_type {
-    Foo.member_a,
-    Foo.member_b,
-};
-
-fn f(foo: *const Foo, index: usize) void {
-    const result = members[index]();
-    _ = foo;
-    _ = result;
-}
-
-export fn entry() usize { return @sizeOf(@TypeOf(f)); }
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:20:34: error: expected 1 argument(s), found 0
diff --git a/test/compile_errors/stage1/obj/missing_function_name.zig b/test/compile_errors/stage1/obj/missing_function_name.zig
deleted file mode 100644
index cd9a3ca7ee96c625ea7b43a0867a29d9fedd4bb7..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/missing_function_name.zig
+++ /dev/null
@@ -1,8 +0,0 @@
-fn () void {}
-export fn entry() usize { return @sizeOf(@TypeOf(f)); }
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:1:1: error: missing function name
diff --git a/test/compile_errors/stage1/obj/missing_param_name.zig b/test/compile_errors/stage1/obj/missing_param_name.zig
deleted file mode 100644
index febb16d2cacc7adfb10ebc908e775c15128e2606..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/missing_param_name.zig
+++ /dev/null
@@ -1,8 +0,0 @@
-fn f(i32) void {}
-export fn entry() usize { return @sizeOf(@TypeOf(f)); }
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:1:6: error: missing parameter name
diff --git a/test/compile_errors/stage1/obj/missing_parameter_name_of_generic_function.zig b/test/compile_errors/stage1/obj/missing_parameter_name_of_generic_function.zig
deleted file mode 100644
index 041c0c4a47726ba9a806587c8b3fd7d1ae91cc1d..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/missing_parameter_name_of_generic_function.zig
+++ /dev/null
@@ -1,11 +0,0 @@
-fn dump(anytype) void {}
-export fn entry() void {
-    var a: u8 = 9;
-    dump(a);
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:1:9: error: missing parameter name
diff --git a/test/compile_errors/stage1/obj/missing_result_type_for_phi_node.zig b/test/compile_errors/stage1/obj/missing_result_type_for_phi_node.zig
deleted file mode 100644
index 33bc1d0d9c907934d0ba055d91b128e31bec9265..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/missing_result_type_for_phi_node.zig
+++ /dev/null
@@ -1,12 +0,0 @@
-fn foo() !void {
-    return anyerror.Foo;
-}
-export fn entry() void {
-    foo() catch 0;
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:5:17: error: integer value 0 cannot be coerced to type 'void'
diff --git a/test/compile_errors/stage1/obj/misspelled_type_with_pointer_only_reference.zig b/test/compile_errors/stage1/obj/misspelled_type_with_pointer_only_reference.zig
deleted file mode 100644
index 8e2055a829912c9d3b4d55c24f09027d3407f94e..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/misspelled_type_with_pointer_only_reference.zig
+++ /dev/null
@@ -1,37 +0,0 @@
-const JasonHM = u8;
-const JasonList = *JsonNode;
-
-const JsonOA = union(enum) {
-    JSONArray: JsonList,
-    JSONObject: JasonHM,
-};
-
-const JsonType = union(enum) {
-    JSONNull: void,
-    JSONInteger: isize,
-    JSONDouble: f64,
-    JSONBool: bool,
-    JSONString: []u8,
-    JSONArray: void,
-    JSONObject: void,
-};
-
-pub const JsonNode = struct {
-    kind: JsonType,
-    jobject: ?JsonOA,
-};
-
-fn foo() 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)); }
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:5:16: error: use of undeclared identifier 'JsonList'
diff --git a/test/compile_errors/stage1/obj/mod_assign_on_undefined_value.zig b/test/compile_errors/stage1/obj/mod_assign_on_undefined_value.zig
deleted file mode 100644
index c127e256e8bd23f73517ed1dd5be34c20580a324..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/mod_assign_on_undefined_value.zig
+++ /dev/null
@@ -1,10 +0,0 @@
-comptime {
-    var a: i64 = undefined;
-    a %= a;
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:3:5: error: use of undefined value here causes undefined behavior
diff --git a/test/compile_errors/stage1/obj/mod_on_undefined_value.zig b/test/compile_errors/stage1/obj/mod_on_undefined_value.zig
deleted file mode 100644
index 8bd7774a4638148af6666ccca95c504195423e28..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/mod_on_undefined_value.zig
+++ /dev/null
@@ -1,10 +0,0 @@
-comptime {
-    var a: i64 = undefined;
-    _ = a % a;
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:3:9: error: use of undefined value here causes undefined behavior
diff --git a/test/compile_errors/stage1/obj/mul_overflow_in_function_evaluation.zig b/test/compile_errors/stage1/obj/mul_overflow_in_function_evaluation.zig
deleted file mode 100644
index 8209b33f94145dd11431f295f7c7fea999ad9316..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/mul_overflow_in_function_evaluation.zig
+++ /dev/null
@@ -1,12 +0,0 @@
-const y = mul(300, 6000);
-fn mul(a: u16, b: u16) u16 {
-    return a * b;
-}
-
-export fn entry() usize { return @sizeOf(@TypeOf(y)); }
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:3:14: error: operation caused overflow
diff --git a/test/compile_errors/stage1/obj/mult_assign_on_undefined_value.zig b/test/compile_errors/stage1/obj/mult_assign_on_undefined_value.zig
deleted file mode 100644
index 04040b975643bdefbc4045ab94a96991527f1871..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/mult_assign_on_undefined_value.zig
+++ /dev/null
@@ -1,10 +0,0 @@
-comptime {
-    var a: i64 = undefined;
-    a *= a;
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:3:5: error: use of undefined value here causes undefined behavior
diff --git a/test/compile_errors/stage1/obj/mult_on_undefined_value.zig b/test/compile_errors/stage1/obj/mult_on_undefined_value.zig
deleted file mode 100644
index 0dcd2b02f2d08afdee284ca4571bd5847ae97f74..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/mult_on_undefined_value.zig
+++ /dev/null
@@ -1,10 +0,0 @@
-comptime {
-    var a: i64 = undefined;
-    _ = a * a;
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:3:9: error: use of undefined value here causes undefined behavior
diff --git a/test/compile_errors/stage1/obj/mult_wrap_assign_on_undefined_value.zig b/test/compile_errors/stage1/obj/mult_wrap_assign_on_undefined_value.zig
deleted file mode 100644
index db54af9f0b53687ac4e8c863efd40d61878b1080..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/mult_wrap_assign_on_undefined_value.zig
+++ /dev/null
@@ -1,10 +0,0 @@
-comptime {
-    var a: i64 = undefined;
-    a *%= a;
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:3:5: error: use of undefined value here causes undefined behavior
diff --git a/test/compile_errors/stage1/obj/mult_wrap_on_undefined_value.zig b/test/compile_errors/stage1/obj/mult_wrap_on_undefined_value.zig
deleted file mode 100644
index 9ad09f7e9306fc682e2a346f413040281999a378..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/mult_wrap_on_undefined_value.zig
+++ /dev/null
@@ -1,10 +0,0 @@
-comptime {
-    var a: i64 = undefined;
-    _ = a *% a;
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:3:9: error: use of undefined value here causes undefined behavior
diff --git a/test/compile_errors/stage1/obj/multiple_function_definitions.zig b/test/compile_errors/stage1/obj/multiple_function_definitions.zig
deleted file mode 100644
index baa4a43048fccc340dd41de0f735a992fb1160aa..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/multiple_function_definitions.zig
+++ /dev/null
@@ -1,10 +0,0 @@
-fn a() void {}
-fn a() void {}
-export fn entry() void { a(); }
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:2:1: error: redeclaration of 'a'
-// tmp.zig:1:1: note: other declaration here
diff --git a/test/compile_errors/stage1/obj/negate_on_undefined_value.zig b/test/compile_errors/stage1/obj/negate_on_undefined_value.zig
deleted file mode 100644
index f8d5f6128d48743bcacdcd267550e05d9903e203..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/negate_on_undefined_value.zig
+++ /dev/null
@@ -1,10 +0,0 @@
-comptime {
-    var a: i64 = undefined;
-    _ = -a;
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:3:10: error: use of undefined value here causes undefined behavior
diff --git a/test/compile_errors/stage1/obj/negate_wrap_on_undefined_value.zig b/test/compile_errors/stage1/obj/negate_wrap_on_undefined_value.zig
deleted file mode 100644
index 4ca32956de7e8bb4de3c877b8246bdd017d44394..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/negate_wrap_on_undefined_value.zig
+++ /dev/null
@@ -1,10 +0,0 @@
-comptime {
-    var a: i64 = undefined;
-    _ = -%a;
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:3:11: error: use of undefined value here causes undefined behavior
diff --git a/test/compile_errors/stage1/obj/negation_overflow_in_function_evaluation.zig b/test/compile_errors/stage1/obj/negation_overflow_in_function_evaluation.zig
deleted file mode 100644
index f83e0de6ae33c50986f0ef06f063b4bd353ee35f..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/negation_overflow_in_function_evaluation.zig
+++ /dev/null
@@ -1,12 +0,0 @@
-const y = neg(-128);
-fn neg(x: i8) i8 {
-    return -x;
-}
-
-export fn entry() usize { return @sizeOf(@TypeOf(y)); }
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:3:12: error: negation caused overflow
diff --git a/test/compile_errors/stage1/obj/nested_error_set_mismatch.zig b/test/compile_errors/stage1/obj/nested_error_set_mismatch.zig
deleted file mode 100644
index cd037635bc4cc8b5ccd35d8671645be45e8a2695..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/nested_error_set_mismatch.zig
+++ /dev/null
@@ -1,20 +0,0 @@
-const NextError = error{NextError};
-const OtherError = error{OutOfMemory};
-
-export fn entry() void {
-    const a: ?NextError!i32 = foo();
-    _ = a;
-}
-
-fn foo() ?OtherError!i32 {
-    return null;
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:5:34: error: expected type '?NextError!i32', found '?OtherError!i32'
-// tmp.zig:5:34: note: optional type child 'OtherError!i32' cannot cast into optional type child 'NextError!i32'
-// tmp.zig:5:34: note: error set 'OtherError' cannot cast into error set 'NextError'
-// tmp.zig:2:26: note: 'error.OutOfMemory' not a member of destination error set
diff --git a/test/compile_errors/stage1/obj/no_else_prong_on_switch_on_global_error_set.zig b/test/compile_errors/stage1/obj/no_else_prong_on_switch_on_global_error_set.zig
deleted file mode 100644
index 39f4399cafcb6c11ca997f115329ebb5fc8891b4..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/no_else_prong_on_switch_on_global_error_set.zig
+++ /dev/null
@@ -1,14 +0,0 @@
-export fn entry() void {
-    foo(error.A);
-}
-fn foo(a: anyerror) void {
-    switch (a) {
-        error.A => {},
-    }
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:5:5: error: else prong required when switching on type 'anyerror'
diff --git a/test/compile_errors/stage1/obj/noalias_on_non_pointer_param.zig b/test/compile_errors/stage1/obj/noalias_on_non_pointer_param.zig
deleted file mode 100644
index ca84aca73f65615812281bf10695672c6cd61207..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/noalias_on_non_pointer_param.zig
+++ /dev/null
@@ -1,8 +0,0 @@
-fn f(noalias x: i32) void { _ = x; }
-export fn entry() void { f(1234); }
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:1:6: error: noalias on non-pointer parameter
diff --git a/test/compile_errors/stage1/obj/non-async_function_pointer_eventually_is_inferred_to_become_async.zig b/test/compile_errors/stage1/obj/non-async_function_pointer_eventually_is_inferred_to_become_async.zig
deleted file mode 100644
index e18b4200289d80343d38cee2da9101f81916c0f5..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/non-async_function_pointer_eventually_is_inferred_to_become_async.zig
+++ /dev/null
@@ -1,15 +0,0 @@
-export fn a() void {
-    var non_async_fn: fn () void = undefined;
-    non_async_fn = func;
-}
-fn func() void {
-    suspend {}
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:5:1: error: 'func' cannot be async
-// tmp.zig:3:20: note: required to be non-async here
-// tmp.zig:6:5: note: suspends here
diff --git a/test/compile_errors/stage1/obj/non-const_expression_function_call_with_struct_return_value_outside_function.zig b/test/compile_errors/stage1/obj/non-const_expression_function_call_with_struct_return_value_outside_function.zig
deleted file mode 100644
index 25e33d1435425bb78f249de714ae593ce47d71e5..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/non-const_expression_function_call_with_struct_return_value_outside_function.zig
+++ /dev/null
@@ -1,17 +0,0 @@
-const Foo = struct {
-    x: i32,
-};
-const a = get_it();
-fn get_it() Foo {
-    global_side_effect = true;
-    return Foo {.x = 13};
-}
-var global_side_effect = false;
-
-export fn entry() usize { return @sizeOf(@TypeOf(a)); }
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:6:26: error: unable to evaluate constant expression
diff --git a/test/compile_errors/stage1/obj/non-const_expression_in_struct_literal_outside_function.zig b/test/compile_errors/stage1/obj/non-const_expression_in_struct_literal_outside_function.zig
deleted file mode 100644
index 46b94f1f96994ad0d1193ba9431c0d0fe13c0cb2..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/non-const_expression_in_struct_literal_outside_function.zig
+++ /dev/null
@@ -1,13 +0,0 @@
-const Foo = struct {
-    x: i32,
-};
-const a = Foo {.x = get_it()};
-extern fn get_it() i32;
-
-export fn entry() usize { return @sizeOf(@TypeOf(a)); }
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:4:21: error: unable to evaluate constant expression
diff --git a/test/compile_errors/stage1/obj/non-const_switch_number_literal.zig b/test/compile_errors/stage1/obj/non-const_switch_number_literal.zig
deleted file mode 100644
index 005db548ed7bbce6cbcedb79491ce64aa288d57a..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/non-const_switch_number_literal.zig
+++ /dev/null
@@ -1,17 +0,0 @@
-export fn foo() void {
-    const x = switch (bar()) {
-        1, 2 => 1,
-        3, 4 => 2,
-        else => 3,
-    };
-    _ = x;
-}
-fn bar() i32 {
-    return 2;
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:5:17: error: cannot store runtime value in type 'comptime_int'
diff --git a/test/compile_errors/stage1/obj/non-const_variables_of_things_that_require_const_variables.zig b/test/compile_errors/stage1/obj/non-const_variables_of_things_that_require_const_variables.zig
deleted file mode 100644
index 73ef29aa5472a7f619dfa18039665ec9c62ccc3e..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/non-const_variables_of_things_that_require_const_variables.zig
+++ /dev/null
@@ -1,51 +0,0 @@
-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;
-}
-const Opaque = opaque {};
-const Foo = struct {
-    fn bar(self: *const Foo) void {_ = self;}
-};
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:2:4: error: variable of type '*const comptime_int' must be const or comptime
-// tmp.zig:6:4: error: variable of type '@Type(.Undefined)' must be const or comptime
-// tmp.zig:10:4: error: variable of type 'comptime_int' must be const or comptime
-// tmp.zig:10: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 'comptime_float' must be const or comptime
-// tmp.zig:14:4: note: to modify this variable at runtime, it must be given an explicit fixed-size number type
-// tmp.zig:18:4: error: variable of type '@Type(.Null)' must be const or comptime
-// tmp.zig:22:4: error: variable of type 'Opaque' not allowed
-// tmp.zig:26:4: error: variable of type 'type' must be const or comptime
-// tmp.zig:30:4: error: variable of type '(bound fn(*const Foo) void)' must be const or comptime
diff --git a/test/compile_errors/stage1/obj/non-enum_tag_type_passed_to_union.zig b/test/compile_errors/stage1/obj/non-enum_tag_type_passed_to_union.zig
deleted file mode 100644
index e188a3f819fd55ac18a82e8ed4b37d36e236898b..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/non-enum_tag_type_passed_to_union.zig
+++ /dev/null
@@ -1,13 +0,0 @@
-const Foo = union(u32) {
-    A: i32,
-};
-export fn entry() void {
-    const x = @typeInfo(Foo).Union.tag_type.?;
-    _ = x;
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:1:19: error: expected enum tag type, found 'u32'
diff --git a/test/compile_errors/stage1/obj/non-extern_function_with_var_args.zig b/test/compile_errors/stage1/obj/non-extern_function_with_var_args.zig
deleted file mode 100644
index 9e5463d451c92e4a36dfb568df084b9570cd7968..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/non-extern_function_with_var_args.zig
+++ /dev/null
@@ -1,10 +0,0 @@
-fn foo(args: ...) void {}
-export fn entry() void {
-    foo();
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:1:14: error: expected type expression, found '...'
diff --git a/test/compile_errors/stage1/obj/non-inline_for_loop_on_a_type_that_requires_comptime.zig b/test/compile_errors/stage1/obj/non-inline_for_loop_on_a_type_that_requires_comptime.zig
deleted file mode 100644
index d2b4e28ea6d2afb7855ac2f1c035e253c2c07812..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/non-inline_for_loop_on_a_type_that_requires_comptime.zig
+++ /dev/null
@@ -1,14 +0,0 @@
-const Foo = struct {
-    name: []const u8,
-    T: type,
-};
-export fn entry() void {
-    const xx: [2]Foo = undefined;
-    for (xx) |f| { _ = f;}
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:7:5: error: values of type 'Foo' must be comptime known, but index value is runtime known
diff --git a/test/compile_errors/stage1/obj/non-integer_tag_type_to_automatic_union_enum.zig b/test/compile_errors/stage1/obj/non-integer_tag_type_to_automatic_union_enum.zig
deleted file mode 100644
index 41d5e1416353753c2d97c8c3e34b93c43d03b008..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/non-integer_tag_type_to_automatic_union_enum.zig
+++ /dev/null
@@ -1,13 +0,0 @@
-const Foo = union(enum(f32)) {
-    A: i32,
-};
-export fn entry() void {
-    const x = @typeInfo(Foo).Union.tag_type.?;
-    _ = x;
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:1:24: error: expected integer tag type, found 'f32'
diff --git a/test/compile_errors/stage1/obj/non-pure_function_returns_type.zig b/test/compile_errors/stage1/obj/non-pure_function_returns_type.zig
deleted file mode 100644
index 9d1c642273a5268eb34867626a7095a176a08a1a..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/non-pure_function_returns_type.zig
+++ /dev/null
@@ -1,24 +0,0 @@
-var a: u32 = 0;
-pub fn List(comptime T: type) type {
-    a += 1;
-    return SmallList(T, 8);
-}
-
-pub fn SmallList(comptime T: type, comptime STATIC_SIZE: usize) type {
-    return struct {
-        items: []T,
-        length: usize,
-        prealloc_items: [STATIC_SIZE]T,
-    };
-}
-
-export fn function_with_return_type_type() void {
-    var list: List(i32) = undefined;
-    list.length = 10;
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:3:7: error: unable to evaluate constant expression
diff --git a/test/compile_errors/stage1/obj/non_async_function_pointer_passed_to_asyncCall.zig b/test/compile_errors/stage1/obj/non_async_function_pointer_passed_to_asyncCall.zig
deleted file mode 100644
index d8ab4087e0a32dd2971c7bc51e3b662d30281bb0..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/non_async_function_pointer_passed_to_asyncCall.zig
+++ /dev/null
@@ -1,12 +0,0 @@
-export fn entry() void {
-    var ptr = afunc;
-    var bytes: [100]u8 align(16) = undefined;
-    _ = @asyncCall(&bytes, {}, ptr, .{});
-}
-fn afunc() void { }
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:4:32: error: expected async function, found 'fn() void'
diff --git a/test/compile_errors/stage1/obj/non_compile_time_array_concatenation.zig b/test/compile_errors/stage1/obj/non_compile_time_array_concatenation.zig
deleted file mode 100644
index e70e6daf324fe492660e3da37d4d4655820b2705..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/non_compile_time_array_concatenation.zig
+++ /dev/null
@@ -1,11 +0,0 @@
-fn f() []u8 {
-    return s ++ "foo";
-}
-var s: [10]u8 = undefined;
-export fn entry() usize { return @sizeOf(@TypeOf(f)); }
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:2:12: error: unable to evaluate constant expression
diff --git a/test/compile_errors/stage1/obj/non_constant_expression_in_array_size.zig b/test/compile_errors/stage1/obj/non_constant_expression_in_array_size.zig
deleted file mode 100644
index a0cb8e8ce15cbe6eb7f23917a2ce84d9293853de..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/non_constant_expression_in_array_size.zig
+++ /dev/null
@@ -1,14 +0,0 @@
-const Foo = struct {
-    y: [get()]u8,
-};
-var global_var: usize = 1;
-fn get() usize { return global_var; }
-
-export fn entry() usize { return @sizeOf(@TypeOf(Foo)); }
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:5:25: error: cannot store runtime value in compile time variable
-// tmp.zig:2:12: note: called from here
diff --git a/test/compile_errors/stage1/obj/non_error_sets_used_in_merge_error_sets_operator.zig b/test/compile_errors/stage1/obj/non_error_sets_used_in_merge_error_sets_operator.zig
deleted file mode 100644
index fc3431820c528574b508a57f984c9807edcb9d7d..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/non_error_sets_used_in_merge_error_sets_operator.zig
+++ /dev/null
@@ -1,17 +0,0 @@
-export fn foo() void {
-    const Errors = u8 || u16;
-    _ = Errors;
-}
-export fn bar() void {
-    const Errors = error{} || u16;
-    _ = Errors;
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// 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:6:31: error: expected error set type, found type 'u16'
-// tmp.zig:6:28: note: `||` merges error sets; `or` performs boolean OR
diff --git a/test/compile_errors/stage1/obj/non_float_passed_to_floatToInt.zig b/test/compile_errors/stage1/obj/non_float_passed_to_floatToInt.zig
deleted file mode 100644
index c91025906a66cfaf91b1cb91072cbe9adbd49f75..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/non_float_passed_to_floatToInt.zig
+++ /dev/null
@@ -1,10 +0,0 @@
-export fn entry() void {
-    const x = @floatToInt(i32, @as(i32, 54));
-    _ = x;
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:2:32: error: expected float type, found 'i32'
diff --git a/test/compile_errors/stage1/obj/non_int_passed_to_intToFloat.zig b/test/compile_errors/stage1/obj/non_int_passed_to_intToFloat.zig
deleted file mode 100644
index 8f6acca51e083db32fbbb0a7bf1e90a1a974f069..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/non_int_passed_to_intToFloat.zig
+++ /dev/null
@@ -1,10 +0,0 @@
-export fn entry() void {
-    const x = @intToFloat(f32, 1.1);
-    _ = x;
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:2:32: error: expected int type, found 'comptime_float'
diff --git a/test/compile_errors/stage1/obj/non_pointer_given_to_ptrToInt.zig b/test/compile_errors/stage1/obj/non_pointer_given_to_ptrToInt.zig
deleted file mode 100644
index 7824c0f7964f68a586301350a515afc5cd4ac5c7..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/non_pointer_given_to_ptrToInt.zig
+++ /dev/null
@@ -1,9 +0,0 @@
-export fn entry(x: i32) usize {
-    return @ptrToInt(x);
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:2:22: error: expected pointer, found 'i32'
diff --git a/test/compile_errors/stage1/obj/normal_string_with_newline.zig b/test/compile_errors/stage1/obj/normal_string_with_newline.zig
deleted file mode 100644
index f6c1d1b1b9b1a47bd26f4f544a35c5b8df64078f..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/normal_string_with_newline.zig
+++ /dev/null
@@ -1,9 +0,0 @@
-const foo = "a
-b";
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:1:13: error: expected expression, found 'invalid bytes'
-// tmp.zig:1:15: note: invalid byte: '\n'
diff --git a/test/compile_errors/stage1/obj/offsetOf-bad_field_name.zig b/test/compile_errors/stage1/obj/offsetOf-bad_field_name.zig
deleted file mode 100644
index de5b82c22c6c68a7f8d835e421266f5327948859..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/offsetOf-bad_field_name.zig
+++ /dev/null
@@ -1,12 +0,0 @@
-const Foo = struct {
-    derp: i32,
-};
-export fn foo() usize {
-    return @offsetOf(Foo, "a",);
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:5:27: error: struct 'Foo' has no field 'a'
diff --git a/test/compile_errors/stage1/obj/offsetOf-non_struct.zig b/test/compile_errors/stage1/obj/offsetOf-non_struct.zig
deleted file mode 100644
index 15275b827b2fedb3a8c28f17d1957b38d8f013f5..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/offsetOf-non_struct.zig
+++ /dev/null
@@ -1,10 +0,0 @@
-const Foo = i32;
-export fn foo() usize {
-    return @offsetOf(Foo, "a",);
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:3:22: error: expected struct type, found 'i32'
diff --git a/test/compile_errors/stage1/obj/only_equality_binary_operator_allowed_for_error_sets.zig b/test/compile_errors/stage1/obj/only_equality_binary_operator_allowed_for_error_sets.zig
deleted file mode 100644
index ff9c4d18a29ccbe9350b203f18ad284e572b9622..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/only_equality_binary_operator_allowed_for_error_sets.zig
+++ /dev/null
@@ -1,10 +0,0 @@
-comptime {
-    const z = error.A > error.B;
-    _ = z;
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:2:23: error: operator not allowed for errors
diff --git a/test/compile_errors/stage1/obj/opaque_type_with_field.zig b/test/compile_errors/stage1/obj/opaque_type_with_field.zig
deleted file mode 100644
index 0b87091de945bdf3b94fd987de5496ca4336d839..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/opaque_type_with_field.zig
+++ /dev/null
@@ -1,11 +0,0 @@
-const Opaque = opaque { foo: i32 };
-export fn entry() void {
-    const foo: ?*Opaque = null;
-    _ = foo;
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:1:25: error: opaque types cannot have fields
diff --git a/test/compile_errors/stage1/obj/optional_pointer_to_void_in_extern_struct.zig b/test/compile_errors/stage1/obj/optional_pointer_to_void_in_extern_struct.zig
deleted file mode 100644
index 552f672ad667b49a7320c60951c59bd77cea699c..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/optional_pointer_to_void_in_extern_struct.zig
+++ /dev/null
@@ -1,14 +0,0 @@
-const Foo = extern struct {
-    x: ?*const void,
-};
-const Bar = extern struct {
-    foo: Foo,
-    y: i32,
-};
-export fn entry(bar: *Bar) void {_ = bar;}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:2:5: error: extern structs cannot contain fields of type '?*const void'
diff --git a/test/compile_errors/stage1/obj/or_on_undefined_value.zig b/test/compile_errors/stage1/obj/or_on_undefined_value.zig
deleted file mode 100644
index 11e6c41deaa52764da050eea129327b3e530550e..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/or_on_undefined_value.zig
+++ /dev/null
@@ -1,10 +0,0 @@
-comptime {
-    var a: bool = undefined;
-    _ = a or a;
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:3:9: error: use of undefined value here causes undefined behavior
diff --git a/test/compile_errors/stage1/obj/orelse_on_undefined_value.zig b/test/compile_errors/stage1/obj/orelse_on_undefined_value.zig
deleted file mode 100644
index 3042c208eb3fbe2ad65e0ccb95d087147a78cfda..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/orelse_on_undefined_value.zig
+++ /dev/null
@@ -1,10 +0,0 @@
-comptime {
-    var a: ?bool = undefined;
-    _ = a orelse false;
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:3:11: error: use of undefined value here causes undefined behavior
diff --git a/test/compile_errors/stage1/obj/out_of_range_comptime_int_passed_to_floatToInt.zig b/test/compile_errors/stage1/obj/out_of_range_comptime_int_passed_to_floatToInt.zig
deleted file mode 100644
index 1a1dd541c91517a3289bb1b4a9d22bd339cef0ea..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/out_of_range_comptime_int_passed_to_floatToInt.zig
+++ /dev/null
@@ -1,10 +0,0 @@
-export fn entry() void {
-    const x = @floatToInt(i8, 200);
-    _ = x;
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:2:31: error: integer value 200 cannot be coerced to type 'i8'
diff --git a/test/compile_errors/stage1/obj/overflow_in_enum_value_allocation.zig b/test/compile_errors/stage1/obj/overflow_in_enum_value_allocation.zig
deleted file mode 100644
index c5dc5c1dcf8f697da9504f335a5da40150a4fbc1..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/overflow_in_enum_value_allocation.zig
+++ /dev/null
@@ -1,14 +0,0 @@
-const Moo = enum(u8) {
-    Last = 255,
-    Over,
-};
-pub fn main() void {
-  var y = Moo.Last;
-  _ = y;
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:3:5: error: enumeration value 256 too large for type 'u8'
diff --git a/test/compile_errors/stage1/obj/packed_union_given_enum_tag_type.zig b/test/compile_errors/stage1/obj/packed_union_given_enum_tag_type.zig
deleted file mode 100644
index fceb7af65c7c643273d0b490ef1884042296505e..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/packed_union_given_enum_tag_type.zig
+++ /dev/null
@@ -1,20 +0,0 @@
-const Letter = enum {
-    A,
-    B,
-    C,
-};
-const Payload = packed union(Letter) {
-    A: i32,
-    B: f64,
-    C: bool,
-};
-export fn entry() void {
-    var a = Payload { .A = 1234 };
-    _ = a;
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:6:30: error: packed union does not support enum tag type
diff --git a/test/compile_errors/stage1/obj/packed_union_with_automatic_layout_field.zig b/test/compile_errors/stage1/obj/packed_union_with_automatic_layout_field.zig
deleted file mode 100644
index 99ad6ca306aaeb666ef9b62cc4fb31c2f045486b..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/packed_union_with_automatic_layout_field.zig
+++ /dev/null
@@ -1,18 +0,0 @@
-const Foo = struct {
-    a: u32,
-    b: f32,
-};
-const Payload = packed union {
-    A: Foo,
-    B: bool,
-};
-export fn entry() void {
-    var a = Payload { .B = true };
-    _ = a;
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:6:5: error: non-packed, non-extern struct 'Foo' not allowed in packed union; no guaranteed in-memory representation
diff --git a/test/compile_errors/stage1/obj/panic_called_at_compile_time.zig b/test/compile_errors/stage1/obj/panic_called_at_compile_time.zig
deleted file mode 100644
index 7c169329130519f2c34c03d7040771a2f730b93f..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/panic_called_at_compile_time.zig
+++ /dev/null
@@ -1,11 +0,0 @@
-export fn entry() void {
-    comptime {
-        @panic("aoeu",);
-    }
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:3:9: error: encountered @panic at compile-time
diff --git a/test/compile_errors/stage1/obj/parameter_redeclaration.zig b/test/compile_errors/stage1/obj/parameter_redeclaration.zig
deleted file mode 100644
index 528eee8374400973c1e1b7dac9927050f2d32bf9..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/parameter_redeclaration.zig
+++ /dev/null
@@ -1,10 +0,0 @@
-fn f(a : i32, a : i32) void {
-}
-export fn entry() void { f(1, 2); }
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:1:15: error: redeclaration of function parameter 'a'
-// tmp.zig:1:6: note: previous declaration here
diff --git a/test/compile_errors/stage1/obj/parameter_shadowing_global.zig b/test/compile_errors/stage1/obj/parameter_shadowing_global.zig
deleted file mode 100644
index ce417d7188a1ced348d7a53380acbf285ddb7f11..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/parameter_shadowing_global.zig
+++ /dev/null
@@ -1,12 +0,0 @@
-const Foo = struct {};
-fn f(Foo: i32) void {}
-export fn entry() void {
-    f(1234);
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:2:6: error: local shadows declaration of 'Foo'
-// tmp.zig:1:1: note: declared here
diff --git a/test/compile_errors/stage1/obj/pass_const_ptr_to_mutable_ptr_fn.zig b/test/compile_errors/stage1/obj/pass_const_ptr_to_mutable_ptr_fn.zig
deleted file mode 100644
index 3209bb73217fce1ed8f6c180ab99a703f5e22420..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/pass_const_ptr_to_mutable_ptr_fn.zig
+++ /dev/null
@@ -1,17 +0,0 @@
-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;
-}
-
-export fn entry() usize { return @sizeOf(@TypeOf(foo)); }
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:4:19: error: expected type '*[]const u8', found '*const []const u8'
diff --git a/test/compile_errors/stage1/obj/passing_a_not-aligned-enough_pointer_to_cmpxchg.zig b/test/compile_errors/stage1/obj/passing_a_not-aligned-enough_pointer_to_cmpxchg.zig
deleted file mode 100644
index c1725f1ee85fa9d7236c598ce30e54fd06d73578..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/passing_a_not-aligned-enough_pointer_to_cmpxchg.zig
+++ /dev/null
@@ -1,12 +0,0 @@
-const AtomicOrder = @import("std").builtin.AtomicOrder;
-export fn entry() bool {
-    var x: i32 align(1) = 1234;
-    while (!@cmpxchgWeak(i32, &x, 1234, 5678, AtomicOrder.SeqCst, AtomicOrder.SeqCst)) {}
-    return x == 5678;
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:4:32: error: expected type '*i32', found '*align(1) i32'
diff --git a/test/compile_errors/stage1/obj/passing_an_under-aligned_function_pointer.zig b/test/compile_errors/stage1/obj/passing_an_under-aligned_function_pointer.zig
deleted file mode 100644
index d67bd42a72909fc074b84ed9de4f197ae388b93f..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/passing_an_under-aligned_function_pointer.zig
+++ /dev/null
@@ -1,13 +0,0 @@
-export fn entry() void {
-    testImplicitlyDecreaseFnAlign(alignedSmall, 1234);
-}
-fn testImplicitlyDecreaseFnAlign(ptr: fn () align(8) i32, answer: i32) void {
-    if (ptr() != answer) unreachable;
-}
-fn alignedSmall() align(4) i32 { return 1234; }
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:2:35: error: expected type 'fn() align(8) i32', found 'fn() align(4) i32'
diff --git a/test/compile_errors/stage1/obj/peer_cast_then_implicit_cast_const_pointer_to_mutable_C_pointer.zig b/test/compile_errors/stage1/obj/peer_cast_then_implicit_cast_const_pointer_to_mutable_C_pointer.zig
deleted file mode 100644
index 7d18e760c3045f33062f812bbc86328ec736dfc8..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/peer_cast_then_implicit_cast_const_pointer_to_mutable_C_pointer.zig
+++ /dev/null
@@ -1,11 +0,0 @@
-export fn func() void {
-    var strValue: [*c]u8 = undefined;
-    strValue = strValue orelse "";
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:3:32: error: expected type '[*c]u8', found '*const [0:0]u8'
-// tmp.zig:3:32: note: cast discards const qualifier
diff --git a/test/compile_errors/stage1/obj/pointer_arithmetic_on_pointer-to-array.zig b/test/compile_errors/stage1/obj/pointer_arithmetic_on_pointer-to-array.zig
deleted file mode 100644
index 6542aa69687b243b695ff0344045f0f79097d16e..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/pointer_arithmetic_on_pointer-to-array.zig
+++ /dev/null
@@ -1,12 +0,0 @@
-export fn foo() void {
-    var x: [10]u8 = undefined;
-    var y = &x;
-    var z = y + 1;
-    _ = z;
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:4:17: error: integer value 1 cannot be coerced to type '*[10]u8'
diff --git a/test/compile_errors/stage1/obj/pointer_attributes_checked_when_coercing_pointer_to_anon_literal.zig b/test/compile_errors/stage1/obj/pointer_attributes_checked_when_coercing_pointer_to_anon_literal.zig
deleted file mode 100644
index 8456c8afcb245ed30253136af8c48fc1d22a8029..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/pointer_attributes_checked_when_coercing_pointer_to_anon_literal.zig
+++ /dev/null
@@ -1,24 +0,0 @@
-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;
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:2:31: error: cannot cast pointer to array literal to slice type '[][]const u8'
-// tmp.zig:2:31: note: cast discards const qualifier
-// tmp.zig:6:33: error: cannot cast pointer to array literal to '*[2][]const u8'
-// tmp.zig:6:33: note: cast discards const qualifier
-// tmp.zig:11:21: error: expected type '*S', found '*const struct:11:21'
-// tmp.zig:11:21: note: cast discards const qualifier
diff --git a/test/compile_errors/stage1/obj/pointer_to_noreturn.zig b/test/compile_errors/stage1/obj/pointer_to_noreturn.zig
deleted file mode 100644
index 5afcaacaad100e896435d3ae415b11a0b27de036..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/pointer_to_noreturn.zig
+++ /dev/null
@@ -1,8 +0,0 @@
-fn a() *noreturn {}
-export fn entry() void { _ = a(); }
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:1:9: error: pointer to noreturn not allowed
diff --git a/test/compile_errors/stage1/obj/popCount-non-integer.zig b/test/compile_errors/stage1/obj/popCount-non-integer.zig
deleted file mode 100644
index a58a98faa336f69afd3229e41055310ef973df47..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/popCount-non-integer.zig
+++ /dev/null
@@ -1,9 +0,0 @@
-export fn entry(x: f32) u32 {
-    return @popCount(f32, x);
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:2:22: error: expected integer type, found 'f32'
diff --git a/test/compile_errors/stage1/obj/prevent_bad_implicit_casting_of_anyframe_types.zig b/test/compile_errors/stage1/obj/prevent_bad_implicit_casting_of_anyframe_types.zig
deleted file mode 100644
index 2e21d45c124d65f15c316631a4c2202cb42d6c4b..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/prevent_bad_implicit_casting_of_anyframe_types.zig
+++ /dev/null
@@ -1,24 +0,0 @@
-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 {}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:3:28: error: expected type 'anyframe->i32', found 'anyframe'
-// tmp.zig:8:28: error: expected type 'anyframe->i32', found 'i32'
-// tmp.zig:13:29: error: expected type 'anyframe->i32', found '*@Frame(func)'
diff --git a/test/compile_errors/stage1/obj/primitives_take_precedence_over_declarations.zig b/test/compile_errors/stage1/obj/primitives_take_precedence_over_declarations.zig
deleted file mode 100644
index 6f6107e88c9829ab12c192c029d9d6d6aed356f8..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/primitives_take_precedence_over_declarations.zig
+++ /dev/null
@@ -1,11 +0,0 @@
-const @"u8" = u16;
-export fn entry() void {
-    const a: u8 = 300;
-    _ = a;
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:3:19: error: integer value 300 cannot be coerced to type 'u8'
diff --git a/test/compile_errors/stage1/obj/ptrCast_a_0_bit_type_to_a_non-_0_bit_type.zig b/test/compile_errors/stage1/obj/ptrCast_a_0_bit_type_to_a_non-_0_bit_type.zig
deleted file mode 100644
index 2fc30d4a325a242083d2dc90810f6a0b2fd6e847..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/ptrCast_a_0_bit_type_to_a_non-_0_bit_type.zig
+++ /dev/null
@@ -1,13 +0,0 @@
-export fn entry() bool {
-    var x: u0 = 0;
-    const p = @ptrCast(?*u0, &x);
-    return p == null;
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:3:15: error: '*u0' and '?*u0' do not have the same in-memory representation
-// tmp.zig:3:31: note: '*u0' has no in-memory bits
-// tmp.zig:3:24: note: '?*u0' has in-memory bits
diff --git a/test/compile_errors/stage1/obj/ptrCast_discards_const_qualifier.zig b/test/compile_errors/stage1/obj/ptrCast_discards_const_qualifier.zig
deleted file mode 100644
index 1a90ff73f8836bd8ce77ab6cacd4a63c84a490c3..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/ptrCast_discards_const_qualifier.zig
+++ /dev/null
@@ -1,11 +0,0 @@
-export fn entry() void {
-    const x: i32 = 1234;
-    const y = @ptrCast(*i32, &x);
-    _ = y;
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:3:15: error: cast discards const qualifier
diff --git a/test/compile_errors/stage1/obj/ptrToInt_0_to_non_optional_pointer.zig b/test/compile_errors/stage1/obj/ptrToInt_0_to_non_optional_pointer.zig
deleted file mode 100644
index b8a5d1b0aa48ce8e293fd60d4509875bc82ba817..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/ptrToInt_0_to_non_optional_pointer.zig
+++ /dev/null
@@ -1,10 +0,0 @@
-export fn entry() void {
-    var b = @intToPtr(*i32, 0);
-    _ = b;
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:2:13: error: pointer type '*i32' does not allow address zero
diff --git a/test/compile_errors/stage1/obj/ptrToInt_on_void.zig b/test/compile_errors/stage1/obj/ptrToInt_on_void.zig
deleted file mode 100644
index 5012be65e076eb0a161fe8e90515df84d17231ca..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/ptrToInt_on_void.zig
+++ /dev/null
@@ -1,9 +0,0 @@
-export fn entry() bool {
-    return @ptrToInt(&{}) == @ptrToInt(&{});
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:2:23: error: pointer to size 0 type has no address
diff --git a/test/compile_errors/stage1/obj/ptrcast_to_non-pointer.zig b/test/compile_errors/stage1/obj/ptrcast_to_non-pointer.zig
deleted file mode 100644
index 7e9e9a99b719b2ff978802aec36a08a2e30138bd..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/ptrcast_to_non-pointer.zig
+++ /dev/null
@@ -1,9 +0,0 @@
-export fn entry(a: *i32) usize {
-    return @ptrCast(usize, a);
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:2:21: error: expected pointer, found 'usize'
diff --git a/test/compile_errors/stage1/obj/range_operator_in_switch_used_on_error_set.zig b/test/compile_errors/stage1/obj/range_operator_in_switch_used_on_error_set.zig
deleted file mode 100644
index 8108f429792605faa1b8aa85737004b6e71494bb..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/range_operator_in_switch_used_on_error_set.zig
+++ /dev/null
@@ -1,19 +0,0 @@
-export fn entry() void {
-    try foo(452) catch |err| switch (err) {
-        error.A ... error.B => {},
-        else => {},
-    };
-}
-fn foo(x: i32) !void {
-    switch (x) {
-        0 ... 10 => return error.Foo,
-        11 ... 20 => return error.Bar,
-        else => {},
-    }
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:3:17: error: operator not allowed for errors
diff --git a/test/compile_errors/stage1/obj/reading_past_end_of_pointer_casted_array.zig b/test/compile_errors/stage1/obj/reading_past_end_of_pointer_casted_array.zig
deleted file mode 100644
index cece3345c3f17abc3525eeed0733d57d1006ea21..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/reading_past_end_of_pointer_casted_array.zig
+++ /dev/null
@@ -1,13 +0,0 @@
-comptime {
-    const array: [4]u8 = "aoeu".*;
-    const sub_array = array[1..];
-    const int_ptr = @ptrCast(*const u24, sub_array);
-    const deref = int_ptr.*;
-    _ = deref;
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:5:26: error: attempt to read 4 bytes from [4]u8 at index 1 which is 3 bytes
diff --git a/test/compile_errors/stage1/obj/recursive_inferred_error_set.zig b/test/compile_errors/stage1/obj/recursive_inferred_error_set.zig
deleted file mode 100644
index 89a2a54cfae3a8b2f56aaefca83ccfefbe21c570..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/recursive_inferred_error_set.zig
+++ /dev/null
@@ -1,12 +0,0 @@
-export fn entry() void {
-    foo() catch unreachable;
-}
-fn foo() !void {
-    try foo();
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// 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
diff --git a/test/compile_errors/stage1/obj/redefinition_of_enums.zig b/test/compile_errors/stage1/obj/redefinition_of_enums.zig
deleted file mode 100644
index a95eb88935a25fc36e4939019c826e96622dbdb3..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/redefinition_of_enums.zig
+++ /dev/null
@@ -1,9 +0,0 @@
-const A = enum {x};
-const A = enum {x};
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:2:1: error: redeclaration of 'A'
-// tmp.zig:1:1: note: other declaration here
diff --git a/test/compile_errors/stage1/obj/redefinition_of_global_variables.zig b/test/compile_errors/stage1/obj/redefinition_of_global_variables.zig
deleted file mode 100644
index 3651946ffefa9fb3c97a39763158b3d11a9f6e6a..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/redefinition_of_global_variables.zig
+++ /dev/null
@@ -1,9 +0,0 @@
-var a : i32 = 1;
-var a : i32 = 2;
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:2:1: error: redeclaration of 'a'
-// tmp.zig:1:1: note: other declaration here
diff --git a/test/compile_errors/stage1/obj/redefinition_of_struct.zig b/test/compile_errors/stage1/obj/redefinition_of_struct.zig
deleted file mode 100644
index 8367a05e43729ca57acd871dd2451a7a91eb5f3a..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/redefinition_of_struct.zig
+++ /dev/null
@@ -1,9 +0,0 @@
-const A = struct { x : i32, };
-const A = struct { y : i32, };
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:2:1: error: redeclaration of 'A'
-// tmp.zig:1:1: note: other declaration here
diff --git a/test/compile_errors/stage1/obj/refer_to_the_type_of_a_generic_function.zig b/test/compile_errors/stage1/obj/refer_to_the_type_of_a_generic_function.zig
deleted file mode 100644
index 99ab1da8a3c5c8969af94af66b36f82606f5974e..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/refer_to_the_type_of_a_generic_function.zig
+++ /dev/null
@@ -1,11 +0,0 @@
-export fn entry() void {
-    const Func = fn (type) void;
-    const f: Func = undefined;
-    f(i32);
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:4:5: error: use of undefined value here causes undefined behavior
diff --git a/test/compile_errors/stage1/obj/referring_to_a_struct_that_is_invalid.zig b/test/compile_errors/stage1/obj/referring_to_a_struct_that_is_invalid.zig
deleted file mode 100644
index 433650cddbb2913b6548105972d3526238eea913..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/referring_to_a_struct_that_is_invalid.zig
+++ /dev/null
@@ -1,17 +0,0 @@
-const UsbDeviceRequest = struct {
-    Type: u8,
-};
-
-export fn foo() void {
-    comptime assert(@sizeOf(UsbDeviceRequest) == 0x8);
-}
-
-fn assert(ok: bool) void {
-    if (!ok) unreachable;
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:10:14: error: reached unreachable code
diff --git a/test/compile_errors/stage1/obj/regression_test_2980_base_type_u32_is_not_type_checked_properly_when_assigning_a_value_within_a_struct.zig b/test/compile_errors/stage1/obj/regression_test_2980_base_type_u32_is_not_type_checked_properly_when_assigning_a_value_within_a_struct.zig
deleted file mode 100644
index 8be44fbe054f85087c7731c351b1817ff7392ab0..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/regression_test_2980_base_type_u32_is_not_type_checked_properly_when_assigning_a_value_within_a_struct.zig
+++ /dev/null
@@ -1,21 +0,0 @@
-const Foo = struct {
-    ptr: ?*usize,
-    uval: u32,
-};
-fn get_uval(x: u32) !u32 {
-    _ = x;
-    return error.NotFound;
-}
-export fn entry() void {
-    const afoo = Foo{
-        .ptr = null,
-        .uval = get_uval(42),
-    };
-    _ = afoo;
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:12:25: error: cannot convert error union to payload type. consider using `try`, `catch`, or `if`. expected type 'u32', found '@typeInfo(@typeInfo(@TypeOf(get_uval)).Fn.return_type.?).ErrorUnion.error_set!u32'
diff --git a/test/compile_errors/stage1/obj/reify_type.Fn_with_is_generic_true.zig b/test/compile_errors/stage1/obj/reify_type.Fn_with_is_generic_true.zig
deleted file mode 100644
index f2849b5eb486fc09843e554ceaf891dbd47e4f04..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/reify_type.Fn_with_is_generic_true.zig
+++ /dev/null
@@ -1,17 +0,0 @@
-const Foo = @Type(.{
-    .Fn = .{
-        .calling_convention = .Unspecified,
-        .alignment = 0,
-        .is_generic = true,
-        .is_var_args = false,
-        .return_type = u0,
-        .args = &.{},
-    },
-});
-comptime { _ = Foo; }
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:1:20: error: Type.Fn.is_generic must be false for @Type
diff --git a/test/compile_errors/stage1/obj/reify_type.Fn_with_is_var_args_true_and_non-C_callconv.zig b/test/compile_errors/stage1/obj/reify_type.Fn_with_is_var_args_true_and_non-C_callconv.zig
deleted file mode 100644
index 4d449e9eb9e78b92c65f361b19640c805d3dbdc0..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/reify_type.Fn_with_is_var_args_true_and_non-C_callconv.zig
+++ /dev/null
@@ -1,17 +0,0 @@
-const Foo = @Type(.{
-    .Fn = .{
-        .calling_convention = .Unspecified,
-        .alignment = 0,
-        .is_generic = false,
-        .is_var_args = true,
-        .return_type = u0,
-        .args = &.{},
-    },
-});
-comptime { _ = Foo; }
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:1:20: error: varargs functions must have C calling convention
diff --git a/test/compile_errors/stage1/obj/reify_type.Fn_with_return_type_null.zig b/test/compile_errors/stage1/obj/reify_type.Fn_with_return_type_null.zig
deleted file mode 100644
index 98cbc37d41d44d86bd7e571fb7cab8fee07cbca2..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/reify_type.Fn_with_return_type_null.zig
+++ /dev/null
@@ -1,17 +0,0 @@
-const Foo = @Type(.{
-    .Fn = .{
-        .calling_convention = .Unspecified,
-        .alignment = 0,
-        .is_generic = false,
-        .is_var_args = false,
-        .return_type = null,
-        .args = &.{},
-    },
-});
-comptime { _ = Foo; }
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:1:20: error: Type.Fn.return_type must be non-null for @Type
diff --git a/test/compile_errors/stage1/obj/reify_type.Pointer_with_invalid_address_space.zig b/test/compile_errors/stage1/obj/reify_type.Pointer_with_invalid_address_space.zig
deleted file mode 100644
index 1ca97ce2505eba7d621ace7737485dc70434c79e..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/reify_type.Pointer_with_invalid_address_space.zig
+++ /dev/null
@@ -1,18 +0,0 @@
-export fn entry() void {
-    _ = @Type(.{ .Pointer = .{
-        .size = .One,
-        .is_const = false,
-        .is_volatile = false,
-        .alignment = 1,
-        .address_space = .gs,
-        .child = u8,
-        .is_allowzero = false,
-        .sentinel = null,
-    }});
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:2:16: error: address space 'gs' not available in stage 1 compiler, must be .generic
diff --git a/test/compile_errors/stage1/obj/reify_type_for_exhaustive_enum_with_non-integer_tag_type.zig b/test/compile_errors/stage1/obj/reify_type_for_exhaustive_enum_with_non-integer_tag_type.zig
deleted file mode 100644
index 56d05578be1173d6504127707635c88fc9be0982..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/reify_type_for_exhaustive_enum_with_non-integer_tag_type.zig
+++ /dev/null
@@ -1,18 +0,0 @@
-const Tag = @Type(.{
-    .Enum = .{
-        .layout = .Auto,
-        .tag_type = bool,
-        .fields = &.{},
-        .decls = &.{},
-        .is_exhaustive = false,
-    },
-});
-export fn entry() void {
-    _ = @intToEnum(Tag, 0);
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:1:20: error: Type.Enum.tag_type must be an integer type, not 'bool'
diff --git a/test/compile_errors/stage1/obj/reify_type_for_exhaustive_enum_with_undefined_tag_type.zig b/test/compile_errors/stage1/obj/reify_type_for_exhaustive_enum_with_undefined_tag_type.zig
deleted file mode 100644
index e6454d2ee5a8e71acca500edc3af9278d18db9f6..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/reify_type_for_exhaustive_enum_with_undefined_tag_type.zig
+++ /dev/null
@@ -1,18 +0,0 @@
-const Tag = @Type(.{
-    .Enum = .{
-        .layout = .Auto,
-        .tag_type = undefined,
-        .fields = &.{},
-        .decls = &.{},
-        .is_exhaustive = false,
-    },
-});
-export fn entry() void {
-    _ = @intToEnum(Tag, 0);
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:1:20: error: use of undefined value here causes undefined behavior
diff --git a/test/compile_errors/stage1/obj/reify_type_for_exhaustive_enum_with_zero_fields.zig b/test/compile_errors/stage1/obj/reify_type_for_exhaustive_enum_with_zero_fields.zig
deleted file mode 100644
index d3ce70c1b0ab286279f79727d6db6cf41a2e929f..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/reify_type_for_exhaustive_enum_with_zero_fields.zig
+++ /dev/null
@@ -1,18 +0,0 @@
-const Tag = @Type(.{
-    .Enum = .{
-        .layout = .Auto,
-        .tag_type = u1,
-        .fields = &.{},
-        .decls = &.{},
-        .is_exhaustive = true,
-    },
-});
-export fn entry() void {
-    _ = @intToEnum(Tag, 0);
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:1:20: error: enums must have 1 or more fields
diff --git a/test/compile_errors/stage1/obj/reify_type_for_tagged_union_with_extra_enum_field.zig b/test/compile_errors/stage1/obj/reify_type_for_tagged_union_with_extra_enum_field.zig
deleted file mode 100644
index 0c56cb91ea3f20c2a2febf2e06583a097b2456ae..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/reify_type_for_tagged_union_with_extra_enum_field.zig
+++ /dev/null
@@ -1,34 +0,0 @@
-const Tag = @Type(.{
-    .Enum = .{
-        .layout = .Auto,
-        .tag_type = u2,
-        .fields = &.{
-            .{ .name = "signed", .value = 0 },
-            .{ .name = "unsigned", .value = 1 },
-            .{ .name = "arst", .value = 2 },
-        },
-        .decls = &.{},
-        .is_exhaustive = true,
-    },
-});
-const Tagged = @Type(.{
-    .Union = .{
-        .layout = .Auto,
-        .tag_type = Tag,
-        .fields = &.{
-            .{ .name = "signed", .field_type = i32, .alignment = @alignOf(i32) },
-            .{ .name = "unsigned", .field_type = u32, .alignment = @alignOf(u32) },
-        },
-        .decls = &.{},
-    },
-});
-export fn entry() void {
-    var tagged = Tagged{ .signed = -1 };
-    tagged = .{ .unsigned = 1 };
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:14:23: error: enum field missing: 'arst'
diff --git a/test/compile_errors/stage1/obj/reify_type_for_tagged_union_with_extra_union_field.zig b/test/compile_errors/stage1/obj/reify_type_for_tagged_union_with_extra_union_field.zig
deleted file mode 100644
index 63cf1f178e26db73e4563c161b8ecfdd7655f164..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/reify_type_for_tagged_union_with_extra_union_field.zig
+++ /dev/null
@@ -1,35 +0,0 @@
-const Tag = @Type(.{
-    .Enum = .{
-        .layout = .Auto,
-        .tag_type = u1,
-        .fields = &.{
-            .{ .name = "signed", .value = 0 },
-            .{ .name = "unsigned", .value = 1 },
-        },
-        .decls = &.{},
-        .is_exhaustive = true,
-    },
-});
-const Tagged = @Type(.{
-    .Union = .{
-        .layout = .Auto,
-        .tag_type = Tag,
-        .fields = &.{
-            .{ .name = "signed", .field_type = i32, .alignment = @alignOf(i32) },
-            .{ .name = "unsigned", .field_type = u32, .alignment = @alignOf(u32) },
-            .{ .name = "arst", .field_type = f32, .alignment = @alignOf(f32) },
-        },
-        .decls = &.{},
-    },
-});
-export fn entry() void {
-    var tagged = Tagged{ .signed = -1 };
-    tagged = .{ .unsigned = 1 };
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:13:23: error: enum field not found: 'arst'
-// tmp.zig:1:20: note: enum declared here
diff --git a/test/compile_errors/stage1/obj/reify_type_for_union_with_opaque_field.zig b/test/compile_errors/stage1/obj/reify_type_for_union_with_opaque_field.zig
deleted file mode 100644
index d3f4f6da4b80e3b69643f5b215ab8f8c224904b0..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/reify_type_for_union_with_opaque_field.zig
+++ /dev/null
@@ -1,19 +0,0 @@
-const Untagged = @Type(.{
-    .Union = .{
-        .layout = .Auto,
-        .tag_type = null,
-        .fields = &.{
-            .{ .name = "foo", .field_type = opaque {}, .alignment = 1 },
-        },
-        .decls = &.{},
-    },
-});
-export fn entry() void {
-    _ = Untagged{};
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:1:25: error: opaque types have unknown size and therefore cannot be directly embedded in unions
diff --git a/test/compile_errors/stage1/obj/reify_type_for_union_with_zero_fields.zig b/test/compile_errors/stage1/obj/reify_type_for_union_with_zero_fields.zig
deleted file mode 100644
index 578f902697597d364a9fdd242afd66890d004ec5..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/reify_type_for_union_with_zero_fields.zig
+++ /dev/null
@@ -1,17 +0,0 @@
-const Untagged = @Type(.{
-    .Union = .{
-        .layout = .Auto,
-        .tag_type = null,
-        .fields = &.{},
-        .decls = &.{},
-    },
-});
-export fn entry() void {
-    _ = Untagged{};
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:1:25: error: unions must have 1 or more fields
diff --git a/test/compile_errors/stage1/obj/reify_type_union_payload_is_undefined.zig b/test/compile_errors/stage1/obj/reify_type_union_payload_is_undefined.zig
deleted file mode 100644
index 47be31c71142271c9022c53aeab4a3e1c8e523b8..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/reify_type_union_payload_is_undefined.zig
+++ /dev/null
@@ -1,10 +0,0 @@
-const Foo = @Type(.{
-    .Struct = undefined,
-});
-comptime { _ = Foo; }
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:1:20: error: use of undefined value here causes undefined behavior
diff --git a/test/compile_errors/stage1/obj/reify_type_with_Type.Int.zig b/test/compile_errors/stage1/obj/reify_type_with_Type.Int.zig
deleted file mode 100644
index 116bd86e0f229e17e8bf4a8a68c66dbeec1b81ba..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/reify_type_with_Type.Int.zig
+++ /dev/null
@@ -1,13 +0,0 @@
-const builtin = @import("std").builtin;
-export fn entry() void {
-    _ = @Type(builtin.Type.Int{
-        .signedness = .signed,
-        .bits = 8,
-    });
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:3:31: error: expected type 'std.builtin.Type', found 'std.builtin.Type.Int'
diff --git a/test/compile_errors/stage1/obj/reify_type_with_non-constant_expression.zig b/test/compile_errors/stage1/obj/reify_type_with_non-constant_expression.zig
deleted file mode 100644
index 7eec6b395a81a8972f70c6d6295821bc72d510f4..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/reify_type_with_non-constant_expression.zig
+++ /dev/null
@@ -1,11 +0,0 @@
-const builtin = @import("std").builtin;
-var globalTypeInfo : builtin.Type = undefined;
-export fn entry() void {
-    _ = @Type(globalTypeInfo);
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:4:15: error: unable to evaluate constant expression
diff --git a/test/compile_errors/stage1/obj/reify_type_with_undefined.zig b/test/compile_errors/stage1/obj/reify_type_with_undefined.zig
deleted file mode 100644
index 1de93ccdf62d041945319c5a8626af4eea39c2f2..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/reify_type_with_undefined.zig
+++ /dev/null
@@ -1,20 +0,0 @@
-comptime {
-    _ = @Type(.{ .Array = .{ .len = 0, .child = u8, .sentinel = undefined } });
-}
-comptime {
-    _ = @Type(.{
-        .Struct = .{
-            .fields = undefined,
-            .decls = undefined,
-            .is_tuple = false,
-            .layout = .Auto,
-        },
-    });
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:2:16: error: use of undefined value here causes undefined behavior
-// tmp.zig:5:16: error: use of undefined value here causes undefined behavior
diff --git a/test/compile_errors/stage1/obj/result_location_incompatibility_mismatching_handle_is_ptr.zig b/test/compile_errors/stage1/obj/result_location_incompatibility_mismatching_handle_is_ptr.zig
deleted file mode 100644
index 18dd6382fcb6f871f637f3ce749a3d1853531882..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/result_location_incompatibility_mismatching_handle_is_ptr.zig
+++ /dev/null
@@ -1,18 +0,0 @@
-export fn entry() void {
-    var damn = Container{
-        .not_optional = getOptional(),
-    };
-    _ = damn;
-}
-pub fn getOptional() ?i32 {
-    return 0;
-}
-pub const Container = struct {
-    not_optional: i32,
-};
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:3:36: error: cannot convert optional to payload type. consider using `.?`, `orelse`, or `if`. expected type 'i32', found '?i32'
diff --git a/test/compile_errors/stage1/obj/result_location_incompatibility_mismatching_handle_is_ptr_generic_call.zig b/test/compile_errors/stage1/obj/result_location_incompatibility_mismatching_handle_is_ptr_generic_call.zig
deleted file mode 100644
index 75811c58e1e7d118392426a29410b4fe6f770b9b..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/result_location_incompatibility_mismatching_handle_is_ptr_generic_call.zig
+++ /dev/null
@@ -1,18 +0,0 @@
-export fn entry() void {
-    var damn = Container{
-        .not_optional = getOptional(i32),
-    };
-    _ = damn;
-}
-pub fn getOptional(comptime T: type) ?T {
-    return 0;
-}
-pub const Container = struct {
-    not_optional: i32,
-};
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:3:36: error: cannot convert optional to payload type. consider using `.?`, `orelse`, or `if`. expected type 'i32', found '?i32'
diff --git a/test/compile_errors/stage1/obj/return_from_defer_expression.zig b/test/compile_errors/stage1/obj/return_from_defer_expression.zig
deleted file mode 100644
index cbe9542176d01eff318e8eda739dc9e7424e8c11..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/return_from_defer_expression.zig
+++ /dev/null
@@ -1,21 +0,0 @@
-pub fn testTrickyDefer() !void {
-    defer canFail() catch {};
-
-    defer try canFail();
-
-    const a = maybeInt() orelse return;
-}
-
-fn canFail() anyerror!void { }
-
-pub fn maybeInt() ?i32 {
-    return 0;
-}
-
-export fn entry() usize { return @sizeOf(@TypeOf(testTrickyDefer)); }
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:4:11: error: 'try' not allowed inside defer expression
diff --git a/test/compile_errors/stage1/obj/returning_error_from_void_async_function.zig b/test/compile_errors/stage1/obj/returning_error_from_void_async_function.zig
deleted file mode 100644
index 691c89a3478e21324685d27680ec26c13b0fc5f2..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/returning_error_from_void_async_function.zig
+++ /dev/null
@@ -1,12 +0,0 @@
-export fn entry() void {
-    _ = async amain();
-}
-fn amain() callconv(.Async) void {
-    return error.ShouldBeCompileError;
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:5:17: error: expected type 'void', found 'error{ShouldBeCompileError}'
diff --git a/test/compile_errors/stage1/obj/runtime-known_async_function_called.zig b/test/compile_errors/stage1/obj/runtime-known_async_function_called.zig
deleted file mode 100644
index 90685ce566297391b6924ec1a56cddc2db28aa9a..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/runtime-known_async_function_called.zig
+++ /dev/null
@@ -1,14 +0,0 @@
-export fn entry() void {
-    _ = async amain();
-}
-fn amain() void {
-    var ptr = afunc;
-    _ = ptr();
-}
-fn afunc() callconv(.Async) void {}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:6:12: error: function is not comptime-known; @asyncCall required
diff --git a/test/compile_errors/stage1/obj/runtime-known_function_called_with_async_keyword.zig b/test/compile_errors/stage1/obj/runtime-known_function_called_with_async_keyword.zig
deleted file mode 100644
index c66d0f9cbb557517b1e02bfd271871d2b229243e..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/runtime-known_function_called_with_async_keyword.zig
+++ /dev/null
@@ -1,12 +0,0 @@
-export fn entry() void {
-    var ptr = afunc;
-    _ = async ptr();
-}
-
-fn afunc() callconv(.Async) void { }
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:3:15: error: function is not comptime-known; @asyncCall required
diff --git a/test/compile_errors/stage1/obj/runtime_assignment_to_comptime_struct_type.zig b/test/compile_errors/stage1/obj/runtime_assignment_to_comptime_struct_type.zig
deleted file mode 100644
index 62b09673eb9479c3fe9fe75f50543a25a3bdd220..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/runtime_assignment_to_comptime_struct_type.zig
+++ /dev/null
@@ -1,15 +0,0 @@
-const Foo = struct {
-    Bar: u8,
-    Baz: type,
-};
-export fn f() void {
-    var x: u8 = 0;
-    const foo = Foo { .Bar = x, .Baz = u8 };
-    _ = foo;
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:7:23: error: unable to evaluate constant expression
diff --git a/test/compile_errors/stage1/obj/runtime_assignment_to_comptime_union_type.zig b/test/compile_errors/stage1/obj/runtime_assignment_to_comptime_union_type.zig
deleted file mode 100644
index af13f8b8ce9068c97a8015a39fca9be4cf6b8569..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/runtime_assignment_to_comptime_union_type.zig
+++ /dev/null
@@ -1,15 +0,0 @@
-const Foo = union {
-    Bar: u8,
-    Baz: type,
-};
-export fn f() void {
-    var x: u8 = 0;
-    const foo = Foo { .Bar = x };
-    _ = foo;
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:7:23: error: unable to evaluate constant expression
diff --git a/test/compile_errors/stage1/obj/runtime_cast_to_union_which_has_non-void_fields.zig b/test/compile_errors/stage1/obj/runtime_cast_to_union_which_has_non-void_fields.zig
deleted file mode 100644
index d25c815c7e01d6df0b4bda73c3727b2f06ef6e8b..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/runtime_cast_to_union_which_has_non-void_fields.zig
+++ /dev/null
@@ -1,20 +0,0 @@
-const Letter = enum { A, B, C };
-const Value = union(Letter) {
-    A: i32,
-    B,
-    C,
-};
-export fn entry() void {
-    foo(Letter.A);
-}
-fn foo(l: Letter) void {
-    var x: Value = l;
-    _ = x;
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// 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'
diff --git a/test/compile_errors/stage1/obj/runtime_index_into_comptime_type_slice.zig b/test/compile_errors/stage1/obj/runtime_index_into_comptime_type_slice.zig
deleted file mode 100644
index 379767c7f36801b29114092c460883cdf21e45c1..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/runtime_index_into_comptime_type_slice.zig
+++ /dev/null
@@ -1,17 +0,0 @@
-const Struct = struct {
-    a: u32,
-};
-fn getIndex() usize {
-    return 2;
-}
-export fn entry() void {
-    const index = getIndex();
-    const field = @typeInfo(Struct).Struct.fields[index];
-    _ = field;
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:9:51: error: values of type 'std.builtin.Type.StructField' must be comptime known, but index value is runtime known
diff --git a/test/compile_errors/stage1/obj/saturating_arithmetic_does_not_allow_floats.zig b/test/compile_errors/stage1/obj/saturating_arithmetic_does_not_allow_floats.zig
deleted file mode 100644
index 7bda134af6106e249610d83810afd6a74f26eff6..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/saturating_arithmetic_does_not_allow_floats.zig
+++ /dev/null
@@ -1,9 +0,0 @@
-export fn a() void {
-    _ = @as(f32, 1.0) +| @as(f32, 1.0);
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// error: invalid operands to binary expression: 'f32' and 'f32'
diff --git a/test/compile_errors/stage1/obj/saturating_shl_assign_does_not_allow_negative_rhs_at_comptime.zig b/test/compile_errors/stage1/obj/saturating_shl_assign_does_not_allow_negative_rhs_at_comptime.zig
deleted file mode 100644
index 7b94f8e832b9f9f53eaac1e2964c5c523a4bf003..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/saturating_shl_assign_does_not_allow_negative_rhs_at_comptime.zig
+++ /dev/null
@@ -1,12 +0,0 @@
-export fn a() void {
-    comptime {
-      var x = @as(i32, 1);
-      x <<|= @as(i32, -2);
-  }
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// error: shift by negative value -2
diff --git a/test/compile_errors/stage1/obj/saturating_shl_does_not_allow_negative_rhs_at_comptime.zig b/test/compile_errors/stage1/obj/saturating_shl_does_not_allow_negative_rhs_at_comptime.zig
deleted file mode 100644
index ac1ce7d3a0e14088a7a15a674a755ef1a15145e6..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/saturating_shl_does_not_allow_negative_rhs_at_comptime.zig
+++ /dev/null
@@ -1,9 +0,0 @@
-export fn a() void {
-    _ = @as(i32, 1) <<| @as(i32, -2);
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// error: shift by negative value -2
diff --git a/test/compile_errors/stage1/obj/setAlignStack_in_inline_function.zig b/test/compile_errors/stage1/obj/setAlignStack_in_inline_function.zig
deleted file mode 100644
index 8490298aa37c081db7e9a2fd58cb00e8ce877471..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/setAlignStack_in_inline_function.zig
+++ /dev/null
@@ -1,12 +0,0 @@
-export fn entry() void {
-    foo();
-}
-fn foo() callconv(.Inline) void {
-    @setAlignStack(16);
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:5:5: error: @setAlignStack in inline function
diff --git a/test/compile_errors/stage1/obj/setAlignStack_in_naked_function.zig b/test/compile_errors/stage1/obj/setAlignStack_in_naked_function.zig
deleted file mode 100644
index b9adc84ed540f1a0c4a1c10bc9b34c3017fc5ae5..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/setAlignStack_in_naked_function.zig
+++ /dev/null
@@ -1,9 +0,0 @@
-export fn entry() callconv(.Naked) void {
-    @setAlignStack(16);
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:2:5: error: @setAlignStack in naked function
diff --git a/test/compile_errors/stage1/obj/setAlignStack_outside_function.zig b/test/compile_errors/stage1/obj/setAlignStack_outside_function.zig
deleted file mode 100644
index 754756012b4fd77e4dadfeca2175ac923712739a..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/setAlignStack_outside_function.zig
+++ /dev/null
@@ -1,9 +0,0 @@
-comptime {
-    @setAlignStack(16);
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:2:5: error: @setAlignStack outside function
diff --git a/test/compile_errors/stage1/obj/setAlignStack_set_twice.zig b/test/compile_errors/stage1/obj/setAlignStack_set_twice.zig
deleted file mode 100644
index 244db9d96208061e2cd1540cab696bf5634b3945..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/setAlignStack_set_twice.zig
+++ /dev/null
@@ -1,11 +0,0 @@
-export fn entry() void {
-    @setAlignStack(16);
-    @setAlignStack(16);
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:3:5: error: alignstack set twice
-// tmp.zig:2:5: note: first set here
diff --git a/test/compile_errors/stage1/obj/setAlignStack_too_big.zig b/test/compile_errors/stage1/obj/setAlignStack_too_big.zig
deleted file mode 100644
index 601631e15840ec7c1360190b0dcbab78734ae679..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/setAlignStack_too_big.zig
+++ /dev/null
@@ -1,9 +0,0 @@
-export fn entry() void {
-    @setAlignStack(511 + 1);
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:2:5: error: attempt to @setAlignStack(512); maximum is 256
diff --git a/test/compile_errors/stage1/obj/setFloatMode_twice_for_same_scope.zig b/test/compile_errors/stage1/obj/setFloatMode_twice_for_same_scope.zig
deleted file mode 100644
index 41fe6d4d6c4e9d78c5fea3055843a76355d6b061..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/setFloatMode_twice_for_same_scope.zig
+++ /dev/null
@@ -1,11 +0,0 @@
-export fn foo() void {
-    @setFloatMode(@import("std").builtin.FloatMode.Optimized);
-    @setFloatMode(@import("std").builtin.FloatMode.Optimized);
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:3:5: error: float mode set twice for same scope
-// tmp.zig:2:5: note: first set here
diff --git a/test/compile_errors/stage1/obj/setRuntimeSafety_twice_for_same_scope.zig b/test/compile_errors/stage1/obj/setRuntimeSafety_twice_for_same_scope.zig
deleted file mode 100644
index 03a93b68d55ffb08d1c185a5d5cbf33e5ecbdd50..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/setRuntimeSafety_twice_for_same_scope.zig
+++ /dev/null
@@ -1,11 +0,0 @@
-export fn foo() void {
-    @setRuntimeSafety(false);
-    @setRuntimeSafety(false);
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:3:5: error: runtime safety set twice for same scope
-// tmp.zig:2:5: note: first set here
diff --git a/test/compile_errors/stage1/obj/setting_a_section_on_a_local_variable.zig b/test/compile_errors/stage1/obj/setting_a_section_on_a_local_variable.zig
deleted file mode 100644
index 90d605dc40215c54d6ac969cc96c1a55c549a2c2..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/setting_a_section_on_a_local_variable.zig
+++ /dev/null
@@ -1,10 +0,0 @@
-export fn entry() i32 {
-    var foo: i32 linksection(".text2") = 1234;
-    return foo;
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:2:30: error: cannot set section of local variable 'foo'
diff --git a/test/compile_errors/stage1/obj/shift_amount_has_to_be_an_integer_type.zig b/test/compile_errors/stage1/obj/shift_amount_has_to_be_an_integer_type.zig
deleted file mode 100644
index 53794dba1b80a07067305abb27fe5224d30a2710..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/shift_amount_has_to_be_an_integer_type.zig
+++ /dev/null
@@ -1,10 +0,0 @@
-export fn entry() void {
-    const x = 1 << &@as(u8, 10);
-    _ = x;
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:2:21: error: shift amount has to be an integer type, but found '*const u8'
diff --git a/test/compile_errors/stage1/obj/shift_by_negative_comptime_integer.zig b/test/compile_errors/stage1/obj/shift_by_negative_comptime_integer.zig
deleted file mode 100644
index 3425cf565ebe8e92485bef9f93d44dbd56d3110a..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/shift_by_negative_comptime_integer.zig
+++ /dev/null
@@ -1,10 +0,0 @@
-comptime {
-    var a = 1 >> -1;
-    _ = a;
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:2:18: error: shift by negative value -1
diff --git a/test/compile_errors/stage1/obj/shift_left_assign_on_undefined_value.zig b/test/compile_errors/stage1/obj/shift_left_assign_on_undefined_value.zig
deleted file mode 100644
index 575bf0ee6b60cd3bc30b6b520773dfaee5fe3b56..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/shift_left_assign_on_undefined_value.zig
+++ /dev/null
@@ -1,10 +0,0 @@
-comptime {
-    var a: i64 = undefined;
-    a >>= 2;
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:3:5: error: use of undefined value here causes undefined behavior
diff --git a/test/compile_errors/stage1/obj/shift_left_on_undefined_value.zig b/test/compile_errors/stage1/obj/shift_left_on_undefined_value.zig
deleted file mode 100644
index abd06fbbabebfe422aee08e3ab758b13c028f7da..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/shift_left_on_undefined_value.zig
+++ /dev/null
@@ -1,10 +0,0 @@
-comptime {
-    var a: i64 = undefined;
-    _ = a << 2;
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:3:9: error: use of undefined value here causes undefined behavior
diff --git a/test/compile_errors/stage1/obj/shift_right_assign_on_undefined_value.zig b/test/compile_errors/stage1/obj/shift_right_assign_on_undefined_value.zig
deleted file mode 100644
index 575bf0ee6b60cd3bc30b6b520773dfaee5fe3b56..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/shift_right_assign_on_undefined_value.zig
+++ /dev/null
@@ -1,10 +0,0 @@
-comptime {
-    var a: i64 = undefined;
-    a >>= 2;
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:3:5: error: use of undefined value here causes undefined behavior
diff --git a/test/compile_errors/stage1/obj/shift_right_on_undefined_value.zig b/test/compile_errors/stage1/obj/shift_right_on_undefined_value.zig
deleted file mode 100644
index e24cbe473a09a23618353883e9458d632939918d..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/shift_right_on_undefined_value.zig
+++ /dev/null
@@ -1,10 +0,0 @@
-comptime {
-    var a: i64 = undefined;
-    _ = a >> 2;
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:3:9: error: use of undefined value here causes undefined behavior
diff --git a/test/compile_errors/stage1/obj/shifting_RHS_is_log2_of_LHS_int_bit_width.zig b/test/compile_errors/stage1/obj/shifting_RHS_is_log2_of_LHS_int_bit_width.zig
deleted file mode 100644
index d9b9bbfce36755bf318250d73451fc61c6012983..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/shifting_RHS_is_log2_of_LHS_int_bit_width.zig
+++ /dev/null
@@ -1,9 +0,0 @@
-export fn entry(x: u8, y: u8) u8 {
-    return x << y;
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:2:17: error: expected type 'u3', found 'u8'
diff --git a/test/compile_errors/stage1/obj/shifting_without_int_type_or_comptime_known.zig b/test/compile_errors/stage1/obj/shifting_without_int_type_or_comptime_known.zig
deleted file mode 100644
index 4d875575d016505922129b062d5c922be6786395..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/shifting_without_int_type_or_comptime_known.zig
+++ /dev/null
@@ -1,9 +0,0 @@
-export fn entry(x: u8) u8 {
-    return 0x11 << x;
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:2:17: error: LHS of shift must be a fixed-width integer type, or RHS must be compile-time known
diff --git a/test/compile_errors/stage1/obj/shlExact_shifts_out_1_bits.zig b/test/compile_errors/stage1/obj/shlExact_shifts_out_1_bits.zig
deleted file mode 100644
index 953c5fec50199c59dd2669b4e8601d026f4d70f8..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/shlExact_shifts_out_1_bits.zig
+++ /dev/null
@@ -1,10 +0,0 @@
-comptime {
-    const x = @shlExact(@as(u8, 0b01010101), 2);
-    _ = x;
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:2:15: error: operation caused overflow
diff --git a/test/compile_errors/stage1/obj/shrExact_shifts_out_1_bits.zig b/test/compile_errors/stage1/obj/shrExact_shifts_out_1_bits.zig
deleted file mode 100644
index 223db7663042f98a32ff416c5e513d806e6e155a..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/shrExact_shifts_out_1_bits.zig
+++ /dev/null
@@ -1,10 +0,0 @@
-comptime {
-    const x = @shrExact(@as(u8, 0b10101010), 2);
-    _ = x;
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:2:15: error: exact shift shifted out 1 bits
diff --git a/test/compile_errors/stage1/obj/signed_integer_division.zig b/test/compile_errors/stage1/obj/signed_integer_division.zig
deleted file mode 100644
index 3eebbf2248dbb2acd204d755c00346e2abbbdf6a..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/signed_integer_division.zig
+++ /dev/null
@@ -1,9 +0,0 @@
-export fn foo(a: i32, b: i32) i32 {
-    return a / b;
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:2:14: error: division with 'i32' and 'i32': signed integers must use @divTrunc, @divFloor, or @divExact
diff --git a/test/compile_errors/stage1/obj/signed_integer_remainder_division.zig b/test/compile_errors/stage1/obj/signed_integer_remainder_division.zig
deleted file mode 100644
index 58776729543830b4850da0851947441810a0a33f..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/signed_integer_remainder_division.zig
+++ /dev/null
@@ -1,9 +0,0 @@
-export fn foo(a: i32, b: i32) i32 {
-    return a % b;
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:2:14: error: remainder division with 'i32' and 'i32': signed integers and floats must use @rem or @mod
diff --git a/test/compile_errors/stage1/obj/sizeOf_bad_type.zig b/test/compile_errors/stage1/obj/sizeOf_bad_type.zig
deleted file mode 100644
index f8c397f768620b7a0fb480a2c68c78c3dcf72f75..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/sizeOf_bad_type.zig
+++ /dev/null
@@ -1,9 +0,0 @@
-export fn entry() usize {
-    return @sizeOf(@TypeOf(null));
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:2:20: error: no size available for type '@Type(.Null)'
diff --git a/test/compile_errors/stage1/obj/slice_cannot_have_its_bytes_reinterpreted.zig b/test/compile_errors/stage1/obj/slice_cannot_have_its_bytes_reinterpreted.zig
deleted file mode 100644
index 8fcf4f505c94690e48ba2a0b6cfe559068423bc4..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/slice_cannot_have_its_bytes_reinterpreted.zig
+++ /dev/null
@@ -1,11 +0,0 @@
-export fn foo() void {
-    const bytes = [1]u8{ 0xfa } ** 16;
-    var value = @ptrCast(*const []const u8, &bytes).*;
-    _ = value;
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// :3:52: error: slice '[]const u8' cannot have its bytes reinterpreted
diff --git a/test/compile_errors/stage1/obj/slice_passed_as_array_init_type.zig b/test/compile_errors/stage1/obj/slice_passed_as_array_init_type.zig
deleted file mode 100644
index 7ad29b1900b98546ce17377f2b77d71e6e794bec..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/slice_passed_as_array_init_type.zig
+++ /dev/null
@@ -1,10 +0,0 @@
-export fn entry() void {
-    const x = []u8{};
-    _ = x;
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:2:15: error: array literal requires address-of operator (&) to coerce to slice type '[]u8'
diff --git a/test/compile_errors/stage1/obj/slice_passed_as_array_init_type_with_elems.zig b/test/compile_errors/stage1/obj/slice_passed_as_array_init_type_with_elems.zig
deleted file mode 100644
index 0da4b3fc9de8de87465ca09d7ddb2b6c57b37c34..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/slice_passed_as_array_init_type_with_elems.zig
+++ /dev/null
@@ -1,10 +0,0 @@
-export fn entry() void {
-    const x = []u8{1, 2};
-    _ = x;
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:2:15: error: array literal requires address-of operator (&) to coerce to slice type '[]u8'
diff --git a/test/compile_errors/stage1/obj/slice_sentinel_mismatch-1.zig b/test/compile_errors/stage1/obj/slice_sentinel_mismatch-1.zig
deleted file mode 100644
index d0c47097da9b677bab22ff8cfe0f2f5c7d6de733..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/slice_sentinel_mismatch-1.zig
+++ /dev/null
@@ -1,10 +0,0 @@
-export fn entry() void {
-    const y: [:1]const u8 = &[_:2]u8{ 1, 2 };
-    _ = y;
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:2:37: error: expected type '[:1]const u8', found '*const [2:2]u8'
diff --git a/test/compile_errors/stage1/obj/slice_sentinel_mismatch-2.zig b/test/compile_errors/stage1/obj/slice_sentinel_mismatch-2.zig
deleted file mode 100644
index 5f8d312a3c74dc031861ffb300beb641145e95a8..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/slice_sentinel_mismatch-2.zig
+++ /dev/null
@@ -1,12 +0,0 @@
-fn foo() [:0]u8 {
-    var x: []u8 = undefined;
-    return x;
-}
-comptime { _ = foo; }
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:3:12: error: expected type '[:0]u8', found '[]u8'
-// tmp.zig:3:12: note: destination pointer requires a terminating '0' sentinel
diff --git a/test/compile_errors/stage1/obj/slicing_of_global_undefined_pointer.zig b/test/compile_errors/stage1/obj/slicing_of_global_undefined_pointer.zig
deleted file mode 100644
index 8bbc0f85ebb7a4249e54f56f16b0710d02004705..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/slicing_of_global_undefined_pointer.zig
+++ /dev/null
@@ -1,10 +0,0 @@
-var buf: *[1]u8 = undefined;
-export fn entry() void {
-    _ = buf[0..1];
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:3:12: error: non-zero length slice of undefined pointer
diff --git a/test/compile_errors/stage1/obj/slicing_single-item_pointer.zig b/test/compile_errors/stage1/obj/slicing_single-item_pointer.zig
deleted file mode 100644
index d8c82fa3aff677a450d0505c102816c97c468c22..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/slicing_single-item_pointer.zig
+++ /dev/null
@@ -1,10 +0,0 @@
-export fn entry(ptr: *i32) void {
-    const slice = ptr[0..2];
-    _ = slice;
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:2:22: error: slice of single-item pointer
diff --git a/test/compile_errors/stage1/obj/specify_enum_tag_type_that_is_too_small.zig b/test/compile_errors/stage1/obj/specify_enum_tag_type_that_is_too_small.zig
deleted file mode 100644
index dc7077c8f84d0f1b21aabc89d896b3737aad7a79..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/specify_enum_tag_type_that_is_too_small.zig
+++ /dev/null
@@ -1,18 +0,0 @@
-const Small = enum (u2) {
-    One,
-    Two,
-    Three,
-    Four,
-    Five,
-};
-
-export fn entry() void {
-    var x = Small.One;
-    _ = x;
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:6:5: error: enumeration value 4 too large for type 'u2'
diff --git a/test/compile_errors/stage1/obj/specify_non-integer_enum_tag_type.zig b/test/compile_errors/stage1/obj/specify_non-integer_enum_tag_type.zig
deleted file mode 100644
index 333647e1e392afb22f7596385ceace2d6a01a48c..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/specify_non-integer_enum_tag_type.zig
+++ /dev/null
@@ -1,16 +0,0 @@
-const Small = enum (f32) {
-    One,
-    Two,
-    Three,
-};
-
-export fn entry() void {
-    var x = Small.One;
-    _ = x;
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:1:21: error: expected integer, found 'f32'
diff --git a/test/compile_errors/stage1/obj/src_outside_function.zig b/test/compile_errors/stage1/obj/src_outside_function.zig
deleted file mode 100644
index 7f8c7ae72fbd6e5f35777c91815591b18d75a32e..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/src_outside_function.zig
+++ /dev/null
@@ -1,9 +0,0 @@
-comptime {
-    @src();
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:2:5: error: @src outside function
diff --git a/test/compile_errors/stage1/obj/std.fmt_error_for_unused_arguments.zig b/test/compile_errors/stage1/obj/std.fmt_error_for_unused_arguments.zig
deleted file mode 100644
index 21603ab3d314c69482b08fd9c2038ad9d489223f..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/std.fmt_error_for_unused_arguments.zig
+++ /dev/null
@@ -1,9 +0,0 @@
-export fn entry() 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
-// backend=stage1
-// target=native
-//
-// ?:?:?: error: 10 unused arguments in '{d} {d} {d} {d} {d}'
diff --git a/test/compile_errors/stage1/obj/store_vector_pointer_with_unknown_runtime_index.zig b/test/compile_errors/stage1/obj/store_vector_pointer_with_unknown_runtime_index.zig
deleted file mode 100644
index 57e91631b1173af253233d4621f00069232be958..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/store_vector_pointer_with_unknown_runtime_index.zig
+++ /dev/null
@@ -1,16 +0,0 @@
-export fn entry() void {
-    var v: @import("std").meta.Vector(4, i32) = [_]i32{ 1, 5, 3, undefined };
-
-    var i: u32 = 0;
-    storev(&v[i], 42);
-}
-
-fn storev(ptr: anytype, val: i32) void {
-    ptr.* = val;
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:9:8: error: unable to determine vector element index of type '*align(16:0:4:?) i32
diff --git a/test/compile_errors/stage1/obj/storing_runtime_value_in_compile_time_variable_then_using_it.zig b/test/compile_errors/stage1/obj/storing_runtime_value_in_compile_time_variable_then_using_it.zig
deleted file mode 100644
index 2d85209358de870aedd0cca812642ce672c1baa7..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/storing_runtime_value_in_compile_time_variable_then_using_it.zig
+++ /dev/null
@@ -1,49 +0,0 @@
-const Mode = @import("std").builtin.Mode;
-
-fn Free(comptime filename: []const u8) TestCase {
-    return TestCase {
-        .filename = filename,
-        .problem_type = ProblemType.Free,
-    };
-}
-
-fn LibC(comptime filename: []const u8) TestCase {
-    return TestCase {
-        .filename = filename,
-        .problem_type = ProblemType.LinkLibC,
-    };
-}
-
-const TestCase = struct {
-    filename: []const u8,
-    problem_type: ProblemType,
-};
-
-const ProblemType = enum {
-    Free,
-    LinkLibC,
-};
-
-export fn entry() void {
-    const tests = [_]TestCase {
-        Free("001"),
-        Free("002"),
-        LibC("078"),
-        Free("116"),
-        Free("117"),
-    };
-
-    for ([_]Mode { Mode.Debug, Mode.ReleaseSafe, Mode.ReleaseFast }) |mode| {
-        _ = mode;
-        inline for (tests) |test_case| {
-            const foo = test_case.filename ++ ".zig";
-            _ = foo;
-        }
-    }
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:38:29: error: cannot store runtime value in compile time variable
diff --git a/test/compile_errors/stage1/obj/struct_depends_on_itself_via_optional_field.zig b/test/compile_errors/stage1/obj/struct_depends_on_itself_via_optional_field.zig
deleted file mode 100644
index 46086172f77b635fefc79407f275504634848248..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/struct_depends_on_itself_via_optional_field.zig
+++ /dev/null
@@ -1,19 +0,0 @@
-const LhsExpr = struct {
-    rhsExpr: ?AstObject,
-};
-const AstObject = union {
-    lhsExpr: LhsExpr,
-};
-export fn entry() void {
-    const lhsExpr = LhsExpr{ .rhsExpr = null };
-    const obj = AstObject{ .lhsExpr = lhsExpr };
-    _ = obj;
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:1:17: error: struct 'LhsExpr' depends on itself
-// tmp.zig:5:5: note: while checking this field
-// tmp.zig:2:5: note: while checking this field
diff --git a/test/compile_errors/stage1/obj/struct_field_missing_type.zig b/test/compile_errors/stage1/obj/struct_field_missing_type.zig
deleted file mode 100644
index 175f1c7df771210fc691b14ffda9aa57bc38e516..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/struct_field_missing_type.zig
+++ /dev/null
@@ -1,13 +0,0 @@
-const Letter = struct {
-    A,
-};
-export fn entry() void {
-    var a = Letter { .A = {} };
-    _ = a;
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:2:5: error: struct field missing type
diff --git a/test/compile_errors/stage1/obj/struct_init_syntax_for_array.zig b/test/compile_errors/stage1/obj/struct_init_syntax_for_array.zig
deleted file mode 100644
index 6362e05114651cc82838d8e9a0295a0bceec3a00..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/struct_init_syntax_for_array.zig
+++ /dev/null
@@ -1,10 +0,0 @@
-const foo = [3]u16{ .x = 1024 };
-comptime {
-    _ = foo;
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:1:13: error: initializing array with struct syntax
diff --git a/test/compile_errors/stage1/obj/struct_with_declarations_unavailable_for_reify_type.zig b/test/compile_errors/stage1/obj/struct_with_declarations_unavailable_for_reify_type.zig
deleted file mode 100644
index 409020ca257f480a5ccbb16b4fdb8147d3fef35c..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/struct_with_declarations_unavailable_for_reify_type.zig
+++ /dev/null
@@ -1,9 +0,0 @@
-export fn entry() void {
-    _ = @Type(@typeInfo(struct { const foo = 1; }));
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:2:15: error: Type.Struct.decls must be empty for @Type
diff --git a/test/compile_errors/stage1/obj/struct_with_invalid_field.zig b/test/compile_errors/stage1/obj/struct_with_invalid_field.zig
deleted file mode 100644
index dcc9d26f65bae996f07fdcde1aab66b1266f593f..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/struct_with_invalid_field.zig
+++ /dev/null
@@ -1,30 +0,0 @@
-const std = @import("std",);
-const Allocator = std.mem.Allocator;
-const ArrayList = std.ArrayList;
-
-const HeaderWeight = enum {
-    H1, H2, H3, H4, H5, H6,
-};
-
-const MdText = ArrayList(u8);
-
-const MdNode = union(enum) {
-    Header: struct {
-        text: MdText,
-        weight: HeaderValue,
-    },
-};
-
-export fn entry() void {
-    const a = MdNode.Header {
-        .text = MdText.init(std.testing.allocator),
-        .weight = HeaderWeight.H1,
-    };
-    _ = a;
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:14:17: error: use of undeclared identifier 'HeaderValue'
diff --git a/test/compile_errors/stage1/obj/sub_assign_on_undefined_value.zig b/test/compile_errors/stage1/obj/sub_assign_on_undefined_value.zig
deleted file mode 100644
index 74b705a154bfbd141d5e538c8bd09c113700421e..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/sub_assign_on_undefined_value.zig
+++ /dev/null
@@ -1,10 +0,0 @@
-comptime {
-    var a: i64 = undefined;
-    a -= a;
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:3:5: error: use of undefined value here causes undefined behavior
diff --git a/test/compile_errors/stage1/obj/sub_on_undefined_value.zig b/test/compile_errors/stage1/obj/sub_on_undefined_value.zig
deleted file mode 100644
index 08c590ee3ff3bf66c3e2dbe838bc8ecc215e9f33..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/sub_on_undefined_value.zig
+++ /dev/null
@@ -1,10 +0,0 @@
-comptime {
-    var a: i64 = undefined;
-    _ = a - a;
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:3:9: error: use of undefined value here causes undefined behavior
diff --git a/test/compile_errors/stage1/obj/sub_overflow_in_function_evaluation.zig b/test/compile_errors/stage1/obj/sub_overflow_in_function_evaluation.zig
deleted file mode 100644
index dc259e6dcfcac7fc474487a4a65d394ff74f5d2f..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/sub_overflow_in_function_evaluation.zig
+++ /dev/null
@@ -1,12 +0,0 @@
-const y = sub(10, 20);
-fn sub(a: u16, b: u16) u16 {
-    return a - b;
-}
-
-export fn entry() usize { return @sizeOf(@TypeOf(y)); }
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:3:14: error: operation caused overflow
diff --git a/test/compile_errors/stage1/obj/sub_wrap_assign_on_undefined_value.zig b/test/compile_errors/stage1/obj/sub_wrap_assign_on_undefined_value.zig
deleted file mode 100644
index 41aa1ca14b08c74891486a50150d0a09ad3b1715..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/sub_wrap_assign_on_undefined_value.zig
+++ /dev/null
@@ -1,10 +0,0 @@
-comptime {
-    var a: i64 = undefined;
-    a -%= a;
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:3:5: error: use of undefined value here causes undefined behavior
diff --git a/test/compile_errors/stage1/obj/sub_wrap_on_undefined_value.zig b/test/compile_errors/stage1/obj/sub_wrap_on_undefined_value.zig
deleted file mode 100644
index 68e4e78512f47387e83c7f20340829bca1003814..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/sub_wrap_on_undefined_value.zig
+++ /dev/null
@@ -1,10 +0,0 @@
-comptime {
-    var a: i64 = undefined;
-    _ = a -% a;
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:3:9: error: use of undefined value here causes undefined behavior
diff --git a/test/compile_errors/stage1/obj/suspend_inside_suspend_block.zig b/test/compile_errors/stage1/obj/suspend_inside_suspend_block.zig
deleted file mode 100644
index 4adffd2f2574b7f7216e3c2e93151779773978c4..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/suspend_inside_suspend_block.zig
+++ /dev/null
@@ -1,16 +0,0 @@
-export fn entry() void {
-    _ = async foo();
-}
-fn foo() void {
-    suspend {
-        suspend {
-        }
-    }
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:6:9: error: cannot suspend inside suspend block
-// tmp.zig:5:5: note: other suspend block here
diff --git a/test/compile_errors/stage1/obj/switch_expression-duplicate_enumeration_prong.zig b/test/compile_errors/stage1/obj/switch_expression-duplicate_enumeration_prong.zig
deleted file mode 100644
index 056aebe3dd415d5b069aaa62f1bd7da083120d89..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/switch_expression-duplicate_enumeration_prong.zig
+++ /dev/null
@@ -1,24 +0,0 @@
-const Number = enum {
-    One,
-    Two,
-    Three,
-    Four,
-};
-fn f(n: Number) i32 {
-    switch (n) {
-        Number.One => 1,
-        Number.Two => 2,
-        Number.Three => @as(i32, 3),
-        Number.Four => 4,
-        Number.Two => 2,
-    }
-}
-
-export fn entry() usize { return @sizeOf(@TypeOf(f)); }
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:13:15: error: duplicate switch value
-// tmp.zig:10:15: note: other value here
diff --git a/test/compile_errors/stage1/obj/switch_expression-duplicate_enumeration_prong_when_else_present.zig b/test/compile_errors/stage1/obj/switch_expression-duplicate_enumeration_prong_when_else_present.zig
deleted file mode 100644
index 4d891c3917f19c9ea21418cea7461c509a803d86..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/switch_expression-duplicate_enumeration_prong_when_else_present.zig
+++ /dev/null
@@ -1,25 +0,0 @@
-const Number = enum {
-    One,
-    Two,
-    Three,
-    Four,
-};
-fn f(n: Number) i32 {
-    switch (n) {
-        Number.One => 1,
-        Number.Two => 2,
-        Number.Three => @as(i32, 3),
-        Number.Four => 4,
-        Number.Two => 2,
-        else => 10,
-    }
-}
-
-export fn entry() usize { return @sizeOf(@TypeOf(f)); }
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:13:15: error: duplicate switch value
-// tmp.zig:10:15: note: other value here
diff --git a/test/compile_errors/stage1/obj/switch_expression-duplicate_or_overlapping_integer_value.zig b/test/compile_errors/stage1/obj/switch_expression-duplicate_or_overlapping_integer_value.zig
deleted file mode 100644
index 2810bc13e1eefe5ee620fcbc25fd0ea78f2f4254..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/switch_expression-duplicate_or_overlapping_integer_value.zig
+++ /dev/null
@@ -1,16 +0,0 @@
-fn foo(x: u8) u8 {
-    return switch (x) {
-        0 ... 100 => @as(u8, 0),
-        101 ... 200 => 1,
-        201, 203 ... 207 => 2,
-        206 ... 255 => 3,
-    };
-}
-export fn entry() usize { return @sizeOf(@TypeOf(foo)); }
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:6:9: error: duplicate switch value
-// tmp.zig:5:14: note: previous value here
diff --git a/test/compile_errors/stage1/obj/switch_expression-duplicate_type.zig b/test/compile_errors/stage1/obj/switch_expression-duplicate_type.zig
deleted file mode 100644
index b84c4622a2e0c55cb74aa8935a91e1b406286c70..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/switch_expression-duplicate_type.zig
+++ /dev/null
@@ -1,17 +0,0 @@
-fn foo(comptime T: type, x: T) u8 {
-    _ = x;
-    return switch (T) {
-        u32 => 0,
-        u64 => 1,
-        u32 => 2,
-        else => 3,
-    };
-}
-export fn entry() usize { return @sizeOf(@TypeOf(foo(u32, 0))); }
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:6:9: error: duplicate switch value
-// tmp.zig:4:9: note: previous value here
diff --git a/test/compile_errors/stage1/obj/switch_expression-duplicate_type_struct_alias.zig b/test/compile_errors/stage1/obj/switch_expression-duplicate_type_struct_alias.zig
deleted file mode 100644
index 057e674e5a97623c9518c24fc6f93f159738ddad..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/switch_expression-duplicate_type_struct_alias.zig
+++ /dev/null
@@ -1,21 +0,0 @@
-const Test = struct {
-    bar: i32,
-};
-const Test2 = Test;
-fn foo(comptime T: type, x: T) u8 {
-    _ = x;
-    return switch (T) {
-        Test => 0,
-        u64 => 1,
-        Test2 => 2,
-        else => 3,
-    };
-}
-export fn entry() usize { return @sizeOf(@TypeOf(foo(u32, 0))); }
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:10:9: error: duplicate switch value
-// tmp.zig:8:9: note: previous value here
diff --git a/test/compile_errors/stage1/obj/switch_expression-missing_enumeration_prong.zig b/test/compile_errors/stage1/obj/switch_expression-missing_enumeration_prong.zig
deleted file mode 100644
index 1a13730223b9ee9a1a7f7930f311e64956b1b31d..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/switch_expression-missing_enumeration_prong.zig
+++ /dev/null
@@ -1,21 +0,0 @@
-const Number = enum {
-    One,
-    Two,
-    Three,
-    Four,
-};
-fn f(n: Number) i32 {
-    switch (n) {
-        Number.One => 1,
-        Number.Two => 2,
-        Number.Three => @as(i32, 3),
-    }
-}
-
-export fn entry() usize { return @sizeOf(@TypeOf(f)); }
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:8:5: error: enumeration value 'Number.Four' not handled in switch
diff --git a/test/compile_errors/stage1/obj/switch_expression-multiple_else_prongs.zig b/test/compile_errors/stage1/obj/switch_expression-multiple_else_prongs.zig
deleted file mode 100644
index 82672220925567bcb41f41d0f38bffb7cafbbae7..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/switch_expression-multiple_else_prongs.zig
+++ /dev/null
@@ -1,16 +0,0 @@
-fn f(x: u32) void {
-    const value: bool = switch (x) {
-        1234 => false,
-        else => true,
-        else => true,
-    };
-}
-export fn entry() void {
-    f(1234);
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:5:9: error: multiple else prongs in switch expression
diff --git a/test/compile_errors/stage1/obj/switch_expression-non_exhaustive_integer_prongs.zig b/test/compile_errors/stage1/obj/switch_expression-non_exhaustive_integer_prongs.zig
deleted file mode 100644
index 940338edb98e409668a53bb63990a9f10c99b2a2..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/switch_expression-non_exhaustive_integer_prongs.zig
+++ /dev/null
@@ -1,12 +0,0 @@
-fn foo(x: u8) void {
-    switch (x) {
-        0 => {},
-    }
-}
-export fn entry() usize { return @sizeOf(@TypeOf(foo)); }
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:2:5: error: switch must handle all possibilities
diff --git a/test/compile_errors/stage1/obj/switch_expression-switch_on_pointer_type_with_no_else.zig b/test/compile_errors/stage1/obj/switch_expression-switch_on_pointer_type_with_no_else.zig
deleted file mode 100644
index 6a357beabed5d55f8c18205e08182b340dee5bfd..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/switch_expression-switch_on_pointer_type_with_no_else.zig
+++ /dev/null
@@ -1,13 +0,0 @@
-fn foo(x: *u8) void {
-    switch (x) {
-        &y => {},
-    }
-}
-const y: u8 = 100;
-export fn entry() usize { return @sizeOf(@TypeOf(foo)); }
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:2:5: error: else prong required when switching on type '*u8'
diff --git a/test/compile_errors/stage1/obj/switch_expression-unreachable_else_prong_bool.zig b/test/compile_errors/stage1/obj/switch_expression-unreachable_else_prong_bool.zig
deleted file mode 100644
index 2ee39f153187e00ed113cbaab9f01cd16e320182..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/switch_expression-unreachable_else_prong_bool.zig
+++ /dev/null
@@ -1,14 +0,0 @@
-fn foo(x: bool) void {
-    switch (x) {
-        true => {},
-        false => {},
-        else => {},
-    }
-}
-export fn entry() usize { return @sizeOf(@TypeOf(foo)); }
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:5:9: error: unreachable else prong, all cases already handled
diff --git a/test/compile_errors/stage1/obj/switch_expression-unreachable_else_prong_enum.zig b/test/compile_errors/stage1/obj/switch_expression-unreachable_else_prong_enum.zig
deleted file mode 100644
index bcf840ab97769c77b5521a5d40cca55544db9973..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/switch_expression-unreachable_else_prong_enum.zig
+++ /dev/null
@@ -1,24 +0,0 @@
-const TestEnum = enum{ T1, T2 };
-
-fn err(x: u8) TestEnum {
-    switch (x) {
-        0 => return TestEnum.T1,
-        else => return TestEnum.T2,
-    }
-}
-
-fn foo(x: u8) void {
-    switch (err(x)) {
-        TestEnum.T1 => {},
-        TestEnum.T2 => {},
-        else => {},
-    }
-}
-
-export fn entry() usize { return @sizeOf(@TypeOf(foo)); }
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:14:9: error: unreachable else prong, all cases already handled
diff --git a/test/compile_errors/stage1/obj/switch_expression-unreachable_else_prong_range_i8.zig b/test/compile_errors/stage1/obj/switch_expression-unreachable_else_prong_range_i8.zig
deleted file mode 100644
index f0c9d7a08a3b32fa33f0663abc152ef3649e11c4..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/switch_expression-unreachable_else_prong_range_i8.zig
+++ /dev/null
@@ -1,17 +0,0 @@
-fn foo(x: i8) void {
-    switch (x) {
-        -128...0 => {},
-        1 => {},
-        2 => {},
-        3 => {},
-        4...127 => {},
-        else => {},
-    }
-}
-export fn entry() usize { return @sizeOf(@TypeOf(foo)); }
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:8:9: error: unreachable else prong, all cases already handled
diff --git a/test/compile_errors/stage1/obj/switch_expression-unreachable_else_prong_range_u8.zig b/test/compile_errors/stage1/obj/switch_expression-unreachable_else_prong_range_u8.zig
deleted file mode 100644
index 9342ce8c32f26b8939b01f3db0d642b4dde0b32b..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/switch_expression-unreachable_else_prong_range_u8.zig
+++ /dev/null
@@ -1,17 +0,0 @@
-fn foo(x: u8) void {
-    switch (x) {
-        0 => {},
-        1 => {},
-        2 => {},
-        3 => {},
-        4...255 => {},
-        else => {},
-    }
-}
-export fn entry() usize { return @sizeOf(@TypeOf(foo)); }
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:8:9: error: unreachable else prong, all cases already handled
diff --git a/test/compile_errors/stage1/obj/switch_expression-unreachable_else_prong_u1.zig b/test/compile_errors/stage1/obj/switch_expression-unreachable_else_prong_u1.zig
deleted file mode 100644
index 90abf5074bebd8bf5c411d0c75752a6f2c4c2d48..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/switch_expression-unreachable_else_prong_u1.zig
+++ /dev/null
@@ -1,14 +0,0 @@
-fn foo(x: u1) void {
-    switch (x) {
-        0 => {},
-        1 => {},
-        else => {},
-    }
-}
-export fn entry() usize { return @sizeOf(@TypeOf(foo)); }
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:5:9: error: unreachable else prong, all cases already handled
diff --git a/test/compile_errors/stage1/obj/switch_expression-unreachable_else_prong_u2.zig b/test/compile_errors/stage1/obj/switch_expression-unreachable_else_prong_u2.zig
deleted file mode 100644
index a523046e162008ce1eff29ce29396b7060e90f0c..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/switch_expression-unreachable_else_prong_u2.zig
+++ /dev/null
@@ -1,16 +0,0 @@
-fn foo(x: u2) void {
-    switch (x) {
-        0 => {},
-        1 => {},
-        2 => {},
-        3 => {},
-        else => {},
-    }
-}
-export fn entry() usize { return @sizeOf(@TypeOf(foo)); }
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:7:9: error: unreachable else prong, all cases already handled
diff --git a/test/compile_errors/stage1/obj/switch_on_enum_with_1_field_with_no_prongs.zig b/test/compile_errors/stage1/obj/switch_on_enum_with_1_field_with_no_prongs.zig
deleted file mode 100644
index 97f7de121d69086f701c4eb986ec7329d6449c8d..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/switch_on_enum_with_1_field_with_no_prongs.zig
+++ /dev/null
@@ -1,12 +0,0 @@
-const Foo = enum { M };
-
-export fn entry() void {
-    var f = Foo.M;
-    switch (f) {}
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:5:5: error: enumeration value 'Foo.M' not handled in switch
diff --git a/test/compile_errors/stage1/obj/switch_on_union_with_no_attached_enum.zig b/test/compile_errors/stage1/obj/switch_on_union_with_no_attached_enum.zig
deleted file mode 100644
index 684861a898d769124f3c2a6c6e5ed15c319db442..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/switch_on_union_with_no_attached_enum.zig
+++ /dev/null
@@ -1,22 +0,0 @@
-const Payload = union {
-    A: i32,
-    B: f64,
-    C: bool,
-};
-export fn entry() void {
-    const a = Payload { .A = 1234 };
-    foo(a);
-}
-fn foo(a: *const Payload) void {
-    switch (a.*) {
-        Payload.A => {},
-        else => unreachable,
-    }
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:11:14: error: switch on union which has no attached enum
-// tmp.zig:1:17: note: consider 'union(enum)' here
diff --git a/test/compile_errors/stage1/obj/switch_with_invalid_expression_parameter.zig b/test/compile_errors/stage1/obj/switch_with_invalid_expression_parameter.zig
deleted file mode 100644
index 1eb74519f50fb197b25a5bf4fc843b3c83b3c52b..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/switch_with_invalid_expression_parameter.zig
+++ /dev/null
@@ -1,17 +0,0 @@
-export fn entry() void {
-    Test(i32);
-}
-fn Test(comptime T: type) void {
-    const x = switch (T) {
-        []u8 => |x| x,
-        i32 => |x| x,
-        else => unreachable,
-    };
-    _ = x;
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:7:17: error: switch on type 'type' provides no expression parameter
diff --git a/test/compile_errors/stage1/obj/switch_with_overlapping_case_ranges.zig b/test/compile_errors/stage1/obj/switch_with_overlapping_case_ranges.zig
deleted file mode 100644
index 1b03d3fe54078d85b6109bbbf916f0f637ba5d6a..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/switch_with_overlapping_case_ranges.zig
+++ /dev/null
@@ -1,13 +0,0 @@
-export fn entry() void {
-    var q: u8 = 0;
-    switch (q) {
-        1...2 => {},
-        0...255 => {},
-    }
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:5:9: error: duplicate switch value
diff --git a/test/compile_errors/stage1/obj/tagName_used_on_union_with_no_associated_enum_tag.zig b/test/compile_errors/stage1/obj/tagName_used_on_union_with_no_associated_enum_tag.zig
deleted file mode 100644
index efd9b8ceefc944bc02f8cd65f808771bc712bd70..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/tagName_used_on_union_with_no_associated_enum_tag.zig
+++ /dev/null
@@ -1,16 +0,0 @@
-const FloatInt = extern union {
-    Float: f32,
-    Int: i32,
-};
-export fn entry() void {
-    var fi = FloatInt{.Float = 123.45};
-    var tagName = @tagName(fi);
-    _ = tagName;
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:7:19: error: union has no associated enum
-// tmp.zig:1:18: note: declared here
diff --git a/test/compile_errors/stage1/obj/take_slice_of_invalid_dereference.zig b/test/compile_errors/stage1/obj/take_slice_of_invalid_dereference.zig
deleted file mode 100644
index c039be373778354fee485a624a66d1e34aade8c6..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/take_slice_of_invalid_dereference.zig
+++ /dev/null
@@ -1,10 +0,0 @@
-export fn entry() void {
-    const x = 'a'.*[0..];
-    _ = x;
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:2:18: error: attempt to dereference non-pointer type 'comptime_int'
diff --git a/test/compile_errors/stage1/obj/taking_bit_offset_of_void_field_in_struct.zig b/test/compile_errors/stage1/obj/taking_bit_offset_of_void_field_in_struct.zig
deleted file mode 100644
index e404c3bdd698fe4b4fa42774a841ebe7191c68c9..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/taking_bit_offset_of_void_field_in_struct.zig
+++ /dev/null
@@ -1,13 +0,0 @@
-const Empty = struct {
-    val: void,
-};
-export fn foo() void {
-    const fieldOffset = @bitOffsetOf(Empty, "val",);
-    _ = fieldOffset;
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:5:45: error: zero-bit field 'val' in struct 'Empty' has no offset
diff --git a/test/compile_errors/stage1/obj/taking_byte_offset_of_void_field_in_struct.zig b/test/compile_errors/stage1/obj/taking_byte_offset_of_void_field_in_struct.zig
deleted file mode 100644
index eb7d83efff7c9049cc68118178b5dd3d29a78506..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/taking_byte_offset_of_void_field_in_struct.zig
+++ /dev/null
@@ -1,13 +0,0 @@
-const Empty = struct {
-    val: void,
-};
-export fn foo() void {
-    const fieldOffset = @offsetOf(Empty, "val",);
-    _ = fieldOffset;
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:5:42: error: zero-bit field 'val' in struct 'Empty' has no offset
diff --git a/test/compile_errors/stage1/obj/threadlocal_qualifier_on_const.zig b/test/compile_errors/stage1/obj/threadlocal_qualifier_on_const.zig
deleted file mode 100644
index d34ba06879c2d6b0107941a1e4bbdd97bcf7ab7d..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/threadlocal_qualifier_on_const.zig
+++ /dev/null
@@ -1,10 +0,0 @@
-threadlocal const x: i32 = 1234;
-export fn entry() i32 {
-    return x;
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:1:1: error: threadlocal variable cannot be constant
diff --git a/test/compile_errors/stage1/obj/top_level_decl_dependency_loop.zig b/test/compile_errors/stage1/obj/top_level_decl_dependency_loop.zig
deleted file mode 100644
index ac70285c9ca3d275b281d1898a8a59dced06511f..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/top_level_decl_dependency_loop.zig
+++ /dev/null
@@ -1,12 +0,0 @@
-const a : @TypeOf(b) = 0;
-const b : @TypeOf(a) = 0;
-export fn entry() void {
-    const c = a + b;
-    _ = c;
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:2:19: error: dependency loop detected
diff --git a/test/compile_errors/stage1/obj/truncate_sign_mismatch.zig b/test/compile_errors/stage1/obj/truncate_sign_mismatch.zig
deleted file mode 100644
index 8434d9ed16da32a0f0052227d147a1ca94dbe715..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/truncate_sign_mismatch.zig
+++ /dev/null
@@ -1,25 +0,0 @@
-export fn entry1() i8 {
-    var x: u32 = 10;
-    return @truncate(i8, x);
-}
-export fn entry2() u8 {
-    var x: i32 = -10;
-    return @truncate(u8, x);
-}
-export fn entry3() i8 {
-    comptime var x: u32 = 10;
-    return @truncate(i8, x);
-}
-export fn entry4() u8 {
-    comptime var x: i32 = -10;
-    return @truncate(u8, x);
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:3:26: error: expected signed integer type, found 'u32'
-// tmp.zig:7:26: error: expected unsigned integer type, found 'i32'
-// tmp.zig:11:26: error: expected signed integer type, found 'u32'
-// tmp.zig:15:26: error: expected unsigned integer type, found 'i32'
diff --git a/test/compile_errors/stage1/obj/truncate_undefined_value.zig b/test/compile_errors/stage1/obj/truncate_undefined_value.zig
deleted file mode 100644
index 67a1f17ba783dfbd83c79483ba8f78e7ea0f1f47..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/truncate_undefined_value.zig
+++ /dev/null
@@ -1,10 +0,0 @@
-export fn entry() void {
-    var z = @truncate(u8, @as(u16, undefined));
-    _ = z;
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:2:27: error: use of undefined value here causes undefined behavior
diff --git a/test/compile_errors/stage1/obj/try_in_function_with_non_error_return_type.zig b/test/compile_errors/stage1/obj/try_in_function_with_non_error_return_type.zig
deleted file mode 100644
index c00fa2709f726bfe0b8da730520e9b3fa546c9ba..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/try_in_function_with_non_error_return_type.zig
+++ /dev/null
@@ -1,10 +0,0 @@
-export fn f() void {
-    try something();
-}
-fn something() anyerror!void { }
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:2:5: error: expected type 'void', found 'anyerror'
diff --git a/test/compile_errors/stage1/obj/type_checking_function_pointers.zig b/test/compile_errors/stage1/obj/type_checking_function_pointers.zig
deleted file mode 100644
index b88b6bdb520883c4019119306e8ae18c58d1d09d..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/type_checking_function_pointers.zig
+++ /dev/null
@@ -1,13 +0,0 @@
-fn a(b: fn (*const u8) void) void {
-    b('a');
-}
-fn c(d: u8) void {_ = d;}
-export fn entry() void {
-    a(c);
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:6:7: error: expected type 'fn(*const u8) void', found 'fn(u8) void'
diff --git a/test/compile_errors/stage1/obj/type_variables_must_be_constant.zig b/test/compile_errors/stage1/obj/type_variables_must_be_constant.zig
deleted file mode 100644
index f8cadf8520e55f99c3c8d1e623bc22dc91ff0494..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/type_variables_must_be_constant.zig
+++ /dev/null
@@ -1,10 +0,0 @@
-var foo = u8;
-export fn entry() foo {
-    return 1;
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:1:1: error: variable of type 'type' must be constant
diff --git a/test/compile_errors/stage1/obj/undeclared_identifier.zig b/test/compile_errors/stage1/obj/undeclared_identifier.zig
deleted file mode 100644
index 297a618eb8978af2398460dfaeea449a6af0ca7e..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/undeclared_identifier.zig
+++ /dev/null
@@ -1,11 +0,0 @@
-export fn a() void {
-    return
-    b +
-    c;
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:3:5: error: use of undeclared identifier 'b'
diff --git a/test/compile_errors/stage1/obj/undeclared_identifier_error_should_mark_fn_as_impure.zig b/test/compile_errors/stage1/obj/undeclared_identifier_error_should_mark_fn_as_impure.zig
deleted file mode 100644
index 697b7ccb55db0f3ff23265d131f2584e2f8cb0b9..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/undeclared_identifier_error_should_mark_fn_as_impure.zig
+++ /dev/null
@@ -1,12 +0,0 @@
-export fn foo() void {
-    test_a_thing();
-}
-fn test_a_thing() void {
-    bad_fn_call();
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:5:5: error: use of undeclared identifier 'bad_fn_call'
diff --git a/test/compile_errors/stage1/obj/undeclared_identifier_in_unanalyzed_branch.zig b/test/compile_errors/stage1/obj/undeclared_identifier_in_unanalyzed_branch.zig
deleted file mode 100644
index 2efa8ca115ac96fb9b91edfc07cd81c22957ce69..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/undeclared_identifier_in_unanalyzed_branch.zig
+++ /dev/null
@@ -1,11 +0,0 @@
-export fn a() void {
-    if (false) {
-        lol_this_doesnt_exist = nonsense;
-    }
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:3:9: error: use of undeclared identifier 'lol_this_doesnt_exist'
diff --git a/test/compile_errors/stage1/obj/undefined_as_field_type_is_rejected.zig b/test/compile_errors/stage1/obj/undefined_as_field_type_is_rejected.zig
deleted file mode 100644
index b6eb059661c10877af4c38e0e120196ae482960e..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/undefined_as_field_type_is_rejected.zig
+++ /dev/null
@@ -1,13 +0,0 @@
-const Foo = struct {
-    a: undefined,
-};
-export fn entry1() void {
-    const foo: Foo = undefined;
-    _ = foo;
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:2:8: error: use of undefined value here causes undefined behavior
diff --git a/test/compile_errors/stage1/obj/undefined_function_call.zig b/test/compile_errors/stage1/obj/undefined_function_call.zig
deleted file mode 100644
index a9627961fe514824e433319bc959dc413b108aff..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/undefined_function_call.zig
+++ /dev/null
@@ -1,9 +0,0 @@
-export fn a() void {
-    b();
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:2:5: error: use of undeclared identifier 'b'
diff --git a/test/compile_errors/stage1/obj/underscore_is_not_a_declarable_symbol.zig b/test/compile_errors/stage1/obj/underscore_is_not_a_declarable_symbol.zig
deleted file mode 100644
index f4318af8fd085db48ca01898965fe29a25d3fb28..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/underscore_is_not_a_declarable_symbol.zig
+++ /dev/null
@@ -1,10 +0,0 @@
-export fn f1() usize {
-    var _: usize = 2;
-    return _;
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:2:9: error: '_' used as an identifier without @"_" syntax
diff --git a/test/compile_errors/stage1/obj/underscore_should_not_be_usable_inside_for.zig b/test/compile_errors/stage1/obj/underscore_should_not_be_usable_inside_for.zig
deleted file mode 100644
index fe89c8372d6fa93d84df83f5dc0b9bd422a01cfa..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/underscore_should_not_be_usable_inside_for.zig
+++ /dev/null
@@ -1,13 +0,0 @@
-export fn returns() void {
-    for ([_]void{}) |_, i| {
-        for ([_]void{}) |_, j| {
-            return _;
-        }
-    }
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:4:20: error: '_' used as an identifier without @"_" syntax
diff --git a/test/compile_errors/stage1/obj/underscore_should_not_be_usable_inside_while.zig b/test/compile_errors/stage1/obj/underscore_should_not_be_usable_inside_while.zig
deleted file mode 100644
index 7f694e06031349b551bdc3bd2f21136e05c59f55..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/underscore_should_not_be_usable_inside_while.zig
+++ /dev/null
@@ -1,16 +0,0 @@
-export fn returns() void {
-    while (optionalReturn()) |_| {
-        while (optionalReturn()) |_| {
-            return _;
-        }
-    }
-}
-fn optionalReturn() ?u32 {
-    return 1;
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:4:20: error: '_' used as an identifier without @"_" syntax
diff --git a/test/compile_errors/stage1/obj/underscore_should_not_be_usable_inside_while_else.zig b/test/compile_errors/stage1/obj/underscore_should_not_be_usable_inside_while_else.zig
deleted file mode 100644
index 87a705ee698afa010defbdc94d540c3f6e41910f..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/underscore_should_not_be_usable_inside_while_else.zig
+++ /dev/null
@@ -1,18 +0,0 @@
-export fn returns() void {
-    while (optionalReturnError()) |_| {
-        while (optionalReturnError()) |_| {
-            return;
-        } else |_| {
-            if (_ == error.optionalReturnError) return;
-        }
-    }
-}
-fn optionalReturnError() !?u32 {
-    return error.optionalReturnError;
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:6:17: error: '_' used as an identifier without @"_" syntax
diff --git a/test/compile_errors/stage1/obj/union_auto-enum_value_already_taken.zig b/test/compile_errors/stage1/obj/union_auto-enum_value_already_taken.zig
deleted file mode 100644
index 3b00f95ff953f51e464a35e0468fa40bdde282c7..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/union_auto-enum_value_already_taken.zig
+++ /dev/null
@@ -1,18 +0,0 @@
-const MultipleChoice = union(enum(u32)) {
-    A = 20,
-    B = 40,
-    C = 60,
-    D = 1000,
-    E = 60,
-};
-export fn entry() void {
-    var x = MultipleChoice { .C = {} };
-    _ = x;
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:6:9: error: enum tag value 60 already taken
-// tmp.zig:4:9: note: other occurrence here
diff --git a/test/compile_errors/stage1/obj/union_enum_field_does_not_match_enum.zig b/test/compile_errors/stage1/obj/union_enum_field_does_not_match_enum.zig
deleted file mode 100644
index 38260091dc4a249657cdae7af6184db042b34177..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/union_enum_field_does_not_match_enum.zig
+++ /dev/null
@@ -1,22 +0,0 @@
-const Letter = enum {
-    A,
-    B,
-    C,
-};
-const Payload = union(Letter) {
-    A: i32,
-    B: f64,
-    C: bool,
-    D: bool,
-};
-export fn entry() void {
-    var a = Payload {.A = 1234};
-    _ = a;
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:10:5: error: enum field not found: 'D'
-// tmp.zig:1:16: note: enum declared here
diff --git a/test/compile_errors/stage1/obj/union_fields_with_value_assignments.zig b/test/compile_errors/stage1/obj/union_fields_with_value_assignments.zig
deleted file mode 100644
index 94568d55c3aef0032243009e50ae8d598b2bf7c3..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/union_fields_with_value_assignments.zig
+++ /dev/null
@@ -1,14 +0,0 @@
-const MultipleChoice = union {
-    A: i32 = 20,
-};
-export fn entry() void {
-    var x: MultipleChoice = undefined;
-    _ = x;
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:1:24: error: explicitly valued tagged union missing integer tag type
-// tmp.zig:2:14: note: tag value specified here
diff --git a/test/compile_errors/stage1/obj/union_with_0_fields.zig b/test/compile_errors/stage1/obj/union_with_0_fields.zig
deleted file mode 100644
index a6f3d69faa49f63d86a2d7fac6b480fdad0a5286..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/union_with_0_fields.zig
+++ /dev/null
@@ -1,7 +0,0 @@
-const Foo = union {};
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:1:13: error: union declarations must have at least one tag
diff --git a/test/compile_errors/stage1/obj/union_with_specified_enum_omits_field.zig b/test/compile_errors/stage1/obj/union_with_specified_enum_omits_field.zig
deleted file mode 100644
index 0bb677a18cdb128090acdbcdcba57079bbc3fdef..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/union_with_specified_enum_omits_field.zig
+++ /dev/null
@@ -1,19 +0,0 @@
-const Letter = enum {
-    A,
-    B,
-    C,
-};
-const Payload = union(Letter) {
-    A: i32,
-    B: f64,
-};
-export fn entry() usize {
-    return @sizeOf(Payload);
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:6:17: error: enum field missing: 'C'
-// tmp.zig:4:5: note: declared here
diff --git a/test/compile_errors/stage1/obj/union_with_too_small_explicit_signed_tag_type.zig b/test/compile_errors/stage1/obj/union_with_too_small_explicit_signed_tag_type.zig
deleted file mode 100644
index 97f4d48f6b84cc8dbf16ee1715a97a8c81b7ceab..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/union_with_too_small_explicit_signed_tag_type.zig
+++ /dev/null
@@ -1,16 +0,0 @@
-const U = union(enum(i2)) {
-    A: u8,
-    B: u8,
-    C: u8,
-    D: u8,
-};
-export fn entry() void {
-    _ = U{ .D = 1 };
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:1:22: error: specified integer tag type cannot represent every field
-// tmp.zig:1:22: note: type i2 cannot fit values in range 0...3
diff --git a/test/compile_errors/stage1/obj/union_with_too_small_explicit_unsigned_tag_type.zig b/test/compile_errors/stage1/obj/union_with_too_small_explicit_unsigned_tag_type.zig
deleted file mode 100644
index c1496ade86dc5e8bb1b8173dd6afe22602568c7c..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/union_with_too_small_explicit_unsigned_tag_type.zig
+++ /dev/null
@@ -1,17 +0,0 @@
-const U = union(enum(u2)) {
-    A: u8,
-    B: u8,
-    C: u8,
-    D: u8,
-    E: u8,
-};
-export fn entry() void {
-    _ = U{ .E = 1 };
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:1:22: error: specified integer tag type cannot represent every field
-// tmp.zig:1:22: note: type u2 cannot fit values in range 0...4
diff --git a/test/compile_errors/stage1/obj/unknown_length_pointer_to_opaque.zig b/test/compile_errors/stage1/obj/unknown_length_pointer_to_opaque.zig
deleted file mode 100644
index d155b986d718b90b2f09febfc1a6dd7134c2c114..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/unknown_length_pointer_to_opaque.zig
+++ /dev/null
@@ -1,7 +0,0 @@
-export const T = [*]opaque {};
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:1:21: error: unknown-length pointer to opaque
diff --git a/test/compile_errors/stage1/obj/unreachable_code-double_break.zig b/test/compile_errors/stage1/obj/unreachable_code-double_break.zig
deleted file mode 100644
index 0a19337af844a7fae0915f4d8ac9fbf64c7b47a1..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/unreachable_code-double_break.zig
+++ /dev/null
@@ -1,12 +0,0 @@
-export fn a() void {
-    const b = blk: {
-        break :blk break :blk @as(u32, 1);
-    };
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:3:9: error: unreachable code
-// tmp.zig:3:20: note: control flow is diverted here
diff --git a/test/compile_errors/stage1/obj/unreachable_code-nested_returns.zig b/test/compile_errors/stage1/obj/unreachable_code-nested_returns.zig
deleted file mode 100644
index 8a80fcd161c2d5c7f18c6398d5bd59a20dd7bf02..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/unreachable_code-nested_returns.zig
+++ /dev/null
@@ -1,10 +0,0 @@
-export fn a() i32 {
-    return return 1;
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:2:5: error: unreachable code
-// tmp.zig:2:12: note: control flow is diverted here
diff --git a/test/compile_errors/stage1/obj/unreachable_code.zig b/test/compile_errors/stage1/obj/unreachable_code.zig
deleted file mode 100644
index 30a92d06bf6f48883da302015a404e381cf0476f..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/unreachable_code.zig
+++ /dev/null
@@ -1,13 +0,0 @@
-export fn a() void {
-    return;
-    b();
-}
-
-fn b() void {}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:3:6: error: unreachable code
-// tmp.zig:2:5: note: control flow is diverted here
diff --git a/test/compile_errors/stage1/obj/unreachable_executed_at_comptime.zig b/test/compile_errors/stage1/obj/unreachable_executed_at_comptime.zig
deleted file mode 100644
index 34cb354e941656f8dd8790da9c1e40a71ed456e5..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/unreachable_executed_at_comptime.zig
+++ /dev/null
@@ -1,16 +0,0 @@
-fn foo(comptime x: i32) i32 {
-    comptime {
-        if (x >= 0) return -x;
-        unreachable;
-    }
-}
-export fn entry() void {
-    _ = foo(-42);
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:4:9: error: reached unreachable code
-// tmp.zig:8:12: note: called from here
diff --git a/test/compile_errors/stage1/obj/unreachable_parameter.zig b/test/compile_errors/stage1/obj/unreachable_parameter.zig
deleted file mode 100644
index 296194f7e33dbd4e59d0fbb6831664b8fe586426..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/unreachable_parameter.zig
+++ /dev/null
@@ -1,8 +0,0 @@
-fn f(a: noreturn) void { _ = a; }
-export fn entry() void { f(); }
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:1:9: error: parameter of type 'noreturn' not allowed
diff --git a/test/compile_errors/stage1/obj/unreachable_variable.zig b/test/compile_errors/stage1/obj/unreachable_variable.zig
deleted file mode 100644
index 7f822a8bceb9fe50102f6a50c9f9849ac047de15..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/unreachable_variable.zig
+++ /dev/null
@@ -1,10 +0,0 @@
-export fn f() void {
-    const a: noreturn = {};
-    _ = a;
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:2:25: error: expected type 'noreturn', found 'void'
diff --git a/test/compile_errors/stage1/obj/unreachable_with_return.zig b/test/compile_errors/stage1/obj/unreachable_with_return.zig
deleted file mode 100644
index 6410d24913a4ad88416b445dbd87600eb352b6e5..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/unreachable_with_return.zig
+++ /dev/null
@@ -1,8 +0,0 @@
-fn a() noreturn {return;}
-export fn entry() void { a(); }
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:1:18: error: expected type 'noreturn', found 'void'
diff --git a/test/compile_errors/stage1/obj/unsupported_modifier_at_start_of_asm_output_constraint.zig b/test/compile_errors/stage1/obj/unsupported_modifier_at_start_of_asm_output_constraint.zig
deleted file mode 100644
index 7c70fc509528aa9ef19f024d606cf8c507f8457f..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/unsupported_modifier_at_start_of_asm_output_constraint.zig
+++ /dev/null
@@ -1,10 +0,0 @@
-export fn foo() void {
-    var bar: u32 = 3;
-    asm volatile ("" : [baz]"+r"(bar) : : "");
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// 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
diff --git a/test/compile_errors/stage1/obj/unused_variable_error_on_errdefer.zig b/test/compile_errors/stage1/obj/unused_variable_error_on_errdefer.zig
deleted file mode 100644
index b85d5729dcf8f62c23cdee35a1a3fa873ff42768..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/unused_variable_error_on_errdefer.zig
+++ /dev/null
@@ -1,13 +0,0 @@
-fn foo() !void {
-    errdefer |a| unreachable;
-    return error.A;
-}
-export fn entry() void {
-    foo() catch unreachable;
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:2:15: error: unused variable: 'a'
diff --git a/test/compile_errors/stage1/obj/use_anyopaque_as_return_type_of_fn_ptr.zig b/test/compile_errors/stage1/obj/use_anyopaque_as_return_type_of_fn_ptr.zig
deleted file mode 100644
index ef2787ca75abc320a298bdabe29065ab350b2c48..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/use_anyopaque_as_return_type_of_fn_ptr.zig
+++ /dev/null
@@ -1,10 +0,0 @@
-export fn entry() void {
-    const a: fn () anyopaque = undefined;
-    _ = a;
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:2:20: error: return type cannot be opaque
diff --git a/test/compile_errors/stage1/obj/use_implicit_casts_to_assign_null_to_non-nullable_pointer.zig b/test/compile_errors/stage1/obj/use_implicit_casts_to_assign_null_to_non-nullable_pointer.zig
deleted file mode 100644
index 4263f38e3e8c56d9bc77513de039fef49060c39a..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/use_implicit_casts_to_assign_null_to_non-nullable_pointer.zig
+++ /dev/null
@@ -1,14 +0,0 @@
-export fn entry() void {
-    var x: i32 = 1234;
-    var p: *i32 = &x;
-    var pp: *?*i32 = &p;
-    pp.* = null;
-    var y = p.*;
-    _ = y;
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:4:23: error: expected type '*?*i32', found '**i32'
diff --git a/test/compile_errors/stage1/obj/use_invalid_number_literal_as_array_index.zig b/test/compile_errors/stage1/obj/use_invalid_number_literal_as_array_index.zig
deleted file mode 100644
index b1d0aaa6f47ec8ccdd11f73a53d58ae8c351386c..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/use_invalid_number_literal_as_array_index.zig
+++ /dev/null
@@ -1,11 +0,0 @@
-var v = 25;
-export fn entry() void {
-    var arr: [v]u8 = undefined;
-    _ = arr;
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:1:1: error: unable to infer variable type
diff --git a/test/compile_errors/stage1/obj/use_of_comptime-known_undefined_function_value.zig b/test/compile_errors/stage1/obj/use_of_comptime-known_undefined_function_value.zig
deleted file mode 100644
index 3500b13dfc21df3fa6fe0eab59da94cf47884da7..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/use_of_comptime-known_undefined_function_value.zig
+++ /dev/null
@@ -1,13 +0,0 @@
-const Cmd = struct {
-    exec: fn () void,
-};
-export fn entry() void {
-    const command = Cmd{ .exec = undefined };
-    command.exec();
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:6:12: error: use of undefined value here causes undefined behavior
diff --git a/test/compile_errors/stage1/obj/use_of_undeclared_identifier.zig b/test/compile_errors/stage1/obj/use_of_undeclared_identifier.zig
deleted file mode 100644
index c1297731a30de29d0538068a391507011a99c383..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/use_of_undeclared_identifier.zig
+++ /dev/null
@@ -1,9 +0,0 @@
-export fn f() void {
-    b = 3;
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:2:5: error: use of undeclared identifier 'b'
diff --git a/test/compile_errors/stage1/obj/using_an_unknown_len_ptr_type_instead_of_array.zig b/test/compile_errors/stage1/obj/using_an_unknown_len_ptr_type_instead_of_array.zig
deleted file mode 100644
index 3124b057a81d365e0bf47552bc15be21f8d14bf3..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/using_an_unknown_len_ptr_type_instead_of_array.zig
+++ /dev/null
@@ -1,13 +0,0 @@
-const resolutions = [*][*]const u8{
-    "[320 240  ]",
-    null,
-};
-comptime {
-    _ = resolutions;
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:1:21: error: expected array type or [_], found '[*][*]const u8'
diff --git a/test/compile_errors/stage1/obj/using_invalid_types_in_function_call_raises_an_error.zig b/test/compile_errors/stage1/obj/using_invalid_types_in_function_call_raises_an_error.zig
deleted file mode 100644
index f1fda15ea75a7395f3f9316fbf7ccda770c02fe8..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/using_invalid_types_in_function_call_raises_an_error.zig
+++ /dev/null
@@ -1,11 +0,0 @@
-const MenuEffect = enum {};
-fn func(effect: MenuEffect) void { _ = effect; }
-export fn entry() void {
-    func(MenuEffect.ThisDoesNotExist);
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:1:20: error: enum declarations must have at least one tag
diff --git a/test/compile_errors/stage1/obj/usingnamespace_with_wrong_type.zig b/test/compile_errors/stage1/obj/usingnamespace_with_wrong_type.zig
deleted file mode 100644
index 86b5f0dcfb3daa295b711d20871b595b68a75331..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/usingnamespace_with_wrong_type.zig
+++ /dev/null
@@ -1,7 +0,0 @@
-usingnamespace void;
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:1:1: error: expected struct, enum, or union; found 'void'
diff --git a/test/compile_errors/stage1/obj/variable_has_wrong_type.zig b/test/compile_errors/stage1/obj/variable_has_wrong_type.zig
deleted file mode 100644
index 52dcf150de0e57ad064cc6c702a9d06d221e06e7..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/variable_has_wrong_type.zig
+++ /dev/null
@@ -1,10 +0,0 @@
-export fn f() i32 {
-    const a = "a";
-    return a;
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:3:12: error: expected type 'i32', found '*const [1:0]u8'
diff --git a/test/compile_errors/stage1/obj/variable_in_inline_assembly_template_cannot_be_found.zig b/test/compile_errors/stage1/obj/variable_in_inline_assembly_template_cannot_be_found.zig
deleted file mode 100644
index 7636b501fd0237702050f200014cd065a85a602c..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/variable_in_inline_assembly_template_cannot_be_found.zig
+++ /dev/null
@@ -1,12 +0,0 @@
-export fn entry() void {
-    var sp = asm volatile ("mov %[foo], sp"
-        : [bar] "=r" (-> usize),
-    );
-    _ = sp;
-}
-
-// error
-// backend=stage1
-// target=x86_64-linux-gnu
-//
-// tmp.zig:2:14: error: could not find 'foo' in the inputs or outputs
diff --git a/test/compile_errors/stage1/obj/variable_initialization_compile_error_then_referenced.zig b/test/compile_errors/stage1/obj/variable_initialization_compile_error_then_referenced.zig
deleted file mode 100644
index 91b70481a1955cb6c9b77f59e502c1ca1ca7406c..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/variable_initialization_compile_error_then_referenced.zig
+++ /dev/null
@@ -1,19 +0,0 @@
-fn Undeclared() type {
-    return T;
-}
-fn Gen() type {
-    const X = Undeclared();
-    return struct {
-        x: X,
-    };
-}
-export fn entry() void {
-    const S = Gen();
-    _ = S;
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:2:12: error: use of undeclared identifier 'T'
diff --git a/test/compile_errors/stage1/obj/variable_with_type_noreturn.zig b/test/compile_errors/stage1/obj/variable_with_type_noreturn.zig
deleted file mode 100644
index e2ba9183be83259ca69bc9f3fe4309189c59ffbe..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/variable_with_type_noreturn.zig
+++ /dev/null
@@ -1,10 +0,0 @@
-export fn entry9() void {
-    var z: noreturn = return;
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:2:5: error: unreachable code
-// tmp.zig:2:23: note: control flow is diverted here
diff --git a/test/compile_errors/stage1/obj/vector_index_out_of_bounds.zig b/test/compile_errors/stage1/obj/vector_index_out_of_bounds.zig
deleted file mode 100644
index fdffd8b45567777d9dc61263f24a724d019a9431..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/vector_index_out_of_bounds.zig
+++ /dev/null
@@ -1,10 +0,0 @@
-export fn entry() void {
-    const x = @import("std").meta.Vector(3, f32){ 25, 75, 5, 0 };
-    _ = x;
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:2:62: error: index 3 outside vector of size 3
diff --git a/test/compile_errors/stage1/obj/volatile_on_global_assembly.zig b/test/compile_errors/stage1/obj/volatile_on_global_assembly.zig
deleted file mode 100644
index 2157fe6a71f5f1542665f595bd7ba9b17350d658..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/volatile_on_global_assembly.zig
+++ /dev/null
@@ -1,9 +0,0 @@
-comptime {
-    asm volatile ("");
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:2:9: error: volatile is meaningless on global assembly
diff --git a/test/compile_errors/stage1/obj/wasmMemoryGrow_is_a_compile_error_in_non-Wasm_targets.zig b/test/compile_errors/stage1/obj/wasmMemoryGrow_is_a_compile_error_in_non-Wasm_targets.zig
deleted file mode 100644
index 6eda076f1228d801fabb8332ebf29ab7aa206c68..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/wasmMemoryGrow_is_a_compile_error_in_non-Wasm_targets.zig
+++ /dev/null
@@ -1,10 +0,0 @@
-export fn foo() void {
-    _ = @wasmMemoryGrow(0, 1);
-    return;
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:2:9: error: @wasmMemoryGrow is a wasm32 feature only
diff --git a/test/compile_errors/stage1/obj/wasmMemorySize_is_a_compile_error_in_non-Wasm_targets.zig b/test/compile_errors/stage1/obj/wasmMemorySize_is_a_compile_error_in_non-Wasm_targets.zig
deleted file mode 100644
index 9bdf81073f755cf1f8365da1e3a08548104de45c..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/wasmMemorySize_is_a_compile_error_in_non-Wasm_targets.zig
+++ /dev/null
@@ -1,10 +0,0 @@
-export fn foo() void {
-    _ = @wasmMemorySize(0);
-    return;
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:2:9: error: @wasmMemorySize is a wasm32 feature only
diff --git a/test/compile_errors/stage1/obj/while_expected_bool_got_error_union.zig b/test/compile_errors/stage1/obj/while_expected_bool_got_error_union.zig
deleted file mode 100644
index 9fc327e6c9b24a4052063387e1406b6f38dc1b73..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/while_expected_bool_got_error_union.zig
+++ /dev/null
@@ -1,10 +0,0 @@
-export fn foo() void {
-    while (bar()) {}
-}
-fn bar() anyerror!i32 { return 1; }
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:2:15: error: expected type 'bool', found 'anyerror!i32'
diff --git a/test/compile_errors/stage1/obj/while_expected_bool_got_optional.zig b/test/compile_errors/stage1/obj/while_expected_bool_got_optional.zig
deleted file mode 100644
index 5948d627867a3b3f7dd97a58d2de58d1bbca4f91..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/while_expected_bool_got_optional.zig
+++ /dev/null
@@ -1,10 +0,0 @@
-export fn foo() void {
-    while (bar()) {}
-}
-fn bar() ?i32 { return 1; }
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:2:15: error: expected type 'bool', found '?i32'
diff --git a/test/compile_errors/stage1/obj/while_expected_error_union_got_bool.zig b/test/compile_errors/stage1/obj/while_expected_error_union_got_bool.zig
deleted file mode 100644
index b8a72e97937e454aa404e0c744fef8549d33d4ce..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/while_expected_error_union_got_bool.zig
+++ /dev/null
@@ -1,10 +0,0 @@
-export fn foo() void {
-    while (bar()) |x| {_ = x;} else |err| {_ = err;}
-}
-fn bar() bool { return true; }
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:2:15: error: expected error union type, found 'bool'
diff --git a/test/compile_errors/stage1/obj/while_expected_error_union_got_optional.zig b/test/compile_errors/stage1/obj/while_expected_error_union_got_optional.zig
deleted file mode 100644
index c933dc95092aa2bc4637f9dd9498cfe8771496a1..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/while_expected_error_union_got_optional.zig
+++ /dev/null
@@ -1,10 +0,0 @@
-export fn foo() void {
-    while (bar()) |x| {_ = x;} else |err| {_ = err;}
-}
-fn bar() ?i32 { return 1; }
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:2:15: error: expected error union type, found '?i32'
diff --git a/test/compile_errors/stage1/obj/while_expected_optional_got_bool.zig b/test/compile_errors/stage1/obj/while_expected_optional_got_bool.zig
deleted file mode 100644
index 0458d1ba0179951341bfbbf6e2d78df4ab315a02..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/while_expected_optional_got_bool.zig
+++ /dev/null
@@ -1,10 +0,0 @@
-export fn foo() void {
-    while (bar()) |x| {_ = x;}
-}
-fn bar() bool { return true; }
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:2:15: error: expected optional type, found 'bool'
diff --git a/test/compile_errors/stage1/obj/while_expected_optional_got_error_union.zig b/test/compile_errors/stage1/obj/while_expected_optional_got_error_union.zig
deleted file mode 100644
index 7cdbd2cccf69ad800659f21f13eabaa6177f6757..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/while_expected_optional_got_error_union.zig
+++ /dev/null
@@ -1,10 +0,0 @@
-export fn foo() void {
-    while (bar()) |x| {_ = x;}
-}
-fn bar() anyerror!i32 { return 1; }
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:2:15: error: expected optional type, found 'anyerror!i32'
diff --git a/test/compile_errors/stage1/obj/while_loop_body_expression_ignored.zig b/test/compile_errors/stage1/obj/while_loop_body_expression_ignored.zig
deleted file mode 100644
index 9542cbc62f00cb6e3473f6b546ac06c9ac82f0b4..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/while_loop_body_expression_ignored.zig
+++ /dev/null
@@ -1,22 +0,0 @@
-fn returns() usize {
-    return 2;
-}
-export fn f1() void {
-    while (true) returns();
-}
-export fn f2() void {
-    var x: ?i32 = null;
-    while (x) |_| returns();
-}
-export fn f3() void {
-    var x: anyerror!i32 = error.Bad;
-    while (x) |_| returns() else |_| unreachable;
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:5:25: error: expression value is ignored
-// tmp.zig:9:26: error: expression value is ignored
-// tmp.zig:13:26: error: expression value is ignored
diff --git a/test/compile_errors/stage1/obj/write_to_const_global_variable.zig b/test/compile_errors/stage1/obj/write_to_const_global_variable.zig
deleted file mode 100644
index 4ce93e6b519fe0f52971bb42b3bb44b8908daa9c..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/write_to_const_global_variable.zig
+++ /dev/null
@@ -1,11 +0,0 @@
-const x : i32 = 99;
-fn f() void {
-    x = 1;
-}
-export fn entry() void { f(); }
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:3:9: error: cannot assign to constant
diff --git a/test/compile_errors/stage1/obj/wrong_frame_type_used_for_async_call.zig b/test/compile_errors/stage1/obj/wrong_frame_type_used_for_async_call.zig
deleted file mode 100644
index c02c20f495d8760272493a144f2054264cf474f6..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/wrong_frame_type_used_for_async_call.zig
+++ /dev/null
@@ -1,16 +0,0 @@
-export fn entry() void {
-    var frame: @Frame(foo) = undefined;
-    frame = async bar();
-}
-fn foo() void {
-    suspend {}
-}
-fn bar() void {
-    suspend {}
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:3:13: error: expected type '*@Frame(bar)', found '*@Frame(foo)'
diff --git a/test/compile_errors/stage1/obj/wrong_function_type.zig b/test/compile_errors/stage1/obj/wrong_function_type.zig
deleted file mode 100644
index 58f4477601d3fe33c7d688e8597adff387a5641c..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/wrong_function_type.zig
+++ /dev/null
@@ -1,11 +0,0 @@
-const fns = [_]fn() void { a, b, c };
-fn a() i32 {return 0;}
-fn b() i32 {return 1;}
-fn c() i32 {return 2;}
-export fn entry() usize { return @sizeOf(@TypeOf(fns)); }
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:1:28: error: expected type 'fn() void', found 'fn() i32'
diff --git a/test/compile_errors/stage1/obj/wrong_initializer_for_union_payload_of_type_type.zig b/test/compile_errors/stage1/obj/wrong_initializer_for_union_payload_of_type_type.zig
deleted file mode 100644
index 2e7b8f2e40ac0f918a473303c60fd78a0778d7bd..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/wrong_initializer_for_union_payload_of_type_type.zig
+++ /dev/null
@@ -1,16 +0,0 @@
-const U = union(enum) {
-    A: type,
-};
-const S = struct {
-    u: U,
-};
-export fn entry() void {
-    comptime var v: S = undefined;
-    v.u.A = U{ .A = i32 };
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:9:8: error: use of undefined value here causes undefined behavior
diff --git a/test/compile_errors/stage1/obj/wrong_number_of_arguments.zig b/test/compile_errors/stage1/obj/wrong_number_of_arguments.zig
deleted file mode 100644
index f25c9dae083d800541c3dec579c466a504fd04cb..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/wrong_number_of_arguments.zig
+++ /dev/null
@@ -1,10 +0,0 @@
-export fn a() void {
-    c(1);
-}
-fn c(d: i32, e: i32, f: i32) void { _ = d; _ = e; _ = f; }
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:2:6: error: expected 3 argument(s), found 1
diff --git a/test/compile_errors/stage1/obj/wrong_number_of_arguments_for_method_fn_call.zig b/test/compile_errors/stage1/obj/wrong_number_of_arguments_for_method_fn_call.zig
deleted file mode 100644
index 7371223863c0f43a33a8bd1ae068053cbd691e32..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/wrong_number_of_arguments_for_method_fn_call.zig
+++ /dev/null
@@ -1,14 +0,0 @@
-const Foo = struct {
-    fn method(self: *const Foo, a: i32) void {_ = self; _ = a;}
-};
-fn f(foo: *const Foo) void {
-
-    foo.method(1, 2);
-}
-export fn entry() usize { return @sizeOf(@TypeOf(f)); }
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:6:15: error: expected 2 argument(s), found 3
diff --git a/test/compile_errors/stage1/obj/wrong_panic_signature_generic_function.zig b/test/compile_errors/stage1/obj/wrong_panic_signature_generic_function.zig
deleted file mode 100644
index 45de2fc6cbc56d23259efb73993207e1c44841a5..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/wrong_panic_signature_generic_function.zig
+++ /dev/null
@@ -1,12 +0,0 @@
-pub fn panic(comptime msg: []const u8, error_return_trace: ?*builtin.StackTrace) noreturn {
-    _ = msg; _ = error_return_trace;
-    while (true) {}
-}
-const builtin = @import("std").builtin;
-
-// error
-// backend=stage1
-// target=native
-//
-// error: expected type 'fn([]const u8, ?*std.builtin.StackTrace) noreturn', found 'fn([]const u8,anytype) anytype'
-// note: only one of the functions is generic
diff --git a/test/compile_errors/stage1/obj/wrong_panic_signature_runtime_function.zig b/test/compile_errors/stage1/obj/wrong_panic_signature_runtime_function.zig
deleted file mode 100644
index 5cf224c4a8d8fb8fcc1b380d8995b348d0efdfe4..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/wrong_panic_signature_runtime_function.zig
+++ /dev/null
@@ -1,10 +0,0 @@
-test "" {}
-
-pub fn panic() void {}
-
-
-// error
-// backend=stage1
-// target=native
-//
-// error: expected type 'fn([]const u8, ?*std.builtin.StackTrace) noreturn', found 'fn() void'
diff --git a/test/compile_errors/stage1/obj/wrong_pointer_coerced_to_pointer_to_opaque_{}.zig b/test/compile_errors/stage1/obj/wrong_pointer_coerced_to_pointer_to_opaque_{}.zig
deleted file mode 100644
index 3f6b0e750bd7ecfef3f70d548b102e06a431ef23..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/wrong_pointer_coerced_to_pointer_to_opaque_{}.zig
+++ /dev/null
@@ -1,12 +0,0 @@
-const Derp = opaque {};
-extern fn bar(d: *Derp) void;
-export fn foo() void {
-    var x = @as(u8, 1);
-    bar(@ptrCast(*anyopaque, &x));
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:5:9: error: expected type '*Derp', found '*anyopaque'
diff --git a/test/compile_errors/stage1/obj/wrong_return_type_for_main.zig b/test/compile_errors/stage1/obj/wrong_return_type_for_main.zig
deleted file mode 100644
index 218ef0b65d254c68884b6c9f8032874ccbddce9c..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/wrong_return_type_for_main.zig
+++ /dev/null
@@ -1,7 +0,0 @@
-pub fn main() f32 { }
-
-// error
-// backend=stage1
-// target=native
-//
-// error: expected return type of main to be 'void', '!void', 'noreturn', 'u8', or '!u8'
diff --git a/test/compile_errors/stage1/obj/wrong_size_to_an_array_literal.zig b/test/compile_errors/stage1/obj/wrong_size_to_an_array_literal.zig
deleted file mode 100644
index 909d89458728e960b4034e434ddf2844e8a3ca9a..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/wrong_size_to_an_array_literal.zig
+++ /dev/null
@@ -1,10 +0,0 @@
-comptime {
-    const array = [2]u8{1, 2, 3};
-    _ = array;
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:2:31: error: index 2 outside array of size 2
diff --git a/test/compile_errors/stage1/obj/wrong_type_for_argument_tuple_to_asyncCall.zig b/test/compile_errors/stage1/obj/wrong_type_for_argument_tuple_to_asyncCall.zig
deleted file mode 100644
index 7a9be0a8cc6e9123a0beb597d4be2683aa7546ff..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/wrong_type_for_argument_tuple_to_asyncCall.zig
+++ /dev/null
@@ -1,14 +0,0 @@
-export fn entry1() void {
-    var frame: @Frame(foo) = undefined;
-    @asyncCall(&frame, {}, foo, {});
-}
-
-fn foo() i32 {
-    return 0;
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:3:33: error: expected tuple or struct, found 'void'
diff --git a/test/compile_errors/stage1/obj/wrong_type_for_reify_type.zig b/test/compile_errors/stage1/obj/wrong_type_for_reify_type.zig
deleted file mode 100644
index b0c1d92659d8c73fa2656ad280b0c66829876d7d..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/wrong_type_for_reify_type.zig
+++ /dev/null
@@ -1,9 +0,0 @@
-export fn entry() void {
-    _ = @Type(0);
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:2:15: error: expected type 'std.builtin.Type', found 'comptime_int'
diff --git a/test/compile_errors/stage1/obj/wrong_type_for_result_ptr_to_asyncCall.zig b/test/compile_errors/stage1/obj/wrong_type_for_result_ptr_to_asyncCall.zig
deleted file mode 100644
index b4193d4de11d50385900de8afa2b18c4ee2d3f74..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/wrong_type_for_result_ptr_to_asyncCall.zig
+++ /dev/null
@@ -1,16 +0,0 @@
-export fn entry() void {
-    _ = async amain();
-}
-fn amain() i32 {
-    var frame: @Frame(foo) = undefined;
-    return await @asyncCall(&frame, false, foo, .{});
-}
-fn foo() i32 {
-    return 1234;
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:6:37: error: expected type '*i32', found 'bool'
diff --git a/test/compile_errors/stage1/obj/wrong_type_passed_to_panic.zig b/test/compile_errors/stage1/obj/wrong_type_passed_to_panic.zig
deleted file mode 100644
index ed237f81dfcee0c19e9ab3c0042323b3ae03bcae..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/wrong_type_passed_to_panic.zig
+++ /dev/null
@@ -1,10 +0,0 @@
-export fn entry() void {
-    var e = error.Foo;
-    @panic(e);
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:3:12: error: expected type '[]const u8', found 'error{Foo}'
diff --git a/test/compile_errors/stage1/obj/wrong_type_to_hasField.zig b/test/compile_errors/stage1/obj/wrong_type_to_hasField.zig
deleted file mode 100644
index 680c19a6fbaa10e038d56f89bd6b63efb8cbfd7a..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/wrong_type_to_hasField.zig
+++ /dev/null
@@ -1,9 +0,0 @@
-export fn entry() bool {
-    return @hasField(i32, "hi");
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:2:22: error: type 'i32' does not support @hasField
diff --git a/test/compile_errors/stage1/obj/wrong_types_given_to_atomic_order_args_in_cmpxchg.zig b/test/compile_errors/stage1/obj/wrong_types_given_to_atomic_order_args_in_cmpxchg.zig
deleted file mode 100644
index b0f484e2fd07868c7d4f11ffa5a1227e611bce46..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/wrong_types_given_to_atomic_order_args_in_cmpxchg.zig
+++ /dev/null
@@ -1,10 +0,0 @@
-export fn entry() void {
-    var x: i32 = 1234;
-    while (!@cmpxchgWeak(i32, &x, 1234, 5678, @as(u32, 1234), @as(u32, 1234))) {}
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:3:47: error: expected type 'std.builtin.AtomicOrder', found 'u32'
diff --git a/test/compile_errors/stage1/obj/wrong_types_given_to_export.zig b/test/compile_errors/stage1/obj/wrong_types_given_to_export.zig
deleted file mode 100644
index c06116204f00b04abc3b4b4da4dd941d130f48c4..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/obj/wrong_types_given_to_export.zig
+++ /dev/null
@@ -1,10 +0,0 @@
-fn entry() callconv(.C) void { }
-comptime {
-    @export(entry, .{.name = "entry", .linkage = @as(u32, 1234) });
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:3:59: error: expected type 'std.builtin.GlobalLinkage', found 'comptime_int'
diff --git a/test/compile_errors/stage1/test/access_invalid_typeInfo_decl.zig b/test/compile_errors/stage1/test/access_invalid_typeInfo_decl.zig
deleted file mode 100644
index 40e31a085505b75ca9b0842868bf5f8c2bdb5e85..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/test/access_invalid_typeInfo_decl.zig
+++ /dev/null
@@ -1,11 +0,0 @@
-const A = B;
-test "Crash" {
-    _ = @typeInfo(@This()).Struct.decls[0];
-}
-
-// error
-// backend=stage1
-// target=native
-// is_test=1
-//
-// tmp.zig:1:11: error: use of undeclared identifier 'B'
diff --git a/test/compile_errors/stage1/test/alignCast_of_zero_sized_types.zig b/test/compile_errors/stage1/test/alignCast_of_zero_sized_types.zig
deleted file mode 100644
index f83d22759cac095e9052141c74b10b7c11b49cef..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/test/alignCast_of_zero_sized_types.zig
+++ /dev/null
@@ -1,28 +0,0 @@
-export fn foo() void {
-    const a: *void = undefined;
-    _ = @alignCast(2, a);
-}
-export fn bar() void {
-    const a: ?*void = undefined;
-    _ = @alignCast(2, a);
-}
-export fn baz() void {
-    const a: []void = undefined;
-    _ = @alignCast(2, a);
-}
-export fn qux() void {
-    const a = struct {
-        fn a(comptime b: u32) void { _ = b; }
-    }.a;
-    _ = @alignCast(2, a);
-}
-
-// error
-// backend=stage1
-// target=native
-// is_test=1
-//
-// tmp.zig:3:23: error: cannot adjust alignment of zero sized type '*void'
-// tmp.zig:7:23: error: cannot adjust alignment of zero sized type '?*void'
-// tmp.zig:11:23: error: cannot adjust alignment of zero sized type '[]void'
-// tmp.zig:17:23: error: cannot adjust alignment of zero sized type 'fn(u32) anytype'
diff --git a/test/compile_errors/stage1/test/bad_splat_type.zig b/test/compile_errors/stage1/test/bad_splat_type.zig
deleted file mode 100644
index 94e3d052a6cd8b2de19c239b1aa3e9f65c6d1df2..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/test/bad_splat_type.zig
+++ /dev/null
@@ -1,12 +0,0 @@
-export fn entry() void {
-    const c = 4;
-    var v = @splat(4, c);
-    _ = v;
-}
-
-// error
-// backend=stage1
-// target=native
-// is_test=1
-//
-// tmp.zig:3:23: error: vector element type must be integer, float, bool, or pointer; 'comptime_int' is invalid
diff --git a/test/compile_errors/stage1/test/binary_OR_operator_on_error_sets.zig b/test/compile_errors/stage1/test/binary_OR_operator_on_error_sets.zig
deleted file mode 100644
index eb2d21c6eddcc44b2e9571dff3f19ec9cb9e67ff..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/test/binary_OR_operator_on_error_sets.zig
+++ /dev/null
@@ -1,13 +0,0 @@
-pub const A = error.A;
-pub const AB = A | error.B;
-export fn entry() void {
-    var x: AB = undefined;
-    _ = x;
-}
-
-// error
-// backend=stage1
-// target=native
-// is_test=1
-//
-// tmp.zig:2:18: error: invalid operands to binary expression: 'error{A}' and 'error{B}'
diff --git a/test/compile_errors/stage1/test/call_rejects_non_comptime-known_fn-always_inline.zig b/test/compile_errors/stage1/test/call_rejects_non_comptime-known_fn-always_inline.zig
deleted file mode 100644
index a010414a57ad349bf2b9065ddc4f08d29c6491fe..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/test/call_rejects_non_comptime-known_fn-always_inline.zig
+++ /dev/null
@@ -1,11 +0,0 @@
-pub export fn entry() void {
-    var call_me: fn () void = undefined;
-    @call(.{ .modifier = .always_inline }, call_me, .{});
-}
-
-// error
-// backend=stage1
-// target=native
-// is_test=1
-//
-// tmp.zig:3:5: error: the specified modifier requires a comptime-known function
diff --git a/test/compile_errors/stage1/test/call_rejects_non_comptime-known_fn-compile_time.zig b/test/compile_errors/stage1/test/call_rejects_non_comptime-known_fn-compile_time.zig
deleted file mode 100644
index b3ffcc6ec2bb77169efd68539817c9f80e7b6e11..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/test/call_rejects_non_comptime-known_fn-compile_time.zig
+++ /dev/null
@@ -1,11 +0,0 @@
-pub export fn entry() void {
-    var call_me: fn () void = undefined;
-    @call(.{ .modifier = .compile_time }, call_me, .{});
-}
-
-// error
-// backend=stage1
-// target=native
-// is_test=1
-//
-// tmp.zig:3:5: error: the specified modifier requires a comptime-known function
diff --git a/test/compile_errors/stage1/test/cast_between_optional_T_where_T_is_not_a_pointer.zig b/test/compile_errors/stage1/test/cast_between_optional_T_where_T_is_not_a_pointer.zig
deleted file mode 100644
index b8392ff5db5ce80306a649fd4486c2bfdde3e606..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/test/cast_between_optional_T_where_T_is_not_a_pointer.zig
+++ /dev/null
@@ -1,15 +0,0 @@
-pub const fnty1 = ?fn (i8) void;
-pub const fnty2 = ?fn (u64) void;
-export fn entry() void {
-    var a: fnty1 = undefined;
-    var b: fnty2 = undefined;
-    a = b;
-}
-
-// error
-// backend=stage1
-// target=native
-// is_test=1
-//
-// tmp.zig:6:9: error: expected type '?fn(i8) void', found '?fn(u64) void'
-// tmp.zig:6:9: note: optional type child 'fn(u64) void' cannot cast into optional type child 'fn(i8) void'
diff --git a/test/compile_errors/stage1/test/combination_of_nosuspend_and_async.zig b/test/compile_errors/stage1/test/combination_of_nosuspend_and_async.zig
deleted file mode 100644
index 43731c964861741e99c353de416ed6b7c4544d4f..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/test/combination_of_nosuspend_and_async.zig
+++ /dev/null
@@ -1,16 +0,0 @@
-export fn entry() void {
-    nosuspend {
-        const bar = async foo();
-        suspend {}
-        resume bar;
-    }
-}
-fn foo() void {}
-
-// error
-// backend=stage1
-// target=native
-// is_test=1
-//
-// tmp.zig:4:9: error: suspend inside nosuspend block
-// tmp.zig:2:5: note: nosuspend block here
diff --git a/test/compile_errors/stage1/test/comparison_of_non-tagged_union_and_enum_literal.zig b/test/compile_errors/stage1/test/comparison_of_non-tagged_union_and_enum_literal.zig
deleted file mode 100644
index 4898ac744ca97c646e04cb59ea1c9fce85ada31b..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/test/comparison_of_non-tagged_union_and_enum_literal.zig
+++ /dev/null
@@ -1,14 +0,0 @@
-export fn entry() void {
-    const U = union { A: u32, B: u64 };
-    var u = U{ .A = 42 };
-    var ok = u == .A;
-    _ = ok;
-}
-
-// error
-// backend=stage1
-// target=native
-// is_test=1
-//
-// 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
diff --git a/test/compile_errors/stage1/test/comptime_vector_overflow_shows_the_index.zig b/test/compile_errors/stage1/test/comptime_vector_overflow_shows_the_index.zig
deleted file mode 100644
index a1f026ab70ca4ea344aa7ea8a213e83fde32ca74..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/test/comptime_vector_overflow_shows_the_index.zig
+++ /dev/null
@@ -1,14 +0,0 @@
-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;
-}
-
-// error
-// backend=stage1
-// target=native
-// is_test=1
-//
-// tmp.zig:4:15: error: operation caused overflow
-// tmp.zig:4:15: note: when computing vector element at index 2
diff --git a/test/compile_errors/stage1/test/duplicate_field_in_anonymous_struct_literal.zig b/test/compile_errors/stage1/test/duplicate_field_in_anonymous_struct_literal.zig
deleted file mode 100644
index 7b6821d6691b97ce557be4041f0ce1de220c2453..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/test/duplicate_field_in_anonymous_struct_literal.zig
+++ /dev/null
@@ -1,19 +0,0 @@
-export fn entry() void {
-    const anon = .{
-        .inner = .{
-            .a = .{
-                .something = "text",
-            },
-            .a = .{},
-        },
-    };
-    _ = anon;
-}
-
-// error
-// backend=stage1
-// target=native
-// is_test=1
-//
-// tmp.zig:7:13: error: duplicate field
-// tmp.zig:4:13: note: other field here
diff --git a/test/compile_errors/stage1/test/error_in_struct_initializer_doesnt_crash_the_compiler.zig b/test/compile_errors/stage1/test/error_in_struct_initializer_doesnt_crash_the_compiler.zig
deleted file mode 100644
index 2858fd6a0115c33210172a4e34d6bf0548260e39..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/test/error_in_struct_initializer_doesnt_crash_the_compiler.zig
+++ /dev/null
@@ -1,15 +0,0 @@
-pub export fn entry() void {
-    const bitfield = struct {
-        e: u8,
-        e: u8,
-    };
-    var a = .{@sizeOf(bitfield)};
-    _ = a;
-}
-
-// error
-// backend=stage1
-// target=native
-// is_test=1
-//
-// tmp.zig:4:9: error: duplicate struct field: 'e'
diff --git a/test/compile_errors/stage1/test/errors_in_for_loop_bodies_are_propagated.zig b/test/compile_errors/stage1/test/errors_in_for_loop_bodies_are_propagated.zig
deleted file mode 100644
index d8be29e39b453032ffd09d38c2452bd88b13eaac..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/test/errors_in_for_loop_bodies_are_propagated.zig
+++ /dev/null
@@ -1,11 +0,0 @@
-pub export fn entry() void {
-    var arr: [100]u8 = undefined;
-    for (arr) |bits| _ = @popCount(bits);
-}
-
-// error
-// backend=stage1
-// target=native
-// is_test=1
-//
-// tmp.zig:3:26: error: expected 2 arguments, found 1
diff --git a/test/compile_errors/stage1/test/export_with_empty_name_string.zig b/test/compile_errors/stage1/test/export_with_empty_name_string.zig
deleted file mode 100644
index b882d11723afefc50ae5d605b36e200276b82525..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/test/export_with_empty_name_string.zig
+++ /dev/null
@@ -1,11 +0,0 @@
-pub export fn entry() void { }
-comptime {
-    @export(entry, .{ .name = "" });
-}
-
-// error
-// backend=stage1
-// target=native
-// is_test=1
-//
-// tmp.zig:3:5: error: exported symbol name cannot be empty
diff --git a/test/compile_errors/stage1/test/helpful_return_type_error_message.zig b/test/compile_errors/stage1/test/helpful_return_type_error_message.zig
deleted file mode 100644
index 0e97c09de210885dac3f8b91ba4897b817007fbc..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/test/helpful_return_type_error_message.zig
+++ /dev/null
@@ -1,30 +0,0 @@
-export fn foo() u32 {
-    return error.Ohno;
-}
-fn bar() !u32 {
-    return error.Ohno;
-}
-export fn baz() void {
-    try bar();
-}
-export fn qux() u32 {
-    return bar();
-}
-export fn quux() u32 {
-    var buf: u32 = 0;
-    buf = bar();
-}
-
-// error
-// backend=stage1
-// target=native
-// is_test=1
-//
-// tmp.zig:2:17: error: expected type 'u32', found 'error{Ohno}'
-// tmp.zig:1:17: note: function cannot return an error
-// tmp.zig:8:5: error: expected type 'void', found '@typeInfo(@typeInfo(@TypeOf(bar)).Fn.return_type.?).ErrorUnion.error_set'
-// tmp.zig:7:17: note: function cannot return an error
-// tmp.zig:11:15: error: cannot convert error union to payload type. consider using `try`, `catch`, or `if`. expected type 'u32', found '@typeInfo(@typeInfo(@TypeOf(bar)).Fn.return_type.?).ErrorUnion.error_set!u32'
-// tmp.zig:10:17: note: function cannot return an error
-// tmp.zig:15:14: error: cannot convert error union to payload type. consider using `try`, `catch`, or `if`. expected type 'u32', found '@typeInfo(@typeInfo(@TypeOf(bar)).Fn.return_type.?).ErrorUnion.error_set!u32'
-// tmp.zig:14:5: note: cannot store an error in type 'u32'
diff --git a/test/compile_errors/stage1/test/int-float_conversion_to_comptime_int-float.zig b/test/compile_errors/stage1/test/int-float_conversion_to_comptime_int-float.zig
deleted file mode 100644
index de439168ae36788f367d1ceeb70d3cad065c4f19..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/test/int-float_conversion_to_comptime_int-float.zig
+++ /dev/null
@@ -1,16 +0,0 @@
-export fn foo() void {
-    var a: f32 = 2;
-    _ = @floatToInt(comptime_int, a);
-}
-export fn bar() void {
-    var a: u32 = 2;
-    _ = @intToFloat(comptime_float, a);
-}
-
-// error
-// backend=stage1
-// target=native
-// is_test=1
-//
-// tmp.zig:3:35: error: unable to evaluate constant expression
-// tmp.zig:7:37: error: unable to evaluate constant expression
diff --git a/test/compile_errors/stage1/test/invalid_assignments.zig b/test/compile_errors/stage1/test/invalid_assignments.zig
deleted file mode 100644
index 75f45a8bcb94e526334a65f466beb80ceb625a07..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/test/invalid_assignments.zig
+++ /dev/null
@@ -1,20 +0,0 @@
-export fn entry1() void {
-    var a: []const u8 = "foo";
-    a[0..2] = "bar";
-}
-export fn entry2() void {
-    var a: u8 = 2;
-    a + 2 = 3;
-}
-export fn entry4() void {
-    2 + 2 = 3;
-}
-
-// error
-// backend=stage1
-// target=native
-// is_test=1
-//
-// tmp.zig:3:6: error: invalid left-hand side to assignment
-// tmp.zig:7:7: error: invalid left-hand side to assignment
-// tmp.zig:10:7: error: invalid left-hand side to assignment
diff --git a/test/compile_errors/stage1/test/invalid_float_casts.zig b/test/compile_errors/stage1/test/invalid_float_casts.zig
deleted file mode 100644
index 2fe8003728e0e74131f66725c2b596f5f0151d50..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/test/invalid_float_casts.zig
+++ /dev/null
@@ -1,26 +0,0 @@
-export fn foo() void {
-    var a: f32 = 2;
-    _ = @floatCast(comptime_float, a);
-}
-export fn bar() void {
-    var a: f32 = 2;
-    _ = @floatToInt(f32, a);
-}
-export fn baz() void {
-    var a: f32 = 2;
-    _ = @intToFloat(f32, a);
-}
-export fn qux() void {
-    var a: u32 = 2;
-    _ = @floatCast(f32, a);
-}
-
-// error
-// backend=stage1
-// target=native
-// is_test=1
-//
-// tmp.zig:3:36: error: unable to evaluate constant expression
-// tmp.zig:7:21: error: expected integer type, found 'f32'
-// tmp.zig:11:26: error: expected int type, found 'f32'
-// tmp.zig:15:25: error: expected float type, found 'u32'
diff --git a/test/compile_errors/stage1/test/invalid_int_casts.zig b/test/compile_errors/stage1/test/invalid_int_casts.zig
deleted file mode 100644
index 9945751ef5765baab60e2afe8f47ee2c5725f643..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/test/invalid_int_casts.zig
+++ /dev/null
@@ -1,26 +0,0 @@
-export fn foo() void {
-    var a: u32 = 2;
-    _ = @intCast(comptime_int, a);
-}
-export fn bar() void {
-    var a: u32 = 2;
-    _ = @intToFloat(u32, a);
-}
-export fn baz() void {
-    var a: u32 = 2;
-    _ = @floatToInt(u32, a);
-}
-export fn qux() void {
-    var a: f32 = 2;
-    _ = @intCast(u32, a);
-}
-
-// error
-// backend=stage1
-// target=native
-// is_test=1
-//
-// tmp.zig:3:32: error: unable to evaluate constant expression
-// tmp.zig:7:21: error: expected float type, found 'u32'
-// tmp.zig:11:26: error: expected float type, found 'u32'
-// tmp.zig:15:23: error: expected integer type, found 'f32'
diff --git a/test/compile_errors/stage1/test/invalid_non-exhaustive_enum_to_union.zig b/test/compile_errors/stage1/test/invalid_non-exhaustive_enum_to_union.zig
deleted file mode 100644
index 804e83a66aab2642a9191c21c7bdf52f3a64ed88..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/test/invalid_non-exhaustive_enum_to_union.zig
+++ /dev/null
@@ -1,27 +0,0 @@
-const E = enum(u8) {
-    a,
-    b,
-    _,
-};
-const U = union(E) {
-    a,
-    b,
-};
-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;
-}
-
-// error
-// backend=stage1
-// target=native
-// is_test=1
-//
-// tmp.zig:12:16: error: runtime cast to union 'U' from non-exhaustive enum
-// tmp.zig:17:16: error: no tag by value 15
diff --git a/test/compile_errors/stage1/test/invalid_pointer_with_reify_type.zig b/test/compile_errors/stage1/test/invalid_pointer_with_reify_type.zig
deleted file mode 100644
index bf1cf6bd6f97e716677cf542bcfec45d166ab042..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/test/invalid_pointer_with_reify_type.zig
+++ /dev/null
@@ -1,19 +0,0 @@
-export fn entry() void {
-    _ = @Type(.{ .Pointer = .{
-        .size = .One,
-        .is_const = false,
-        .is_volatile = false,
-        .alignment = 1,
-        .address_space = .generic,
-        .child = u8,
-        .is_allowzero = false,
-        .sentinel = &@as(u8, 0),
-    }});
-}
-
-// error
-// backend=stage1
-// target=native
-// is_test=1
-//
-// tmp.zig:2:16: error: sentinels are only allowed on slices and unknown-length pointers
diff --git a/test/compile_errors/stage1/test/nested_vectors.zig b/test/compile_errors/stage1/test/nested_vectors.zig
deleted file mode 100644
index 9e87ac814b2f21d33add49e6e89405837f17c8c2..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/test/nested_vectors.zig
+++ /dev/null
@@ -1,13 +0,0 @@
-export fn entry() void {
-    const V1 = @import("std").meta.Vector(4, u8);
-    const V2 = @Type(.{ .Vector = .{ .len = 4, .child = V1 } });
-    var v: V2 = undefined;
-    _ = v;
-}
-
-// error
-// backend=stage1
-// target=native
-// is_test=1
-//
-// tmp.zig:3:23: error: vector element type must be integer, float, bool, or pointer; '@Vector(4, u8)' is invalid
diff --git a/test/compile_errors/stage1/test/non-exhaustive_enum_marker_assigned_a_value.zig b/test/compile_errors/stage1/test/non-exhaustive_enum_marker_assigned_a_value.zig
deleted file mode 100644
index 609af248dfcc2e7ead10dc39ecd4a865202bfc0b..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/test/non-exhaustive_enum_marker_assigned_a_value.zig
+++ /dev/null
@@ -1,20 +0,0 @@
-const A = enum {
-    a,
-    b,
-    _ = 1,
-};
-const B = enum {
-    a,
-    b,
-    _,
-};
-comptime { _ = A; _ = B; }
-
-// error
-// backend=stage1
-// target=native
-// is_test=1
-//
-// 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
diff --git a/test/compile_errors/stage1/test/non-exhaustive_enums.zig b/test/compile_errors/stage1/test/non-exhaustive_enums.zig
deleted file mode 100644
index 3b5f8af7cbb7f51d9a6e78a2bd59e683f5622851..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/test/non-exhaustive_enums.zig
+++ /dev/null
@@ -1,22 +0,0 @@
-const B = enum(u1) {
-    a,
-    _,
-    b,
-};
-const C = enum(u1) {
-    a,
-    b,
-    _,
-};
-pub export fn entry() void {
-    _ = B;
-    _ = C;
-}
-
-// error
-// backend=stage1
-// target=native
-// is_test=1
-//
-// tmp.zig:3:5: error: '_' field of non-exhaustive enum must be last
-// tmp.zig:6:11: error: non-exhaustive enum specifies every value
diff --git a/test/compile_errors/stage1/test/not_an_enum_type.zig b/test/compile_errors/stage1/test/not_an_enum_type.zig
deleted file mode 100644
index 99c733b4d02a10727e88195105bc7e631f34d0c8..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/test/not_an_enum_type.zig
+++ /dev/null
@@ -1,20 +0,0 @@
-export fn entry() void {
-    var self: Error = undefined;
-    switch (self) {
-        InvalidToken => |x| return x.token,
-        ExpectedVarDeclOrFn => |x| return x.token,
-    }
-}
-const Error = union(enum) {
-    A: InvalidToken,
-    B: ExpectedVarDeclOrFn,
-};
-const InvalidToken = struct {};
-const ExpectedVarDeclOrFn = struct {};
-
-// error
-// backend=stage1
-// target=native
-// is_test=1
-//
-// tmp.zig:4:9: error: expected type '@typeInfo(Error).Union.tag_type.?', found 'type'
diff --git a/test/compile_errors/stage1/test/packed_struct_with_fields_of_not_allowed_types.zig b/test/compile_errors/stage1/test/packed_struct_with_fields_of_not_allowed_types.zig
deleted file mode 100644
index 2951d26c52b434368eac60f6111c8df95a13ff6f..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/test/packed_struct_with_fields_of_not_allowed_types.zig
+++ /dev/null
@@ -1,74 +0,0 @@
-const A = packed struct {
-    x: anyerror,
-};
-const B = packed struct {
-    x: [2]u24,
-};
-const C = packed struct {
-    x: [1]anyerror,
-};
-const D = packed struct {
-    x: [1]S,
-};
-const E = packed struct {
-    x: [1]U,
-};
-const F = packed struct {
-    x: ?anyerror,
-};
-const G = packed struct {
-    x: Enum,
-};
-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,
-};
-const U = struct {
-    A: i32,
-    B: u32,
-};
-const Enum = enum {
-    A,
-    B,
-};
-
-// error
-// backend=stage1
-// target=native
-// is_test=1
-//
-// tmp.zig:2:5: error: type 'anyerror' not allowed in packed struct; no guaranteed in-memory representation
-// tmp.zig:5:5: error: array of 'u24' not allowed in packed struct due to padding bits (must be padded from 48 to 64 bits)
-// tmp.zig:8:5: error: type 'anyerror' not allowed in packed struct; no guaranteed in-memory representation
-// tmp.zig:11:5: error: non-packed, non-extern struct 'S' not allowed in packed struct; no guaranteed in-memory representation
-// 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:57:14: note: enum declaration does not specify an integer tag type
diff --git a/test/compile_errors/stage1/test/ptrToInt_with_pointer_to_zero-sized_type.zig b/test/compile_errors/stage1/test/ptrToInt_with_pointer_to_zero-sized_type.zig
deleted file mode 100644
index 7c2ba184c4246887e970e69e17f2b7d92b9b5190..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/test/ptrToInt_with_pointer_to_zero-sized_type.zig
+++ /dev/null
@@ -1,12 +0,0 @@
-export fn entry() void {
-    var pointer: ?*u0 = null;
-    var x = @ptrToInt(pointer);
-    _ = x;
-}
-
-// error
-// backend=stage1
-// target=native
-// is_test=1
-//
-// tmp.zig:3:23: error: pointer to size 0 type has no address
diff --git a/test/compile_errors/stage1/test/reassign_to_array_parameter.zig b/test/compile_errors/stage1/test/reassign_to_array_parameter.zig
deleted file mode 100644
index f3b51d2c0fd742aae14e5287a013144e04e0bfcd..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/test/reassign_to_array_parameter.zig
+++ /dev/null
@@ -1,13 +0,0 @@
-fn reassign(a: [3]f32) void {
-    a = [3]f32{4, 5, 6};
-}
-export fn entry() void {
-    reassign(.{1, 2, 3});
-}
-
-// error
-// backend=stage1
-// target=native
-// is_test=1
-//
-// tmp.zig:2:15: error: cannot assign to constant
diff --git a/test/compile_errors/stage1/test/reassign_to_slice_parameter.zig b/test/compile_errors/stage1/test/reassign_to_slice_parameter.zig
deleted file mode 100644
index 34bd5541a15e391ecd3bd9a7c93cf874e15200fb..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/test/reassign_to_slice_parameter.zig
+++ /dev/null
@@ -1,13 +0,0 @@
-pub fn reassign(s: []const u8) void {
-    s = s[0..];
-}
-export fn entry() void {
-    reassign("foo");
-}
-
-// error
-// backend=stage1
-// target=native
-// is_test=1
-//
-// tmp.zig:2:10: error: cannot assign to constant
diff --git a/test/compile_errors/stage1/test/reassign_to_struct_parameter.zig b/test/compile_errors/stage1/test/reassign_to_struct_parameter.zig
deleted file mode 100644
index 994833d989bfe0687d02feebbb3770427ee7c6ca..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/test/reassign_to_struct_parameter.zig
+++ /dev/null
@@ -1,16 +0,0 @@
-const S = struct {
-    x: u32,
-};
-fn reassign(s: S) void {
-    s = S{.x = 2};
-}
-export fn entry() void {
-    reassign(S{.x = 3});
-}
-
-// error
-// backend=stage1
-// target=native
-// is_test=1
-//
-// tmp.zig:5:10: error: cannot assign to constant
diff --git a/test/compile_errors/stage1/test/reference_to_const_data.zig b/test/compile_errors/stage1/test/reference_to_const_data.zig
deleted file mode 100644
index 6c98aefd7abd452725c2bdbaedbc52199ee5ba33..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/test/reference_to_const_data.zig
+++ /dev/null
@@ -1,30 +0,0 @@
-export fn foo() void {
-    var ptr = &[_]u8{0,0,0,0};
-    ptr[1] = 2;
-}
-export fn bar() void {
-    var ptr = &@as(u32, 2);
-    ptr.* = 2;
-}
-export fn baz() void {
-    var ptr = &true;
-    ptr.* = false;
-}
-export fn qux() void {
-    const S = struct{
-        x: usize,
-        y: usize,
-    };
-    var ptr = &S{.x=1,.y=2};
-    ptr.x = 2;
-}
-
-// error
-// backend=stage1
-// target=native
-// is_test=1
-//
-// tmp.zig:3:14: error: cannot assign to constant
-// tmp.zig:7:13: error: cannot assign to constant
-// tmp.zig:11:13: error: cannot assign to constant
-// tmp.zig:19:13: error: cannot assign to constant
diff --git a/test/compile_errors/stage1/test/reify_typeOf_with_incompatible_arguments.zig b/test/compile_errors/stage1/test/reify_typeOf_with_incompatible_arguments.zig
deleted file mode 100644
index 2013a07e536d199827132902c0c5c24adc6f7f91..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/test/reify_typeOf_with_incompatible_arguments.zig
+++ /dev/null
@@ -1,12 +0,0 @@
-export fn entry() void {
-    var var_1: f32 = undefined;
-    var var_2: u32 = undefined;
-    _ = @TypeOf(var_1, var_2);
-}
-
-// error
-// backend=stage1
-// target=native
-// is_test=1
-//
-// tmp.zig:4:9: error: incompatible types: 'f32' and 'u32'
diff --git a/test/compile_errors/stage1/test/reify_typeOf_with_no_arguments.zig b/test/compile_errors/stage1/test/reify_typeOf_with_no_arguments.zig
deleted file mode 100644
index 0626d453936f615271824bcdc93d5c6b405b37e2..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/test/reify_typeOf_with_no_arguments.zig
+++ /dev/null
@@ -1,10 +0,0 @@
-export fn entry() void {
-    _ = @TypeOf();
-}
-
-// error
-// backend=stage1
-// target=native
-// is_test=1
-//
-// tmp.zig:2:9: error: expected at least 1 argument, found 0
diff --git a/test/compile_errors/stage1/test/reject_extern_function_definitions_with_body.zig b/test/compile_errors/stage1/test/reject_extern_function_definitions_with_body.zig
deleted file mode 100644
index a7b92e8399e3992b08b4c8ffcc887286bf0f560e..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/test/reject_extern_function_definitions_with_body.zig
+++ /dev/null
@@ -1,10 +0,0 @@
-extern "c" fn definitelyNotInLibC(a: i32, b: i32) i32 {
-    return a + b;
-}
-
-// error
-// backend=stage1
-// target=native
-// is_test=1
-//
-// tmp.zig:1:1: error: extern functions have no body
diff --git a/test/compile_errors/stage1/test/reject_extern_variables_with_initializers.zig b/test/compile_errors/stage1/test/reject_extern_variables_with_initializers.zig
deleted file mode 100644
index 54239e0948e93fafaa3555ebe7c10c8c09a0ab07..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/test/reject_extern_variables_with_initializers.zig
+++ /dev/null
@@ -1,8 +0,0 @@
-extern var foo: int = 2;
-
-// error
-// backend=stage1
-// target=native
-// is_test=1
-//
-// tmp.zig:1:23: error: extern variables have no initializers
diff --git a/test/compile_errors/stage1/test/repeated_invalid_field_access_to_generic_function_returning_type_crashes_compiler_2655.zig b/test/compile_errors/stage1/test/repeated_invalid_field_access_to_generic_function_returning_type_crashes_compiler_2655.zig
deleted file mode 100644
index 7499939b4a1bbd979861be1dcd8fc3fd17e5207f..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/test/repeated_invalid_field_access_to_generic_function_returning_type_crashes_compiler_2655.zig
+++ /dev/null
@@ -1,14 +0,0 @@
-pub fn A() type {
-    return Q;
-}
-test "1" {
-    _ = A().a;
-    _ = A().a;
-}
-
-// error
-// backend=stage1
-// target=native
-// is_test=1
-//
-// tmp.zig:2:12: error: use of undeclared identifier 'Q'
diff --git a/test/compile_errors/stage1/test/return_invalid_type_from_test.zig b/test/compile_errors/stage1/test/return_invalid_type_from_test.zig
deleted file mode 100644
index 590ac3091860b3177105ede28ff9f39e20631a36..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/test/return_invalid_type_from_test.zig
+++ /dev/null
@@ -1,8 +0,0 @@
-test "example" { return 1; }
-
-// error
-// backend=stage1
-// target=native
-// is_test=1
-//
-// tmp.zig:1:25: error: expected type 'void', found 'comptime_int'
diff --git a/test/compile_errors/stage1/test/shift_on_type_with_non-power-of-two_size.zig b/test/compile_errors/stage1/test/shift_on_type_with_non-power-of-two_size.zig
deleted file mode 100644
index 222cb2256308bec4cca5475a28ffdf7eadf1520a..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/test/shift_on_type_with_non-power-of-two_size.zig
+++ /dev/null
@@ -1,34 +0,0 @@
-export fn entry() void {
-    const S = struct {
-        fn a() void {
-            var x: u24 = 42;
-            _ = x >> 24;
-        }
-        fn b() void {
-            var x: u24 = 42;
-            _ = x << 24;
-        }
-        fn c() void {
-            var x: u24 = 42;
-            _ = @shlExact(x, 24);
-        }
-        fn d() void {
-            var x: u24 = 42;
-            _ = @shrExact(x, 24);
-        }
-    };
-    S.a();
-    S.b();
-    S.c();
-    S.d();
-}
-
-// error
-// backend=stage1
-// target=native
-// is_test=1
-//
-// tmp.zig:5:19: error: RHS of shift is too large for LHS type
-// tmp.zig:9:19: error: RHS of shift is too large for LHS type
-// tmp.zig:13:17: error: RHS of shift is too large for LHS type
-// tmp.zig:17:17: error: RHS of shift is too large for LHS type
diff --git a/test/compile_errors/stage1/test/shuffle_with_selected_index_past_first_vector_length.zig b/test/compile_errors/stage1/test/shuffle_with_selected_index_past_first_vector_length.zig
deleted file mode 100644
index 8b0c5ba780b12c79cdffca4edc911835bcd3a48f..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/test/shuffle_with_selected_index_past_first_vector_length.zig
+++ /dev/null
@@ -1,15 +0,0 @@
-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;
-}
-
-// error
-// backend=stage1
-// target=native
-// is_test=1
-//
-// tmp.zig:4:39: error: mask index '4' has out-of-bounds selection
-// tmp.zig:4:27: note: selected index '7' out of bounds of @Vector(4, u32)
-// tmp.zig:4:30: note: selections from the second vector are specified with negative numbers
diff --git a/test/compile_errors/stage1/test/switch_ranges_endpoints_are_validated.zig b/test/compile_errors/stage1/test/switch_ranges_endpoints_are_validated.zig
deleted file mode 100644
index a44d59feedfdadc80c4f2a4b7335ce9d02400f64..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/test/switch_ranges_endpoints_are_validated.zig
+++ /dev/null
@@ -1,16 +0,0 @@
-pub export fn entry() void {
-    var x: i32 = 0;
-    switch (x) {
-        6...1 => {},
-        -1...-5 => {},
-        else => unreachable,
-    }
-}
-
-// error
-// backend=stage1
-// target=native
-// is_test=1
-//
-// tmp.zig:4:9: error: range start value is greater than the end value
-// tmp.zig:5:9: error: range start value is greater than the end value
diff --git a/test/compile_errors/stage1/test/switching_with_exhaustive_enum_has___prong_.zig b/test/compile_errors/stage1/test/switching_with_exhaustive_enum_has___prong_.zig
deleted file mode 100644
index 0ca489bdb82f78134b0e18ecb3e0fa6f319033b5..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/test/switching_with_exhaustive_enum_has___prong_.zig
+++ /dev/null
@@ -1,19 +0,0 @@
-const E = enum{
-    a,
-    b,
-};
-pub export fn entry() void {
-    var e: E = .b;
-    switch (e) {
-        .a => {},
-        .b => {},
-        _ => {},
-    }
-}
-
-// error
-// backend=stage1
-// target=native
-// is_test=1
-//
-// tmp.zig:7:5: error: switch on exhaustive enum has `_` prong
diff --git a/test/compile_errors/stage1/test/switching_with_non-exhaustive_enums.zig b/test/compile_errors/stage1/test/switching_with_non-exhaustive_enums.zig
deleted file mode 100644
index ed46c5f2f14337e7d1e87ed2ca90861bf20bae00..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/test/switching_with_non-exhaustive_enums.zig
+++ /dev/null
@@ -1,35 +0,0 @@
-const E = enum(u8) {
-    a,
-    b,
-    _,
-};
-const U = union(E) {
-    a: i32,
-    b: u32,
-};
-pub export fn entry() void {
-    var e: E = .b;
-    switch (e) { // error: switch not handling the tag `b`
-        .a => {},
-        _ => {},
-    }
-    switch (e) { // error: switch on non-exhaustive enum must include `else` or `_` prong
-        .a => {},
-        .b => {},
-    }
-    var u = U{.a = 2};
-    switch (u) { // error: `_` prong not allowed when switching on tagged union
-        .a => {},
-        .b => {},
-        _ => {},
-    }
-}
-
-// error
-// backend=stage1
-// target=native
-// is_test=1
-//
-// tmp.zig:12:5: error: enumeration value 'E.b' not handled in switch
-// tmp.zig:16:5: error: switch on non-exhaustive enum must include `else` or `_` prong
-// tmp.zig:21:5: error: `_` prong not allowed when switching on tagged union
diff --git a/test/compile_errors/stage1/test/tagName_on_invalid_value_of_non-exhaustive_enum.zig b/test/compile_errors/stage1/test/tagName_on_invalid_value_of_non-exhaustive_enum.zig
deleted file mode 100644
index a98470b681adf87d7f725d128ef3a88d5948d89a..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/test/tagName_on_invalid_value_of_non-exhaustive_enum.zig
+++ /dev/null
@@ -1,11 +0,0 @@
-test "enum" {
-    const E = enum(u8) {A, B, _};
-    _ = @tagName(@intToEnum(E, 5));
-}
-
-// error
-// backend=stage1
-// target=native
-// is_test=1
-//
-// tmp.zig:3:18: error: no tag by value 5
diff --git a/test/compile_errors/stage1/test/type_mismatch_in_C_prototype_with_varargs.zig b/test/compile_errors/stage1/test/type_mismatch_in_C_prototype_with_varargs.zig
deleted file mode 100644
index 1f78ef3999716b4f6ed7d4086cebc466a64902ec..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/test/type_mismatch_in_C_prototype_with_varargs.zig
+++ /dev/null
@@ -1,14 +0,0 @@
-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;
-}
-
-// error
-// backend=stage1
-// target=native
-// is_test=1
-//
-// tmp.zig:5:22: error: expected type 'fn([*c]u8, ...) callconv(.C) void', found 'fn([*:0]u8, ...) callconv(.C) void'
diff --git a/test/compile_errors/stage1/test/type_mismatch_with_tuple_concatenation.zig b/test/compile_errors/stage1/test/type_mismatch_with_tuple_concatenation.zig
deleted file mode 100644
index 5983224676fd805903614b5e78e0252175ff7382..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage1/test/type_mismatch_with_tuple_concatenation.zig
+++ /dev/null
@@ -1,11 +0,0 @@
-export fn entry() void {
-    var x = .{};
-    x = x ++ .{ 1, 2, 3 };
-}
-
-// error
-// backend=stage1
-// target=native
-// is_test=1
-//
-// tmp.zig:3:11: error: expected type 'struct:2:14', found 'struct:3:11'
diff --git a/test/compile_errors/stage2/comptime_unreachable.zig b/test/compile_errors/stage2/comptime_unreachable.zig
deleted file mode 100644
index 6086dd85c6033d35f73e8d9d8e26c0a70844f82c..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage2/comptime_unreachable.zig
+++ /dev/null
@@ -1,7 +0,0 @@
-pub export fn entry() void {
-    comptime unreachable;
-}
-
-// error
-//
-// :2:14: error: reached unreachable code
diff --git a/test/compile_errors/stage2/constant_inside_comptime_function_has_compile_error.zig b/test/compile_errors/stage2/constant_inside_comptime_function_has_compile_error.zig
deleted file mode 100644
index 2b67390b05b2ec7e22608045d5e658810a4b596d..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage2/constant_inside_comptime_function_has_compile_error.zig
+++ /dev/null
@@ -1,21 +0,0 @@
-const ContextAllocator = MemoryPool(usize);
-
-pub fn MemoryPool(comptime T: type) type {
-    const free_list_t = @compileError("aoeu",);
-    _ = T;
-
-    return struct {
-        free_list: free_list_t,
-    };
-}
-
-export fn entry() void {
-    var allocator: ContextAllocator = undefined;
-    _ = allocator;
-}
-
-// error
-// target=native
-//
-// :4:5: error: unreachable code
-// :4:25: note: control flow is diverted here
diff --git a/test/compile_errors/stage2/duplicate-unused_labels.zig b/test/compile_errors/stage2/duplicate-unused_labels.zig
deleted file mode 100644
index 4bfc6c596012082af8e971d5ab932f86a01c8c5c..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage2/duplicate-unused_labels.zig
+++ /dev/null
@@ -1,31 +0,0 @@
-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)) |_| {}
-}
-
-// error
-// target=native
-//
-// :2:12: error: redefinition of label 'blk'
-// :2:5: note: previous definition here
-// :5:26: error: redefinition of label 'blk'
-// :5:5: note: previous definition here
-// :8:46: error: redefinition of label 'blk'
-// :8:5: note: previous definition here
-// :11:5: error: unused block label
-// :14:5: error: unused while loop label
-// :17:5: error: unused for loop label
diff --git a/test/compile_errors/stage2/embed_outside_package.zig b/test/compile_errors/stage2/embed_outside_package.zig
deleted file mode 100644
index 2003adb06199e8df8136ea6941d4ac346219f6bb..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage2/embed_outside_package.zig
+++ /dev/null
@@ -1,8 +0,0 @@
-export fn a() usize {
-    return @embedFile("/root/foo").len;
-}
-
-// error
-// target=native
-//
-//:2:23: error: embed of file outside package path: '/root/foo'
diff --git a/test/compile_errors/stage2/import_outside_package.zig b/test/compile_errors/stage2/import_outside_package.zig
deleted file mode 100644
index 59a75e2745a22d2f1b84d40d0555c4e7dc1ae881..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage2/import_outside_package.zig
+++ /dev/null
@@ -1,8 +0,0 @@
-export fn a() usize {
-    return @import("../../above.zig").len;
-}
-
-// error
-// target=native
-//
-// :2:20: error: import of file outside package path: '../../above.zig'
diff --git a/test/compile_errors/stage2/out_of_bounds_index.zig b/test/compile_errors/stage2/out_of_bounds_index.zig
deleted file mode 100644
index ea9bc6521d136e0aacf5ee7c69307f50c6bef577..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage2/out_of_bounds_index.zig
+++ /dev/null
@@ -1,29 +0,0 @@
-comptime {
-    var array = [_:0]u8{ 1, 2, 3, 4 };
-    var src_slice: [:0]u8 = &array;
-    var slice = src_slice[2..6];
-    _ = slice;
-}
-comptime {
-    var array = [_:0]u8{ 1, 2, 3, 4 };
-    var slice = array[2..6];
-    _ = slice;
-}
-comptime {
-    var array = [_]u8{ 1, 2, 3, 4 };
-    var slice = array[2..5];
-    _ = slice;
-}
-comptime {
-    var array = [_:0]u8{ 1, 2, 3, 4 };
-    var slice = array[3..2];
-    _ = slice;
-}
-
-// error
-// target=native
-//
-// :4:26: error: end index 6 out of bounds for slice of length 4 +1 (sentinel)
-// :9:22: error: end index 6 out of bounds for array of length 4 +1 (sentinel)
-// :14:22: error: end index 5 out of bounds for array of length 4
-// :19:22: error: start index 3 is larger than end index 2
diff --git a/test/compile_errors/stage2/slice_of_null_pointer.zig b/test/compile_errors/stage2/slice_of_null_pointer.zig
deleted file mode 100644
index 7f2c74a8a62bfc65116889043afdcd75e1d04ddd..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage2/slice_of_null_pointer.zig
+++ /dev/null
@@ -1,11 +0,0 @@
-comptime {
-    var x: [*c]u8 = null;
-    var runtime_len: usize = 0;
-    var y = x[0..runtime_len];
-    _ = y;
-}
-
-// error
-// target=native
-//
-// :4:14: error: slice of null pointer
diff --git a/test/compile_errors/stage2/struct_duplicate_field_name.zig b/test/compile_errors/stage2/struct_duplicate_field_name.zig
deleted file mode 100644
index 7e4434f1d92fa353d9fccff5f2c403fae90c9978..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage2/struct_duplicate_field_name.zig
+++ /dev/null
@@ -1,16 +0,0 @@
-const S = struct {
-    foo: u32,
-    foo: u32,
-};
-
-export fn entry() void {
-    const s: S = .{ .foo = 100 };
-    _ = s;
-}
-
-// error
-// target=native
-//
-// :3:5: error: duplicate struct field: 'foo'
-// :2:5: note: other field here
-// :1:11: note: struct declared here
diff --git a/test/compile_errors/stage2/union_access_of_inactive_field.zig b/test/compile_errors/stage2/union_access_of_inactive_field.zig
deleted file mode 100644
index 4f72914216fce157fc689d84d177add5ade64fcc..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage2/union_access_of_inactive_field.zig
+++ /dev/null
@@ -1,15 +0,0 @@
-const U = union {
-    a: void,
-    b: u64,
-};
-comptime {
-    var u: U = .{ .a = {} };
-    const v = u.b;
-    _ = v;
-}
-
-// error
-// target=native
-//
-// :7:16: error: access of union field 'b' while field 'a' is active
-// :1:11: note: union declared here
diff --git a/test/compile_errors/stage2/union_duplicate_enum_field.zig b/test/compile_errors/stage2/union_duplicate_enum_field.zig
deleted file mode 100644
index 44eb58e01449d22d53bf6382c8e61d0cc69b9cb9..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage2/union_duplicate_enum_field.zig
+++ /dev/null
@@ -1,17 +0,0 @@
-const E = enum { a, b };
-const U = union(E) {
-    a: u32,
-    a: u32,
-};
-
-export fn foo() void {
-    var u: U = .{ .a = 123 };
-    _ = u;
-}
-
-// error
-// target=native
-//
-// :4:5: error: duplicate union field: 'a'
-// :3:5: note: other field here
-// :2:11: note: union declared here
diff --git a/test/compile_errors/stage2/union_duplicate_field_definition.zig b/test/compile_errors/stage2/union_duplicate_field_definition.zig
deleted file mode 100644
index 7993f27141f54f163bc29e32dfe0ed46054c67c4..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage2/union_duplicate_field_definition.zig
+++ /dev/null
@@ -1,16 +0,0 @@
-const U = union {
-    foo: u32,
-    foo: u32,
-};
-
-export fn entry() void {
-    const u: U = .{ .foo = 100 };
-    _ = u;
-}
-
-// error
-// target=native
-//
-// :3:5: error: duplicate union field: 'foo'
-// :2:5: note: other field here
-// :1:11: note: union declared here
diff --git a/test/compile_errors/stage2/union_enum_field_missing.zig b/test/compile_errors/stage2/union_enum_field_missing.zig
deleted file mode 100644
index 25ec477894be5813bdfa6498309e0861cde49820..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage2/union_enum_field_missing.zig
+++ /dev/null
@@ -1,21 +0,0 @@
-const E = enum {
-    a,
-    b,
-    c,
-};
-
-const U = union(E) {
-    a: i32,
-    b: f64,
-};
-
-export fn entry() usize {
-    return @sizeOf(U);
-}
-
-// error
-// target=native
-//
-// :7:1: error: enum field(s) missing in union
-// :4:5: note: field 'c' missing, declared here
-// :1:11: note: enum declared here
diff --git a/test/compile_errors/stage2/union_extra_field.zig b/test/compile_errors/stage2/union_extra_field.zig
deleted file mode 100644
index e3bc0deb33e5a5645b130b316126f532859cb744..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage2/union_extra_field.zig
+++ /dev/null
@@ -1,20 +0,0 @@
-const E = enum {
-    a,
-    b,
-    c,
-};
-const U = union(E) {
-    a: i32,
-    b: f64,
-    c: f64,
-    d: f64,
-};
-export fn entry() usize {
-    return @sizeOf(U);
-}
-
-// error
-// target=native
-//
-// :6:1: error: enum 'tmp.E' has no field named 'd'
-// :1:11: note: enum declared here
diff --git a/test/compile_errors/stage2/union_runtime_coercion_from_enum.zig b/test/compile_errors/stage2/union_runtime_coercion_from_enum.zig
deleted file mode 100644
index 9020e9d5d7d202ef14c9c2660bee33df59508901..0000000000000000000000000000000000000000
--- a/test/compile_errors/stage2/union_runtime_coercion_from_enum.zig
+++ /dev/null
@@ -1,23 +0,0 @@
-const E = enum {
-    a,
-    b,
-};
-const U = union(E) {
-    a: u32,
-    b: u64,
-};
-fn foo() E {
-    return E.b;
-}
-export fn doTheTest() u64 {
-    var u: U = foo();
-    return u.b;
-}
-
-// error
-// target=native
-//
-// :13:19: error: runtime coercion from enum 'tmp.E' to union 'tmp.U' which has non-void fields
-// :6:5: note: field 'a' has type 'u32'
-// :7:5: note: field 'b' has type 'u64'
-// :5:11: note: union declared here
diff --git a/test/incremental/aarch64-linux/conditional_branches.0.zig b/test/incremental/aarch64-linux/conditional_branches.0.zig
deleted file mode 100644
index 28435b9d4a86940fb08eaf65bc8243a2488d4429..0000000000000000000000000000000000000000
--- a/test/incremental/aarch64-linux/conditional_branches.0.zig
+++ /dev/null
@@ -1,26 +0,0 @@
-pub fn main() void {
-    foo(123);
-}
-
-fn foo(x: u64) void {
-    if (x > 42) {
-        print();
-    }
-}
-
-fn print() void {
-    asm volatile ("svc #0"
-        :
-        : [number] "{x8}" (64),
-          [arg1] "{x0}" (1),
-          [arg2] "{x1}" (@ptrToInt("Hello, World!\n")),
-          [arg3] "{x2}" ("Hello, World!\n".len),
-        : "memory", "cc"
-    );
-}
-
-// run
-// target=aarch64-linux
-//
-// Hello, World!
-//
diff --git a/test/incremental/aarch64-linux/conditional_branches.1.zig b/test/incremental/aarch64-linux/conditional_branches.1.zig
deleted file mode 100644
index e03758fcb7c99317c812e8ef06921fe5c43d4f19..0000000000000000000000000000000000000000
--- a/test/incremental/aarch64-linux/conditional_branches.1.zig
+++ /dev/null
@@ -1,25 +0,0 @@
-pub fn main() void {
-    foo(true);
-}
-
-fn foo(x: bool) void {
-    if (x) {
-        print();
-    }
-}
-
-fn print() void {
-    asm volatile ("svc #0"
-        :
-        : [number] "{x8}" (64),
-          [arg1] "{x0}" (1),
-          [arg2] "{x1}" (@ptrToInt("Hello, World!\n")),
-          [arg3] "{x2}" ("Hello, World!\n".len),
-        : "memory", "cc"
-    );
-}
-
-// run
-//
-// Hello, World!
-//
diff --git a/test/incremental/aarch64-linux/hello_world_with_updates.0.zig b/test/incremental/aarch64-linux/hello_world_with_updates.0.zig
deleted file mode 100644
index 7a87d74dc3063b0d16f4f12fa678a4d3e7e13953..0000000000000000000000000000000000000000
--- a/test/incremental/aarch64-linux/hello_world_with_updates.0.zig
+++ /dev/null
@@ -1,31 +0,0 @@
-pub export fn _start() noreturn {
-    print();
-    exit(0);
-}
-
-fn print() void {
-    asm volatile ("svc #0"
-        :
-        : [number] "{x8}" (64),
-          [arg1] "{x0}" (1),
-          [arg2] "{x1}" (@ptrToInt("Hello, World!\n")),
-          [arg3] "{x2}" ("Hello, World!\n".len),
-        : "memory", "cc"
-    );
-}
-
-fn exit(ret: usize) noreturn {
-    asm volatile ("svc #0"
-        :
-        : [number] "{x8}" (93),
-          [arg1] "{x0}" (ret),
-        : "memory", "cc"
-    );
-    unreachable;
-}
-
-// run
-// target=aarch64-linux
-//
-// Hello, World!
-//
diff --git a/test/incremental/aarch64-linux/hello_world_with_updates.1.zig b/test/incremental/aarch64-linux/hello_world_with_updates.1.zig
deleted file mode 100644
index a5ca0d9926f62da4dcefb2ff2b30c902acbf1a38..0000000000000000000000000000000000000000
--- a/test/incremental/aarch64-linux/hello_world_with_updates.1.zig
+++ /dev/null
@@ -1,36 +0,0 @@
-pub export fn _start() noreturn {
-    print();
-    print();
-    print();
-    print();
-    exit(0);
-}
-
-fn print() void {
-    asm volatile ("svc #0"
-        :
-        : [number] "{x8}" (64),
-          [arg1] "{x0}" (1),
-          [arg2] "{x1}" (@ptrToInt("Hello, World!\n")),
-          [arg3] "{x2}" ("Hello, World!\n".len),
-        : "memory", "cc"
-    );
-}
-
-fn exit(ret: usize) noreturn {
-    asm volatile ("svc #0"
-        :
-        : [number] "{x8}" (93),
-          [arg1] "{x0}" (ret),
-        : "memory", "cc"
-    );
-    unreachable;
-}
-
-// run
-//
-// Hello, World!
-// Hello, World!
-// Hello, World!
-// Hello, World!
-//
diff --git a/test/incremental/aarch64-linux/hello_world_with_updates.2.zig b/test/incremental/aarch64-linux/hello_world_with_updates.2.zig
deleted file mode 100644
index 71f0f160bc6ba35df619c1875671515f7240ccf7..0000000000000000000000000000000000000000
--- a/test/incremental/aarch64-linux/hello_world_with_updates.2.zig
+++ /dev/null
@@ -1,21 +0,0 @@
-pub fn main() void {
-    print();
-    print();
-}
-
-fn print() void {
-    asm volatile ("svc #0"
-        :
-        : [number] "{x8}" (64),
-          [arg1] "{x0}" (1),
-          [arg2] "{x1}" (@ptrToInt("Hello, World!\n")),
-          [arg3] "{x2}" ("Hello, World!\n".len),
-        : "memory", "cc"
-    );
-}
-
-// run
-//
-// Hello, World!
-// Hello, World!
-//
diff --git a/test/incremental/aarch64-macos/hello_world_with_updates.0.zig b/test/incremental/aarch64-macos/hello_world_with_updates.0.zig
deleted file mode 100644
index 300baac1a45566c33a5e0aa3573cdad39db51a0b..0000000000000000000000000000000000000000
--- a/test/incremental/aarch64-macos/hello_world_with_updates.0.zig
+++ /dev/null
@@ -1,5 +0,0 @@
-// error
-// output_mode=Exe
-// target=aarch64-macos
-//
-// :107:9: error: struct 'tmp.tmp' has no member named 'main'
diff --git a/test/incremental/aarch64-macos/hello_world_with_updates.1.zig b/test/incremental/aarch64-macos/hello_world_with_updates.1.zig
deleted file mode 100644
index 909fc9ccfbcb343f761414446c0ec4d52e98aeef..0000000000000000000000000000000000000000
--- a/test/incremental/aarch64-macos/hello_world_with_updates.1.zig
+++ /dev/null
@@ -1,5 +0,0 @@
-pub export fn main() noreturn {}
-
-// error
-//
-// :1:32: error: expected noreturn, found void
diff --git a/test/incremental/aarch64-macos/hello_world_with_updates.2.zig b/test/incremental/aarch64-macos/hello_world_with_updates.2.zig
deleted file mode 100644
index fb8cb39eddf859f843ce61b068c0f6f8f9feb387..0000000000000000000000000000000000000000
--- a/test/incremental/aarch64-macos/hello_world_with_updates.2.zig
+++ /dev/null
@@ -1,19 +0,0 @@
-extern "c" fn write(usize, usize, usize) usize;
-extern "c" fn exit(usize) noreturn;
-
-pub export fn main() noreturn {
-    print();
-
-    exit(0);
-}
-
-fn print() void {
-    const msg = @ptrToInt("Hello, World!\n");
-    const len = 14;
-    _ = write(1, msg, len);
-}
-
-// run
-//
-// Hello, World!
-//
diff --git a/test/incremental/aarch64-macos/hello_world_with_updates.3.zig b/test/incremental/aarch64-macos/hello_world_with_updates.3.zig
deleted file mode 100644
index f6e233886b0a7d616f92dd11ffb4232191c997de..0000000000000000000000000000000000000000
--- a/test/incremental/aarch64-macos/hello_world_with_updates.3.zig
+++ /dev/null
@@ -1,16 +0,0 @@
-extern "c" fn write(usize, usize, usize) usize;
-
-pub fn main() void {
-    print();
-}
-
-fn print() void {
-    const msg = @ptrToInt("Hello, World!\n");
-    const len = 14;
-    _ = write(1, msg, len);
-}
-
-// run
-//
-// Hello, World!
-//
diff --git a/test/incremental/aarch64-macos/hello_world_with_updates.4.zig b/test/incremental/aarch64-macos/hello_world_with_updates.4.zig
deleted file mode 100644
index f89cef73543ce1f3e51a4e0152c0a8c367edf537..0000000000000000000000000000000000000000
--- a/test/incremental/aarch64-macos/hello_world_with_updates.4.zig
+++ /dev/null
@@ -1,22 +0,0 @@
-extern "c" fn write(usize, usize, usize) usize;
-
-pub fn main() void {
-    print();
-    print();
-    print();
-    print();
-}
-
-fn print() void {
-    const msg = @ptrToInt("Hello, World!\n");
-    const len = 14;
-    _ = write(1, msg, len);
-}
-
-// run
-//
-// Hello, World!
-// Hello, World!
-// Hello, World!
-// Hello, World!
-//
diff --git a/test/incremental/aarch64-macos/hello_world_with_updates.5.zig b/test/incremental/aarch64-macos/hello_world_with_updates.5.zig
deleted file mode 100644
index 0d7f97578afe1274d1c8e3d356ce702992edca61..0000000000000000000000000000000000000000
--- a/test/incremental/aarch64-macos/hello_world_with_updates.5.zig
+++ /dev/null
@@ -1,16 +0,0 @@
-extern "c" fn write(usize, usize, usize) usize;
-
-pub fn main() void {
-    print();
-}
-
-fn print() void {
-    const msg = @ptrToInt("What is up? This is a longer message that will force the data to be relocated in virtual address space.\n");
-    const len = 104;
-    _ = write(1, msg, len);
-}
-
-// run
-//
-// What is up? This is a longer message that will force the data to be relocated in virtual address space.
-//
diff --git a/test/incremental/aarch64-macos/hello_world_with_updates.6.zig b/test/incremental/aarch64-macos/hello_world_with_updates.6.zig
deleted file mode 100644
index 3ce2cb717639d663c2679dcdef2a4583c3c3f8ec..0000000000000000000000000000000000000000
--- a/test/incremental/aarch64-macos/hello_world_with_updates.6.zig
+++ /dev/null
@@ -1,18 +0,0 @@
-extern "c" fn write(usize, usize, usize) usize;
-
-pub fn main() void {
-    print();
-    print();
-}
-
-fn print() void {
-    const msg = @ptrToInt("What is up? This is a longer message that will force the data to be relocated in virtual address space.\n");
-    const len = 104;
-    _ = write(1, msg, len);
-}
-
-// run
-//
-// What is up? This is a longer message that will force the data to be relocated in virtual address space.
-// What is up? This is a longer message that will force the data to be relocated in virtual address space.
-//
diff --git a/test/incremental/adding_numbers_at_runtime_and_comptime.0.zig b/test/incremental/adding_numbers_at_runtime_and_comptime.0.zig
deleted file mode 100644
index e8c219681348a2456792cffea64853f01c5ab81e..0000000000000000000000000000000000000000
--- a/test/incremental/adding_numbers_at_runtime_and_comptime.0.zig
+++ /dev/null
@@ -1,10 +0,0 @@
-pub fn main() void {
-    add(3, 4);
-}
-
-fn add(a: u32, b: u32) void {
-    if (a + b != 7) unreachable;
-}
-
-// run
-//
diff --git a/test/incremental/adding_numbers_at_runtime_and_comptime.1.zig b/test/incremental/adding_numbers_at_runtime_and_comptime.1.zig
deleted file mode 100644
index d90dc6884d6960c96c1192d673662f275739d9ce..0000000000000000000000000000000000000000
--- a/test/incremental/adding_numbers_at_runtime_and_comptime.1.zig
+++ /dev/null
@@ -1,12 +0,0 @@
-pub fn main() void {
-    if (x - 7 != 0) unreachable;
-}
-
-fn add(a: u32, b: u32) u32 {
-    return a + b;
-}
-
-const x = add(3, 4);
-
-// run
-//
diff --git a/test/incremental/adding_numbers_at_runtime_and_comptime.2.zig b/test/incremental/adding_numbers_at_runtime_and_comptime.2.zig
deleted file mode 100644
index 6643d811fc7edd946d27adac4302439093fb2603..0000000000000000000000000000000000000000
--- a/test/incremental/adding_numbers_at_runtime_and_comptime.2.zig
+++ /dev/null
@@ -1,12 +0,0 @@
-pub fn main() void {
-    var x: usize = 3;
-    const y = add(1, 2, x);
-    if (y - 6 != 0) unreachable;
-}
-
-inline fn add(a: usize, b: usize, c: usize) usize {
-    return a + b + c;
-}
-
-// run
-//
diff --git a/test/incremental/ambiguous_reference.zig b/test/incremental/ambiguous_reference.zig
deleted file mode 100644
index 66144a5645902aea913226486abd12657434367d..0000000000000000000000000000000000000000
--- a/test/incremental/ambiguous_reference.zig
+++ /dev/null
@@ -1,13 +0,0 @@
-const T = struct {
-    const T = struct {
-        fn f() void {
-            _ = T;
-        }
-    };
-};
-
-// error
-//
-// :4:17: error: ambiguous reference
-// :2:5: note: declared here
-// :1:1: note: also declared here
diff --git a/test/incremental/arm-linux/arithmetic_operations.0.zig b/test/incremental/arm-linux/arithmetic_operations.0.zig
deleted file mode 100644
index 51a2dbd700ff528ea70db8cac4f4a3faf0605b1a..0000000000000000000000000000000000000000
--- a/test/incremental/arm-linux/arithmetic_operations.0.zig
+++ /dev/null
@@ -1,21 +0,0 @@
-pub fn main() void {
-    print(2, 4);
-    print(1, 7);
-}
-
-fn print(a: u32, b: u32) void {
-    asm volatile ("svc #0"
-        :
-        : [number] "{r7}" (4),
-          [arg3] "{r2}" (a + b),
-          [arg1] "{r0}" (1),
-          [arg2] "{r1}" (@ptrToInt("123456789")),
-        : "memory"
-    );
-    return;
-}
-
-// run
-// target=arm-linux
-//
-// 12345612345678
diff --git a/test/incremental/arm-linux/arithmetic_operations.1.zig b/test/incremental/arm-linux/arithmetic_operations.1.zig
deleted file mode 100644
index 1e3793ed38f2cf4e554de59233f13fbcccc542c7..0000000000000000000000000000000000000000
--- a/test/incremental/arm-linux/arithmetic_operations.1.zig
+++ /dev/null
@@ -1,20 +0,0 @@
-pub fn main() void {
-    print(10, 5);
-    print(4, 3);
-}
-
-fn print(a: u32, b: u32) void {
-    asm volatile ("svc #0"
-        :
-        : [number] "{r7}" (4),
-          [arg3] "{r2}" (a - b),
-          [arg1] "{r0}" (1),
-          [arg2] "{r1}" (@ptrToInt("123456789")),
-        : "memory"
-    );
-    return;
-}
-
-// run
-//
-// 123451
diff --git a/test/incremental/arm-linux/arithmetic_operations.2.zig b/test/incremental/arm-linux/arithmetic_operations.2.zig
deleted file mode 100644
index 6b81e62198b665f8d3928069425df20bc79812bb..0000000000000000000000000000000000000000
--- a/test/incremental/arm-linux/arithmetic_operations.2.zig
+++ /dev/null
@@ -1,20 +0,0 @@
-pub fn main() void {
-    print(8, 9);
-    print(3, 7);
-}
-
-fn print(a: u32, b: u32) void {
-    asm volatile ("svc #0"
-        :
-        : [number] "{r7}" (4),
-          [arg3] "{r2}" (a & b),
-          [arg1] "{r0}" (1),
-          [arg2] "{r1}" (@ptrToInt("123456789")),
-        : "memory"
-    );
-    return;
-}
-
-// run
-//
-// 12345678123
diff --git a/test/incremental/arm-linux/arithmetic_operations.3.zig b/test/incremental/arm-linux/arithmetic_operations.3.zig
deleted file mode 100644
index 23089127f53aa331ed08030caa524b9627fdba2e..0000000000000000000000000000000000000000
--- a/test/incremental/arm-linux/arithmetic_operations.3.zig
+++ /dev/null
@@ -1,20 +0,0 @@
-pub fn main() void {
-    print(4, 2);
-    print(3, 7);
-}
-
-fn print(a: u32, b: u32) void {
-    asm volatile ("svc #0"
-        :
-        : [number] "{r7}" (4),
-          [arg3] "{r2}" (a | b),
-          [arg1] "{r0}" (1),
-          [arg2] "{r1}" (@ptrToInt("123456789")),
-        : "memory"
-    );
-    return;
-}
-
-// run
-//
-// 1234561234567
diff --git a/test/incremental/arm-linux/arithmetic_operations.4.zig b/test/incremental/arm-linux/arithmetic_operations.4.zig
deleted file mode 100644
index ce5133c4653da4568d1bdae16edf56fa418e4fb1..0000000000000000000000000000000000000000
--- a/test/incremental/arm-linux/arithmetic_operations.4.zig
+++ /dev/null
@@ -1,20 +0,0 @@
-pub fn main() void {
-    print(42, 42);
-    print(3, 5);
-}
-
-fn print(a: u32, b: u32) void {
-    asm volatile ("svc #0"
-        :
-        : [number] "{r7}" (4),
-          [arg3] "{r2}" (a ^ b),
-          [arg1] "{r0}" (1),
-          [arg2] "{r1}" (@ptrToInt("123456789")),
-        : "memory"
-    );
-    return;
-}
-
-// run
-//
-// 123456
diff --git a/test/incremental/arm-linux/arithmetic_operations.5.zig b/test/incremental/arm-linux/arithmetic_operations.5.zig
deleted file mode 100644
index b1c18ca7da2ffed288f42f414fc64b42e6e552be..0000000000000000000000000000000000000000
--- a/test/incremental/arm-linux/arithmetic_operations.5.zig
+++ /dev/null
@@ -1,15 +0,0 @@
-pub fn main() void {
-    var x: u32 = 1;
-    assert(x << 1 == 2);
-
-    x <<= 1;
-    assert(x << 2 == 8);
-    assert(x << 3 == 16);
-}
-
-pub fn assert(ok: bool) void {
-    if (!ok) unreachable; // assertion failure
-}
-
-// run
-//
diff --git a/test/incremental/arm-linux/arithmetic_operations.6.zig b/test/incremental/arm-linux/arithmetic_operations.6.zig
deleted file mode 100644
index e03731173c613aa1f3aaf5b9dd114e076eac6e7c..0000000000000000000000000000000000000000
--- a/test/incremental/arm-linux/arithmetic_operations.6.zig
+++ /dev/null
@@ -1,21 +0,0 @@
-pub fn main() void {
-    var a: u32 = 1024;
-    assert(a >> 1 == 512);
-
-    a >>= 1;
-    assert(a >> 2 == 128);
-    assert(a >> 3 == 64);
-    assert(a >> 4 == 32);
-    assert(a >> 5 == 16);
-    assert(a >> 6 == 8);
-    assert(a >> 7 == 4);
-    assert(a >> 8 == 2);
-    assert(a >> 9 == 1);
-}
-
-pub fn assert(ok: bool) void {
-    if (!ok) unreachable; // assertion failure
-}
-
-// run
-//
diff --git a/test/incremental/arm-linux/errors.0.zig b/test/incremental/arm-linux/errors.0.zig
deleted file mode 100644
index 3e20d1d9737652b33f030e6f4b51abe819e222ec..0000000000000000000000000000000000000000
--- a/test/incremental/arm-linux/errors.0.zig
+++ /dev/null
@@ -1,21 +0,0 @@
-pub fn main() void {
-    foo() catch print();
-}
-
-fn foo() anyerror!void {}
-
-fn print() void {
-    asm volatile ("svc #0"
-        :
-        : [number] "{r7}" (4),
-          [arg1] "{r0}" (1),
-          [arg2] "{r1}" (@ptrToInt("Hello, World!\n")),
-          [arg3] "{r2}" ("Hello, World!\n".len),
-        : "memory"
-    );
-    return;
-}
-
-// run
-// target=arm-linux
-//
diff --git a/test/incremental/arm-linux/errors.1.zig b/test/incremental/arm-linux/errors.1.zig
deleted file mode 100644
index 43fbb12675581ef874e92d08f360ee68263e0e4f..0000000000000000000000000000000000000000
--- a/test/incremental/arm-linux/errors.1.zig
+++ /dev/null
@@ -1,24 +0,0 @@
-pub fn main() void {
-    foo() catch print();
-}
-
-fn foo() anyerror!void {
-    return error.Test;
-}
-
-fn print() void {
-    asm volatile ("svc #0"
-        :
-        : [number] "{r7}" (4),
-          [arg1] "{r0}" (1),
-          [arg2] "{r1}" (@ptrToInt("Hello, World!\n")),
-          [arg3] "{r2}" ("Hello, World!\n".len),
-        : "memory"
-    );
-    return;
-}
-
-// run
-//
-// Hello, World!
-//
diff --git a/test/incremental/arm-linux/errors.2.zig b/test/incremental/arm-linux/errors.2.zig
deleted file mode 100644
index a1b9aef97dc4396e8e89bf1394592f260cce3743..0000000000000000000000000000000000000000
--- a/test/incremental/arm-linux/errors.2.zig
+++ /dev/null
@@ -1,27 +0,0 @@
-pub fn main() void {
-    foo() catch |err| {
-        assert(err == error.Foo);
-        assert(err != error.Bar);
-        assert(err != error.Baz);
-    };
-    bar() catch |err| {
-        assert(err != error.Foo);
-        assert(err == error.Bar);
-        assert(err != error.Baz);
-    };
-}
-
-fn assert(ok: bool) void {
-    if (!ok) unreachable;
-}
-
-fn foo() anyerror!void {
-    return error.Foo;
-}
-
-fn bar() anyerror!void {
-    return error.Bar;
-}
-
-// run
-//
diff --git a/test/incremental/arm-linux/errors.3.zig b/test/incremental/arm-linux/errors.3.zig
deleted file mode 100644
index 390696fcfcb261ea6c8383d13c0bec8c9e85c445..0000000000000000000000000000000000000000
--- a/test/incremental/arm-linux/errors.3.zig
+++ /dev/null
@@ -1,12 +0,0 @@
-pub fn main() void {
-    foo() catch unreachable;
-}
-
-fn foo() anyerror!void {
-    try bar();
-}
-
-fn bar() anyerror!void {}
-
-// run
-//
diff --git a/test/incremental/arm-linux/function_pointers.zig b/test/incremental/arm-linux/function_pointers.zig
deleted file mode 100644
index 0ef5df6745d804633632e894b586811e0636216d..0000000000000000000000000000000000000000
--- a/test/incremental/arm-linux/function_pointers.zig
+++ /dev/null
@@ -1,44 +0,0 @@
-const PrintFn = *const fn () void;
-
-pub fn main() void {
-    var printFn: PrintFn = stopSayingThat;
-    var i: u32 = 0;
-    while (i < 4) : (i += 1) printFn();
-
-    printFn = moveEveryZig;
-    printFn();
-}
-
-fn stopSayingThat() void {
-    asm volatile ("svc #0"
-        :
-        : [number] "{r7}" (4),
-          [arg1] "{r0}" (1),
-          [arg2] "{r1}" (@ptrToInt("Hello, my name is Inigo Montoya; you killed my father, prepare to die.\n")),
-          [arg3] "{r2}" ("Hello, my name is Inigo Montoya; you killed my father, prepare to die.\n".len),
-        : "memory"
-    );
-    return;
-}
-
-fn moveEveryZig() void {
-    asm volatile ("svc #0"
-        :
-        : [number] "{r7}" (4),
-          [arg1] "{r0}" (1),
-          [arg2] "{r1}" (@ptrToInt("All your codebase are belong to us\n")),
-          [arg3] "{r2}" ("All your codebase are belong to us\n".len),
-        : "memory"
-    );
-    return;
-}
-
-// run
-// target=arm-linux
-//
-// Hello, my name is Inigo Montoya; you killed my father, prepare to die.
-// Hello, my name is Inigo Montoya; you killed my father, prepare to die.
-// Hello, my name is Inigo Montoya; you killed my father, prepare to die.
-// Hello, my name is Inigo Montoya; you killed my father, prepare to die.
-// All your codebase are belong to us
-//
diff --git a/test/incremental/arm-linux/hello_world_with_updates.0.zig b/test/incremental/arm-linux/hello_world_with_updates.0.zig
deleted file mode 100644
index 4ffdc2ae0f6d372aa809c590737536d468cabae1..0000000000000000000000000000000000000000
--- a/test/incremental/arm-linux/hello_world_with_updates.0.zig
+++ /dev/null
@@ -1,32 +0,0 @@
-pub export fn _start() noreturn {
-    print();
-    exit();
-}
-
-fn print() void {
-    asm volatile ("svc #0"
-        :
-        : [number] "{r7}" (4),
-          [arg1] "{r0}" (1),
-          [arg2] "{r1}" (@ptrToInt("Hello, World!\n")),
-          [arg3] "{r2}" (14),
-        : "memory"
-    );
-    return;
-}
-
-fn exit() noreturn {
-    asm volatile ("svc #0"
-        :
-        : [number] "{r7}" (1),
-          [arg1] "{r0}" (0),
-        : "memory"
-    );
-    unreachable;
-}
-
-// run
-// target=arm-linux
-//
-// Hello, World!
-//
diff --git a/test/incremental/arm-linux/hello_world_with_updates.1.zig b/test/incremental/arm-linux/hello_world_with_updates.1.zig
deleted file mode 100644
index 8372d757ad8e448ab76cb5a2608e25307ffab904..0000000000000000000000000000000000000000
--- a/test/incremental/arm-linux/hello_world_with_updates.1.zig
+++ /dev/null
@@ -1,37 +0,0 @@
-pub export fn _start() noreturn {
-    print();
-    print();
-    print();
-    print();
-    exit();
-}
-
-fn print() void {
-    asm volatile ("svc #0"
-        :
-        : [number] "{r7}" (4),
-          [arg1] "{r0}" (1),
-          [arg2] "{r1}" (@ptrToInt("Hello, World!\n")),
-          [arg3] "{r2}" (14),
-        : "memory"
-    );
-    return;
-}
-
-fn exit() noreturn {
-    asm volatile ("svc #0"
-        :
-        : [number] "{r7}" (1),
-          [arg1] "{r0}" (0),
-        : "memory"
-    );
-    unreachable;
-}
-
-// run
-//
-// Hello, World!
-// Hello, World!
-// Hello, World!
-// Hello, World!
-//
diff --git a/test/incremental/arm-linux/hello_world_with_updates.2.zig b/test/incremental/arm-linux/hello_world_with_updates.2.zig
deleted file mode 100644
index 0b97bf2360149f324a7314208e43cb31b74a39ee..0000000000000000000000000000000000000000
--- a/test/incremental/arm-linux/hello_world_with_updates.2.zig
+++ /dev/null
@@ -1,22 +0,0 @@
-pub fn main() void {
-    print();
-    print();
-}
-
-fn print() void {
-    asm volatile ("svc #0"
-        :
-        : [number] "{r7}" (4),
-          [arg1] "{r0}" (1),
-          [arg2] "{r1}" (@ptrToInt("Hello, World!\n")),
-          [arg3] "{r2}" (14),
-        : "memory"
-    );
-    return;
-}
-
-// run
-//
-// Hello, World!
-// Hello, World!
-//
diff --git a/test/incremental/arm-linux/parameters_and_return_values.0.zig b/test/incremental/arm-linux/parameters_and_return_values.0.zig
deleted file mode 100644
index 6a306d802c2ad01609c73cc79cf6c81d9c6b7b07..0000000000000000000000000000000000000000
--- a/test/incremental/arm-linux/parameters_and_return_values.0.zig
+++ /dev/null
@@ -1,28 +0,0 @@
-pub fn main() void {
-    print(id(14));
-}
-
-fn id(x: u32) u32 {
-    return x;
-}
-
-// TODO: The parameters to the asm statement in print() had to
-// be in a specific order because otherwise the write to r0
-// would overwrite the len parameter which resides in r0
-fn print(len: u32) void {
-    asm volatile ("svc #0"
-        :
-        : [number] "{r7}" (4),
-          [arg3] "{r2}" (len),
-          [arg1] "{r0}" (1),
-          [arg2] "{r1}" (@ptrToInt("Hello, World!\n")),
-        : "memory"
-    );
-    return;
-}
-
-// run
-// target=arm-linux
-//
-// Hello, World!
-//
diff --git a/test/incremental/arm-linux/parameters_and_return_values.1.zig b/test/incremental/arm-linux/parameters_and_return_values.1.zig
deleted file mode 100644
index f2bc35d22ec6a7ac0b203bf257d10805815dc931..0000000000000000000000000000000000000000
--- a/test/incremental/arm-linux/parameters_and_return_values.1.zig
+++ /dev/null
@@ -1,14 +0,0 @@
-pub fn main() void {
-    assert(add(1, 2, 3, 4, 5, 6) == 21);
-}
-
-fn add(a: u32, b: u32, c: u32, d: u32, e: u32, f: u32) u32 {
-    return a + b + c + d + e + f;
-}
-
-pub fn assert(ok: bool) void {
-    if (!ok) unreachable; // assertion failure
-}
-
-// run
-//
diff --git a/test/incremental/arm-linux/print_u32s.zig b/test/incremental/arm-linux/print_u32s.zig
deleted file mode 100644
index 92fad75ddf0a1f75e5d3c0ac6d04052166771cde..0000000000000000000000000000000000000000
--- a/test/incremental/arm-linux/print_u32s.zig
+++ /dev/null
@@ -1,40 +0,0 @@
-pub fn main() void {
-    printNumberHex(0x00000000);
-    printNumberHex(0xaaaaaaaa);
-    printNumberHex(0xdeadbeef);
-    printNumberHex(0x31415926);
-}
-
-fn printNumberHex(x: u32) void {
-    var i: u5 = 28;
-    while (true) : (i -= 4) {
-        const digit = (x >> i) & 0xf;
-        asm volatile ("svc #0"
-            :
-            : [number] "{r7}" (4),
-              [arg1] "{r0}" (1),
-              [arg2] "{r1}" (@ptrToInt("0123456789abcdef") + digit),
-              [arg3] "{r2}" (1),
-            : "memory"
-        );
-
-        if (i == 0) break;
-    }
-    asm volatile ("svc #0"
-        :
-        : [number] "{r7}" (4),
-          [arg1] "{r0}" (1),
-          [arg2] "{r1}" (@ptrToInt("\n")),
-          [arg3] "{r2}" (1),
-        : "memory"
-    );
-}
-
-// run
-// target=arm-linux
-//
-// 00000000
-// aaaaaaaa
-// deadbeef
-// 31415926
-//
diff --git a/test/incremental/arm-linux/spilling_registers.0.zig b/test/incremental/arm-linux/spilling_registers.0.zig
deleted file mode 100644
index ac74e071ad70f03a2d90f76c8d9cd9ca66f76095..0000000000000000000000000000000000000000
--- a/test/incremental/arm-linux/spilling_registers.0.zig
+++ /dev/null
@@ -1,38 +0,0 @@
-pub fn main() void {
-    assert(add(3, 4) == 791);
-}
-
-fn add(a: u32, b: u32) u32 {
-    const x: u32 = blk: {
-        const c = a + b; // 7
-        const d = a + c; // 10
-        const e = d + b; // 14
-        const f = d + e; // 24
-        const g = e + f; // 38
-        const h = f + g; // 62
-        const i = g + h; // 100
-        const j = i + d; // 110
-        const k = i + j; // 210
-        const l = k + c; // 217
-        const m = l + d; // 227
-        const n = m + e; // 241
-        const o = n + f; // 265
-        const p = o + g; // 303
-        const q = p + h; // 365
-        const r = q + i; // 465
-        const s = r + j; // 575
-        const t = s + k; // 785
-        break :blk t;
-    };
-    const y = x + a; // 788
-    const z = y + a; // 791
-    return z;
-}
-
-fn assert(ok: bool) void {
-    if (!ok) unreachable;
-}
-
-// run
-// target=arm-linux
-//
diff --git a/test/incremental/arm-linux/spilling_registers.1.zig b/test/incremental/arm-linux/spilling_registers.1.zig
deleted file mode 100644
index f401a5d7b7d1f29a9dc628315cff7e5b4e85d21c..0000000000000000000000000000000000000000
--- a/test/incremental/arm-linux/spilling_registers.1.zig
+++ /dev/null
@@ -1,37 +0,0 @@
-pub fn main() void {
-    assert(addMul(3, 4) == 357747496);
-}
-
-fn addMul(a: u32, b: u32) u32 {
-    const x: u32 = blk: {
-        const c = a + b; // 7
-        const d = a + c; // 10
-        const e = d + b; // 14
-        const f = d + e; // 24
-        const g = e + f; // 38
-        const h = f + g; // 62
-        const i = g + h; // 100
-        const j = i + d; // 110
-        const k = i + j; // 210
-        const l = k + c; // 217
-        const m = l * d; // 2170
-        const n = m + e; // 2184
-        const o = n * f; // 52416
-        const p = o + g; // 52454
-        const q = p * h; // 3252148
-        const r = q + i; // 3252248
-        const s = r * j; // 357747280
-        const t = s + k; // 357747490
-        break :blk t;
-    };
-    const y = x + a; // 357747493
-    const z = y + a; // 357747496
-    return z;
-}
-
-fn assert(ok: bool) void {
-    if (!ok) unreachable;
-}
-
-// run
-//
diff --git a/test/incremental/bad_inferred_variable_type.zig b/test/incremental/bad_inferred_variable_type.zig
deleted file mode 100644
index 47ceb9b638185dbc9dafd3ec92900dfa5ad4d4cf..0000000000000000000000000000000000000000
--- a/test/incremental/bad_inferred_variable_type.zig
+++ /dev/null
@@ -1,9 +0,0 @@
-pub fn main() void {
-    var x = null;
-    _ = x;
-}
-
-// error
-// output_mode=Exe
-//
-// :2:9: error: variable of type '@TypeOf(null)' must be const or comptime
diff --git a/test/incremental/binary_operands.0.zig b/test/incremental/binary_operands.0.zig
deleted file mode 100644
index e3688232aa27c190ecfcbab4f4ea734093156d98..0000000000000000000000000000000000000000
--- a/test/incremental/binary_operands.0.zig
+++ /dev/null
@@ -1,9 +0,0 @@
-pub fn main() void {
-    var i: u8 = 5;
-    i += 20;
-    if (i != 25) unreachable;
-}
-
-// run
-// target=wasm32-wasi
-//
diff --git a/test/incremental/binary_operands.1.zig b/test/incremental/binary_operands.1.zig
deleted file mode 100644
index fdee492d227abb71eca039c996d32c6a24568d43..0000000000000000000000000000000000000000
--- a/test/incremental/binary_operands.1.zig
+++ /dev/null
@@ -1,8 +0,0 @@
-pub fn main() void {
-    var i: i32 = 2147483647;
-    if (i +% 1 != -2147483648) unreachable;
-    return;
-}
-
-// run
-//
diff --git a/test/incremental/binary_operands.10.zig b/test/incremental/binary_operands.10.zig
deleted file mode 100644
index 63e045c258199ca9127804d16969e7ba2d4c9a64..0000000000000000000000000000000000000000
--- a/test/incremental/binary_operands.10.zig
+++ /dev/null
@@ -1,13 +0,0 @@
-pub fn main() void {
-    var i: u32 = 5;
-    i *= 7;
-    var result: u32 = foo(i, 10);
-    if (result != 350) unreachable;
-    return;
-}
-fn foo(x: u32, y: u32) u32 {
-    return x * y;
-}
-
-// run
-//
diff --git a/test/incremental/binary_operands.11.zig b/test/incremental/binary_operands.11.zig
deleted file mode 100644
index f461bcc0af9ba6cb1cae194c078fb53bcd6b24bd..0000000000000000000000000000000000000000
--- a/test/incremental/binary_operands.11.zig
+++ /dev/null
@@ -1,9 +0,0 @@
-pub fn main() void {
-    var i: i32 = 2147483647;
-    const result = i *% 2;
-    if (result != -2) unreachable;
-    return;
-}
-
-// run
-//
diff --git a/test/incremental/binary_operands.12.zig b/test/incremental/binary_operands.12.zig
deleted file mode 100644
index 0ffb5e22309d4642af7b59c80999f2ce465d7c45..0000000000000000000000000000000000000000
--- a/test/incremental/binary_operands.12.zig
+++ /dev/null
@@ -1,8 +0,0 @@
-pub fn main() void {
-    var i: u3 = 3;
-    if (i *% 3 != 1) unreachable;
-    return;
-}
-
-// run
-//
diff --git a/test/incremental/binary_operands.13.zig b/test/incremental/binary_operands.13.zig
deleted file mode 100644
index e62107b47e71c7bb3d7a0cf2d8e9fcf9b8ee7a0c..0000000000000000000000000000000000000000
--- a/test/incremental/binary_operands.13.zig
+++ /dev/null
@@ -1,8 +0,0 @@
-pub fn main() void {
-    var i: i4 = 3;
-    if (i *% 3 != 1) unreachable;
-    return;
-}
-
-// run
-//
diff --git a/test/incremental/binary_operands.14.zig b/test/incremental/binary_operands.14.zig
deleted file mode 100644
index fcc7245ad97d3606a1d364981bbae5c1339cc8d7..0000000000000000000000000000000000000000
--- a/test/incremental/binary_operands.14.zig
+++ /dev/null
@@ -1,13 +0,0 @@
-pub fn main() void {
-    var i: u32 = 352;
-    i /= 7; // i = 50
-    var result: u32 = foo(i, 7);
-    if (result != 7) unreachable;
-    return;
-}
-fn foo(x: u32, y: u32) u32 {
-    return x / y;
-}
-
-// run
-//
diff --git a/test/incremental/binary_operands.15.zig b/test/incremental/binary_operands.15.zig
deleted file mode 100644
index c709e5dfd2327111b9ea86deaa341e12d148df0e..0000000000000000000000000000000000000000
--- a/test/incremental/binary_operands.15.zig
+++ /dev/null
@@ -1,8 +0,0 @@
-pub fn main() u8 {
-    var i: u8 = 5;
-    i &= 6;
-    return i - 4;
-}
-
-// run
-//
diff --git a/test/incremental/binary_operands.16.zig b/test/incremental/binary_operands.16.zig
deleted file mode 100644
index fe1813b8772784ea7a9617f755223f0ed34fefb1..0000000000000000000000000000000000000000
--- a/test/incremental/binary_operands.16.zig
+++ /dev/null
@@ -1,8 +0,0 @@
-pub fn main() u8 {
-    var i: u8 = 5;
-    i |= 6;
-    return i - 7;
-}
-
-// run
-//
diff --git a/test/incremental/binary_operands.17.zig b/test/incremental/binary_operands.17.zig
deleted file mode 100644
index 439d3d6d6b59699ca309a7705ac83b312fd33b9b..0000000000000000000000000000000000000000
--- a/test/incremental/binary_operands.17.zig
+++ /dev/null
@@ -1,8 +0,0 @@
-pub fn main() u8 {
-    var i: u8 = 5;
-    i ^= 6;
-    return i - 3;
-}
-
-// run
-//
diff --git a/test/incremental/binary_operands.18.zig b/test/incremental/binary_operands.18.zig
deleted file mode 100644
index c21aa586c555e8fd882ba31a0bbbe5169e6ff5e0..0000000000000000000000000000000000000000
--- a/test/incremental/binary_operands.18.zig
+++ /dev/null
@@ -1,9 +0,0 @@
-pub fn main() void {
-    var b: bool = false;
-    b = b or false;
-    if (b) unreachable;
-    return;
-}
-
-// run
-//
diff --git a/test/incremental/binary_operands.19.zig b/test/incremental/binary_operands.19.zig
deleted file mode 100644
index e95470391cf1bec9d9412b1b4156eb26d77669f7..0000000000000000000000000000000000000000
--- a/test/incremental/binary_operands.19.zig
+++ /dev/null
@@ -1,9 +0,0 @@
-pub fn main() void {
-    var b: bool = true;
-    b = b or false;
-    if (!b) unreachable;
-    return;
-}
-
-// run
-//
diff --git a/test/incremental/binary_operands.2.zig b/test/incremental/binary_operands.2.zig
deleted file mode 100644
index 7407ed7d9558f22956f631ac9af4edbf31edc24e..0000000000000000000000000000000000000000
--- a/test/incremental/binary_operands.2.zig
+++ /dev/null
@@ -1,8 +0,0 @@
-pub fn main() void {
-    var i: i4 = 7;
-    if (i +% 1 != 0) unreachable;
-    return;
-}
-
-// run
-//
diff --git a/test/incremental/binary_operands.20.zig b/test/incremental/binary_operands.20.zig
deleted file mode 100644
index 9238bf97c04ed9e5dbb0cc98634eecf96de9fa40..0000000000000000000000000000000000000000
--- a/test/incremental/binary_operands.20.zig
+++ /dev/null
@@ -1,9 +0,0 @@
-pub fn main() void {
-    var b: bool = false;
-    b = b or true;
-    if (!b) unreachable;
-    return;
-}
-
-// run
-//
diff --git a/test/incremental/binary_operands.21.zig b/test/incremental/binary_operands.21.zig
deleted file mode 100644
index a2d427bda9d66dbdcb59d300ffbab4e1a6af9076..0000000000000000000000000000000000000000
--- a/test/incremental/binary_operands.21.zig
+++ /dev/null
@@ -1,9 +0,0 @@
-pub fn main() void {
-    var b: bool = true;
-    b = b or true;
-    if (!b) unreachable;
-    return;
-}
-
-// run
-//
diff --git a/test/incremental/binary_operands.22.zig b/test/incremental/binary_operands.22.zig
deleted file mode 100644
index aa8439a36189db87ef416602872feb38a3b17993..0000000000000000000000000000000000000000
--- a/test/incremental/binary_operands.22.zig
+++ /dev/null
@@ -1,9 +0,0 @@
-pub fn main() void {
-    var b: bool = false;
-    b = b and false;
-    if (b) unreachable;
-    return;
-}
-
-// run
-//
diff --git a/test/incremental/binary_operands.23.zig b/test/incremental/binary_operands.23.zig
deleted file mode 100644
index 8596ea77098058f4d23bab966d0cad540704df09..0000000000000000000000000000000000000000
--- a/test/incremental/binary_operands.23.zig
+++ /dev/null
@@ -1,9 +0,0 @@
-pub fn main() void {
-    var b: bool = true;
-    b = b and false;
-    if (b) unreachable;
-    return;
-}
-
-// run
-//
diff --git a/test/incremental/binary_operands.24.zig b/test/incremental/binary_operands.24.zig
deleted file mode 100644
index 08dc4430a2298ea934e15c140c9aa0f6d65b7603..0000000000000000000000000000000000000000
--- a/test/incremental/binary_operands.24.zig
+++ /dev/null
@@ -1,9 +0,0 @@
-pub fn main() void {
-    var b: bool = false;
-    b = b and true;
-    if (b) unreachable;
-    return;
-}
-
-// run
-//
diff --git a/test/incremental/binary_operands.25.zig b/test/incremental/binary_operands.25.zig
deleted file mode 100644
index 8aa0acfdb558d082ea40c2533b30502315aa59e3..0000000000000000000000000000000000000000
--- a/test/incremental/binary_operands.25.zig
+++ /dev/null
@@ -1,9 +0,0 @@
-pub fn main() void {
-    var b: bool = true;
-    b = b and true;
-    if (!b) unreachable;
-    return;
-}
-
-// run
-//
diff --git a/test/incremental/binary_operands.3.zig b/test/incremental/binary_operands.3.zig
deleted file mode 100644
index 0297f1e7a48a877295b059a36e0fc958e2033f61..0000000000000000000000000000000000000000
--- a/test/incremental/binary_operands.3.zig
+++ /dev/null
@@ -1,7 +0,0 @@
-pub fn main() u8 {
-    var i: u8 = 255;
-    return i +% 1;
-}
-
-// run
-//
diff --git a/test/incremental/binary_operands.4.zig b/test/incremental/binary_operands.4.zig
deleted file mode 100644
index f0f8910e1463b4127d7da741907491cbbee4394a..0000000000000000000000000000000000000000
--- a/test/incremental/binary_operands.4.zig
+++ /dev/null
@@ -1,12 +0,0 @@
-pub fn main() u8 {
-    var i: u8 = 5;
-    i += 20;
-    var result: u8 = foo(i, 10);
-    return result - 35;
-}
-fn foo(x: u8, y: u8) u8 {
-    return x + y;
-}
-
-// run
-//
diff --git a/test/incremental/binary_operands.5.zig b/test/incremental/binary_operands.5.zig
deleted file mode 100644
index 51ab437475684082b941075aa3ba636f7985977a..0000000000000000000000000000000000000000
--- a/test/incremental/binary_operands.5.zig
+++ /dev/null
@@ -1,8 +0,0 @@
-pub fn main() u8 {
-    var i: u8 = 20;
-    i -= 5;
-    return i - 15;
-}
-
-// run
-//
diff --git a/test/incremental/binary_operands.6.zig b/test/incremental/binary_operands.6.zig
deleted file mode 100644
index 5c9c5be68aa1364a8f782aaab099532cd6dde297..0000000000000000000000000000000000000000
--- a/test/incremental/binary_operands.6.zig
+++ /dev/null
@@ -1,8 +0,0 @@
-pub fn main() void {
-    var i: i32 = -2147483648;
-    if (i -% 1 != 2147483647) unreachable;
-    return;
-}
-
-// run
-//
diff --git a/test/incremental/binary_operands.7.zig b/test/incremental/binary_operands.7.zig
deleted file mode 100644
index 634a47fb0ce4042bd71d386044a2077109f39356..0000000000000000000000000000000000000000
--- a/test/incremental/binary_operands.7.zig
+++ /dev/null
@@ -1,8 +0,0 @@
-pub fn main() void {
-    var i: i7 = -64;
-    if (i -% 1 != 63) unreachable;
-    return;
-}
-
-// run
-//
diff --git a/test/incremental/binary_operands.8.zig b/test/incremental/binary_operands.8.zig
deleted file mode 100644
index a20f6646944d35e89980743212ce060d9b3e5930..0000000000000000000000000000000000000000
--- a/test/incremental/binary_operands.8.zig
+++ /dev/null
@@ -1,7 +0,0 @@
-pub fn main() void {
-    var i: u4 = 0;
-    if (i -% 1 != 15) unreachable;
-}
-
-// run
-//
diff --git a/test/incremental/binary_operands.9.zig b/test/incremental/binary_operands.9.zig
deleted file mode 100644
index e6c4f5d52b491158f629ec74f7b0f16f624f94ac..0000000000000000000000000000000000000000
--- a/test/incremental/binary_operands.9.zig
+++ /dev/null
@@ -1,12 +0,0 @@
-pub fn main() u8 {
-    var i: u8 = 5;
-    i -= 3;
-    var result: u8 = foo(i, 10);
-    return result - 8;
-}
-fn foo(x: u8, y: u8) u8 {
-    return y - x;
-}
-
-// run
-//
diff --git a/test/incremental/break_continue.0.zig b/test/incremental/break_continue.0.zig
deleted file mode 100644
index ac0abdb52dadc98760d9ac2d1b466b185e8bd90d..0000000000000000000000000000000000000000
--- a/test/incremental/break_continue.0.zig
+++ /dev/null
@@ -1,9 +0,0 @@
-pub fn main() void {
-    while (true) {
-        break;
-    }
-}
-
-// run
-// target=x86_64-linux,x86_64-macos,aarch64-linux,aarch64-macos
-//
diff --git a/test/incremental/break_continue.1.zig b/test/incremental/break_continue.1.zig
deleted file mode 100644
index 9e4f79bd14d7a1340b9fcbc02c271790c642bd07..0000000000000000000000000000000000000000
--- a/test/incremental/break_continue.1.zig
+++ /dev/null
@@ -1,8 +0,0 @@
-pub fn main() void {
-    foo: while (true) {
-        break :foo;
-    }
-}
-
-// run
-//
diff --git a/test/incremental/break_continue.2.zig b/test/incremental/break_continue.2.zig
deleted file mode 100644
index ba12f33e3f05b3419a5f3f84631e3d52a3ce9eec..0000000000000000000000000000000000000000
--- a/test/incremental/break_continue.2.zig
+++ /dev/null
@@ -1,10 +0,0 @@
-pub fn main() void {
-    var i: u64 = 0;
-    while (true) : (i += 1) {
-        if (i == 4) return;
-        continue;
-    }
-}
-
-// run
-//
diff --git a/test/incremental/break_continue.3.zig b/test/incremental/break_continue.3.zig
deleted file mode 100644
index 03e224d26545d7c8d67617dd0a4fb609b6d80405..0000000000000000000000000000000000000000
--- a/test/incremental/break_continue.3.zig
+++ /dev/null
@@ -1,10 +0,0 @@
-pub fn main() void {
-    var i: u64 = 0;
-    foo: while (true) : (i += 1) {
-        if (i == 4) return;
-        continue :foo;
-    }
-}
-
-// run
-//
diff --git a/test/incremental/catch_at_comptime.0.zig b/test/incremental/catch_at_comptime.0.zig
deleted file mode 100644
index af1545832dee3b3e558a463ebf9ac75ad36b346e..0000000000000000000000000000000000000000
--- a/test/incremental/catch_at_comptime.0.zig
+++ /dev/null
@@ -1,11 +0,0 @@
-pub fn main() void {
-    const i: anyerror!u64 = 0;
-    const caught = i catch 5;
-    assert(caught == 0);
-}
-fn assert(b: bool) void {
-    if (!b) unreachable;
-}
-
-// run
-//
diff --git a/test/incremental/catch_at_comptime.1.zig b/test/incremental/catch_at_comptime.1.zig
deleted file mode 100644
index e05caeae6d9f058b730777d4868e85850dd776c5..0000000000000000000000000000000000000000
--- a/test/incremental/catch_at_comptime.1.zig
+++ /dev/null
@@ -1,11 +0,0 @@
-pub fn main() void {
-    const i: anyerror!u64 = error.B;
-    const caught = i catch 5;
-    assert(caught == 5);
-}
-fn assert(b: bool) void {
-    if (!b) unreachable;
-}
-
-// run
-//
diff --git a/test/incremental/catch_at_comptime.2.zig b/test/incremental/catch_at_comptime.2.zig
deleted file mode 100644
index 326e6f0b61a4c8a651130c6767a72d77617506a6..0000000000000000000000000000000000000000
--- a/test/incremental/catch_at_comptime.2.zig
+++ /dev/null
@@ -1,11 +0,0 @@
-pub fn main() void {
-    const a: anyerror!comptime_int = 42;
-    const b: *const comptime_int = &(a catch unreachable);
-    assert(b.* == 42);
-}
-fn assert(b: bool) void {
-    if (!b) unreachable; // assertion failure
-}
-
-// run
-//
diff --git a/test/incremental/catch_at_comptime.3.zig b/test/incremental/catch_at_comptime.3.zig
deleted file mode 100644
index d00317f697426e19c149abb0e89ae171d0427f45..0000000000000000000000000000000000000000
--- a/test/incremental/catch_at_comptime.3.zig
+++ /dev/null
@@ -1,10 +0,0 @@
-pub fn main() void {
-    const a: anyerror!u32 = error.B;
-    _ = &(a catch |err| assert(err == error.B));
-}
-fn assert(b: bool) void {
-    if (!b) unreachable;
-}
-
-// run
-//
diff --git a/test/incremental/catch_at_comptime.4.zig b/test/incremental/catch_at_comptime.4.zig
deleted file mode 100644
index 57cb602641ded47982e332f2fbe5f484fa64363f..0000000000000000000000000000000000000000
--- a/test/incremental/catch_at_comptime.4.zig
+++ /dev/null
@@ -1,10 +0,0 @@
-pub fn main() void {
-    const a: anyerror!u32 = error.Bar;
-    a catch |err| assert(err == error.Bar);
-}
-fn assert(b: bool) void {
-    if (!b) unreachable;
-}
-
-// run
-//
diff --git a/test/incremental/compile_error.zig b/test/incremental/compile_error.zig
deleted file mode 100644
index dab0f7f7cc9fd2dc36d0bab8dcdaa5b1dbc6fdfb..0000000000000000000000000000000000000000
--- a/test/incremental/compile_error.zig
+++ /dev/null
@@ -1,7 +0,0 @@
-export fn foo() void {
-    @compileError("this is an error");
-}
-
-// error
-//
-// :2:5: error: this is an error
diff --git a/test/incremental/compile_error_in_inline_fn_call_fixed.0.zig b/test/incremental/compile_error_in_inline_fn_call_fixed.0.zig
deleted file mode 100644
index 1848490b0794abeb37eddb4f413e96cc013f976a..0000000000000000000000000000000000000000
--- a/test/incremental/compile_error_in_inline_fn_call_fixed.0.zig
+++ /dev/null
@@ -1,16 +0,0 @@
-pub fn main() void {
-    var x: usize = 3;
-    const y = add(10, 2, x);
-    if (y - 6 != 0) unreachable;
-}
-
-inline fn add(a: usize, b: usize, c: usize) usize {
-    if (a == 10) @compileError("bad");
-    return a + b + c;
-}
-
-// error
-// output_mode=Exe
-//
-// :8:18: error: bad
-// :3:18: note: called from here
diff --git a/test/incremental/compile_error_in_inline_fn_call_fixed.1.zig b/test/incremental/compile_error_in_inline_fn_call_fixed.1.zig
deleted file mode 100644
index 1e61c6c790fd3b9f7bde2c5de0ce5b67421bdc1e..0000000000000000000000000000000000000000
--- a/test/incremental/compile_error_in_inline_fn_call_fixed.1.zig
+++ /dev/null
@@ -1,13 +0,0 @@
-pub fn main() void {
-    var x: usize = 3;
-    const y = add(1, 2, x);
-    if (y - 6 != 0) unreachable;
-}
-
-inline fn add(a: usize, b: usize, c: usize) usize {
-    if (a == 10) @compileError("bad");
-    return a + b + c;
-}
-
-// run
-//
diff --git a/test/incremental/compile_log.0.zig b/test/incremental/compile_log.0.zig
deleted file mode 100644
index c213ebb930ca78b5b25f6fec55acaf643761afb5..0000000000000000000000000000000000000000
--- a/test/incremental/compile_log.0.zig
+++ /dev/null
@@ -1,17 +0,0 @@
-export fn _start() noreturn {
-    const b = true;
-    var f: u32 = 1;
-    @compileLog(b, 20, f, x);
-    @compileLog(1000);
-    var bruh: usize = true;
-    _ = bruh;
-    unreachable;
-}
-export fn other() void {
-    @compileLog(1234);
-}
-fn x() void {}
-
-// error
-//
-// :6:23: error: expected usize, found bool
diff --git a/test/incremental/compile_log.1.zig b/test/incremental/compile_log.1.zig
deleted file mode 100644
index 12e66415420870549bdff9b0e1964403985d2dd3..0000000000000000000000000000000000000000
--- a/test/incremental/compile_log.1.zig
+++ /dev/null
@@ -1,16 +0,0 @@
-export fn _start() noreturn {
-    const b = true;
-    var f: u32 = 1;
-    @compileLog(b, 20, f, x);
-    @compileLog(1000);
-    unreachable;
-}
-export fn other() void {
-    @compileLog(1234);
-}
-fn x() void {}
-
-// error
-//
-// :9:5: error: found compile log statement
-// :4:5: note: also here
diff --git a/test/incremental/double_ampersand.0.zig b/test/incremental/double_ampersand.0.zig
deleted file mode 100644
index b14c30ecb01225e88025b6e0cb1aa7c25c69f1ed..0000000000000000000000000000000000000000
--- a/test/incremental/double_ampersand.0.zig
+++ /dev/null
@@ -1,6 +0,0 @@
-pub const a = if (true && false) 1 else 2;
-
-// error
-// output_mode=Exe
-//
-// :1:24: error: ambiguous use of '&&'; use 'and' for logical AND, or change whitespace to ' & &' for bitwise AND
diff --git a/test/incremental/double_ampersand.1.zig b/test/incremental/double_ampersand.1.zig
deleted file mode 100644
index cd5bba02fdaa14bd47cc3d1332854865e9aaea49..0000000000000000000000000000000000000000
--- a/test/incremental/double_ampersand.1.zig
+++ /dev/null
@@ -1,11 +0,0 @@
-pub fn main() void {
-    const a = true;
-    const b = false;
-    _ = a & &b;
-}
-
-// error
-//
-// :4:11: error: incompatible types: 'bool' and '*const bool'
-// :4:9: note: type 'bool' here
-// :4:13: note: type '*const bool' here
diff --git a/test/incremental/double_ampersand.2.zig b/test/incremental/double_ampersand.2.zig
deleted file mode 100644
index c6f461d66126f07c9808aacf5160615fc36d7917..0000000000000000000000000000000000000000
--- a/test/incremental/double_ampersand.2.zig
+++ /dev/null
@@ -1,7 +0,0 @@
-pub fn main() void {
-    const b: u8 = 1;
-    _ = &&b;
-}
-
-// run
-//
diff --git a/test/incremental/enum_values.0.zig b/test/incremental/enum_values.0.zig
deleted file mode 100644
index d96841dd8c65b1c20f05849b687d5de6b4f2186e..0000000000000000000000000000000000000000
--- a/test/incremental/enum_values.0.zig
+++ /dev/null
@@ -1,18 +0,0 @@
-const Number = enum { One, Two, Three };
-
-pub fn main() void {
-    var number1 = Number.One;
-    var number2: Number = .Two;
-    if (false) {
-        number1;
-        number2;
-    }
-    const number3 = @intToEnum(Number, 2);
-    if (@enumToInt(number3) != 2) {
-        unreachable;
-    }
-    return;
-}
-
-// run
-//
diff --git a/test/incremental/enum_values.1.zig b/test/incremental/enum_values.1.zig
deleted file mode 100644
index 47b9e21a2778c2bdb4d23c881326b10ec975acdd..0000000000000000000000000000000000000000
--- a/test/incremental/enum_values.1.zig
+++ /dev/null
@@ -1,22 +0,0 @@
-const Number = enum { One, Two, Three };
-
-pub fn main() void {
-    var number1 = Number.One;
-    var number2: Number = .Two;
-    const number3 = @intToEnum(Number, 2);
-    assert(number1 != number2);
-    assert(number2 != number3);
-    assert(@enumToInt(number1) == 0);
-    assert(@enumToInt(number2) == 1);
-    assert(@enumToInt(number3) == 2);
-    var x: Number = .Two;
-    assert(number2 == x);
-
-    return;
-}
-fn assert(val: bool) void {
-    if (!val) unreachable;
-}
-
-// run
-//
diff --git a/test/incremental/extern_variable_has_no_type.0.zig b/test/incremental/extern_variable_has_no_type.0.zig
deleted file mode 100644
index 2f03067b3ac8aba8bfe34a948baece7c2796fe05..0000000000000000000000000000000000000000
--- a/test/incremental/extern_variable_has_no_type.0.zig
+++ /dev/null
@@ -1,9 +0,0 @@
-comptime {
-    const x = foo + foo;
-    _ = x;
-}
-extern var foo: i32;
-
-// error
-//
-// :2:15: error: unable to resolve comptime value
diff --git a/test/incremental/extern_variable_has_no_type.1.zig b/test/incremental/extern_variable_has_no_type.1.zig
deleted file mode 100644
index f5c31244e5a7bfe9a39f028fd80f40ebcd3dff04..0000000000000000000000000000000000000000
--- a/test/incremental/extern_variable_has_no_type.1.zig
+++ /dev/null
@@ -1,8 +0,0 @@
-export fn entry() void {
-    _ = foo;
-}
-extern var foo;
-
-// error
-//
-// :4:8: error: unable to infer variable type
diff --git a/test/incremental/function_calls.0.zig b/test/incremental/function_calls.0.zig
deleted file mode 100644
index eb388bc49f6b9399ebc8b1f42424f7527f735360..0000000000000000000000000000000000000000
--- a/test/incremental/function_calls.0.zig
+++ /dev/null
@@ -1,12 +0,0 @@
-pub fn main() void {
-    foo();
-    bar();
-}
-fn foo() void {
-    bar();
-    bar();
-}
-fn bar() void {}
-
-// run
-//
diff --git a/test/incremental/function_calls.1.zig b/test/incremental/function_calls.1.zig
deleted file mode 100644
index 60bc061bca50c1e0a18e5bfa0b67c14d1cc06c9f..0000000000000000000000000000000000000000
--- a/test/incremental/function_calls.1.zig
+++ /dev/null
@@ -1,15 +0,0 @@
-pub fn main() void {
-    bar();
-    foo();
-    foo();
-    bar();
-    foo();
-    bar();
-}
-fn foo() void {
-    bar();
-}
-fn bar() void {}
-
-// run
-//
diff --git a/test/incremental/function_calls.2.zig b/test/incremental/function_calls.2.zig
deleted file mode 100644
index ce5627378a891a2f894ac79e7197f566f51aa958..0000000000000000000000000000000000000000
--- a/test/incremental/function_calls.2.zig
+++ /dev/null
@@ -1,14 +0,0 @@
-pub fn main() void {
-    bar();
-    foo();
-    return;
-}
-fn foo() void {
-    bar();
-    bar();
-    bar();
-}
-fn bar() void {}
-
-// run
-//
diff --git a/test/incremental/function_calls.3.zig b/test/incremental/function_calls.3.zig
deleted file mode 100644
index 0316d9042d6b2888e0c7f3a71a2e99fe06bfbc8f..0000000000000000000000000000000000000000
--- a/test/incremental/function_calls.3.zig
+++ /dev/null
@@ -1,10 +0,0 @@
-pub fn main() void {
-    foo(10, 20);
-}
-fn foo(x: u8, y: u8) void {
-    _ = x;
-    _ = y;
-}
-
-// run
-//
diff --git a/test/incremental/function_redeclaration.zig b/test/incremental/function_redeclaration.zig
deleted file mode 100644
index a9664646c98a4dcb5b889de88ddfc60ce8d5d8d5..0000000000000000000000000000000000000000
--- a/test/incremental/function_redeclaration.zig
+++ /dev/null
@@ -1,14 +0,0 @@
-// dummy comment
-fn entry() void {}
-fn entry() void {}
-
-fn foo() void {
-    var foo = 1234;
-}
-
-// error
-//
-// :3:1: error: redeclaration of 'entry'
-// :2:1: note: other declaration here
-// :6:9: error: local shadows declaration of 'foo'
-// :5:1: note: declared here
diff --git a/test/incremental/global_variable_redeclaration.zig b/test/incremental/global_variable_redeclaration.zig
deleted file mode 100644
index 9a0d5939fbffc35ff3da74a6901cf8d69dec421a..0000000000000000000000000000000000000000
--- a/test/incremental/global_variable_redeclaration.zig
+++ /dev/null
@@ -1,8 +0,0 @@
-// dummy comment
-var foo = false;
-var foo = true;
-
-// error
-//
-// :3:1: error: redeclaration of 'foo'
-// :2:1: note: other declaration here
diff --git a/test/incremental/inner_func_accessing_outer_var.zig b/test/incremental/inner_func_accessing_outer_var.zig
deleted file mode 100644
index e30cf58ef84d54e38ecfac903a7e47437d971a68..0000000000000000000000000000000000000000
--- a/test/incremental/inner_func_accessing_outer_var.zig
+++ /dev/null
@@ -1,15 +0,0 @@
-pub fn f() void {
-    var bar: bool = true;
-    const S = struct {
-        fn baz() bool {
-            return bar;
-        }
-    };
-    _ = S;
-}
-
-// error
-//
-// :5:20: error: mutable 'bar' not accessible from here
-// :2:9: note: declared mutable here
-// :3:15: note: crosses namespace boundary here
diff --git a/test/incremental/int_to_ptr.0.zig b/test/incremental/int_to_ptr.0.zig
deleted file mode 100644
index b7c70b90a44ff58c786fa8b18fa3b440caef980f..0000000000000000000000000000000000000000
--- a/test/incremental/int_to_ptr.0.zig
+++ /dev/null
@@ -1,8 +0,0 @@
-pub fn main() void {
-    _ = @intToPtr(*u8, 0);
-}
-
-// error
-// output_mode=Exe
-//
-// :2:24: error: pointer type '*u8' does not allow address zero
diff --git a/test/incremental/int_to_ptr.1.zig b/test/incremental/int_to_ptr.1.zig
deleted file mode 100644
index 72c8c8c9d6f06d8c7d4e4d49219106160beae122..0000000000000000000000000000000000000000
--- a/test/incremental/int_to_ptr.1.zig
+++ /dev/null
@@ -1,7 +0,0 @@
-pub fn main() void {
-    _ = @intToPtr(*u32, 2);
-}
-
-// error
-//
-// :2:25: error: pointer type '*u32' requires aligned address
diff --git a/test/incremental/large_add_function.zig b/test/incremental/large_add_function.zig
deleted file mode 100644
index 8b0e9b879b2f9309f29ef99823f5d26e783124c7..0000000000000000000000000000000000000000
--- a/test/incremental/large_add_function.zig
+++ /dev/null
@@ -1,38 +0,0 @@
-pub fn main() void {
-    assert(add(3, 4) == 791);
-}
-
-fn add(a: u32, b: u32) u32 {
-    const x: u32 = blk: {
-        const c = a + b; // 7
-        const d = a + c; // 10
-        const e = d + b; // 14
-        const f = d + e; // 24
-        const g = e + f; // 38
-        const h = f + g; // 62
-        const i = g + h; // 100
-        const j = i + d; // 110
-        const k = i + j; // 210
-        const l = k + c; // 217
-        const m = l + d; // 227
-        const n = m + e; // 241
-        const o = n + f; // 265
-        const p = o + g; // 303
-        const q = p + h; // 365
-        const r = q + i; // 465
-        const s = r + j; // 575
-        const t = s + k; // 785
-        break :blk t;
-    };
-    const y = x + a; // 788
-    const z = y + a; // 791
-    return z;
-}
-
-fn assert(ok: bool) void {
-    if (!ok) unreachable;
-}
-
-// run
-// target=aarch64-linux,aarch64-macos
-//
diff --git a/test/incremental/llvm/address_space_pointer_access_chaining_pointer_to_optional_array.zig b/test/incremental/llvm/address_space_pointer_access_chaining_pointer_to_optional_array.zig
deleted file mode 100644
index cf43513159d1fb4ffe7e5a913833f2f343578e7e..0000000000000000000000000000000000000000
--- a/test/incremental/llvm/address_space_pointer_access_chaining_pointer_to_optional_array.zig
+++ /dev/null
@@ -1,12 +0,0 @@
-fn entry(a: *addrspace(.gs) ?[1]i32) *addrspace(.gs) i32 {
-    return &a.*.?[0];
-}
-pub fn main() void {
-    _ = entry;
-}
-
-// error
-// output_mode=Exe
-// backend=llvm
-// target=x86_64-linux,x86_64-macos
-//
diff --git a/test/incremental/llvm/address_spaces_pointer_access_chaining_array_pointer.zig b/test/incremental/llvm/address_spaces_pointer_access_chaining_array_pointer.zig
deleted file mode 100644
index 5907c1dad5e961a35d9116f4c1c94a4dc0fbb4da..0000000000000000000000000000000000000000
--- a/test/incremental/llvm/address_spaces_pointer_access_chaining_array_pointer.zig
+++ /dev/null
@@ -1,12 +0,0 @@
-fn entry(a: *addrspace(.gs) [1]i32) *addrspace(.gs) i32 {
-    return &a[0];
-}
-pub fn main() void {
-    _ = entry;
-}
-
-// error
-// output_mode=Exe
-// backend=stage2,llvm
-// target=x86_64-linux,x86_64-macos
-//
diff --git a/test/incremental/llvm/address_spaces_pointer_access_chaining_complex.zig b/test/incremental/llvm/address_spaces_pointer_access_chaining_complex.zig
deleted file mode 100644
index ece0614f73040a8a73e22dd356721b815dc115db..0000000000000000000000000000000000000000
--- a/test/incremental/llvm/address_spaces_pointer_access_chaining_complex.zig
+++ /dev/null
@@ -1,13 +0,0 @@
-const A = struct { a: ?[1]i32 };
-fn entry(a: *addrspace(.gs) [1]A) *addrspace(.gs) i32 {
-    return &a[0].a.?[0];
-}
-pub fn main() void {
-    _ = entry;
-}
-
-// error
-// output_mode=Exe
-// backend=llvm
-// target=x86_64-linux,x86_64-macos
-//
diff --git a/test/incremental/llvm/address_spaces_pointer_access_chaining_struct_pointer.zig b/test/incremental/llvm/address_spaces_pointer_access_chaining_struct_pointer.zig
deleted file mode 100644
index 9175bcbc0ea9165f083ec8973f606ef5baa57040..0000000000000000000000000000000000000000
--- a/test/incremental/llvm/address_spaces_pointer_access_chaining_struct_pointer.zig
+++ /dev/null
@@ -1,13 +0,0 @@
-const A = struct { a: i32 };
-fn entry(a: *addrspace(.gs) A) *addrspace(.gs) i32 {
-    return &a.a;
-}
-pub fn main() void {
-    _ = entry;
-}
-
-// error
-// output_mode=Exe
-// backend=stage2,llvm
-// target=x86_64-linux,x86_64-macos
-//
diff --git a/test/incremental/llvm/any_typed_null_to_any_typed_optional.zig b/test/incremental/llvm/any_typed_null_to_any_typed_optional.zig
deleted file mode 100644
index c155d044976655e1becf111027c00d25edadbb90..0000000000000000000000000000000000000000
--- a/test/incremental/llvm/any_typed_null_to_any_typed_optional.zig
+++ /dev/null
@@ -1,11 +0,0 @@
-pub fn main() void {
-    var a: ?*anyopaque = undefined;
-    a = @as(?usize, null);
-}
-
-// error
-// output_mode=Exe
-// backend=stage2,llvm
-// target=x86_64-linux,x86_64-macos
-//
-// :3:21: error: expected *anyopaque, found ?usize
diff --git a/test/incremental/llvm/blocks.zig b/test/incremental/llvm/blocks.zig
deleted file mode 100644
index c64909c7fea640a33c5fcf793f6ed82fe3189ba6..0000000000000000000000000000000000000000
--- a/test/incremental/llvm/blocks.zig
+++ /dev/null
@@ -1,22 +0,0 @@
-fn assert(ok: bool) void {
-    if (!ok) unreachable;
-}
-
-fn foo(ok: bool) i32 {
-    const val: i32 = blk: {
-        var x: i32 = 1;
-        if (!ok) break :blk x + 9;
-        break :blk x + 19;
-    };
-    return val + 10;
-}
-
-pub fn main() void {
-    assert(foo(false) == 20);
-    assert(foo(true) == 30);
-}
-
-// run
-// backend=stage2,llvm
-// target=x86_64-linux,x86_64-macos
-//
diff --git a/test/incremental/llvm/dereferencing_though_multiple_pointers_with_address_spaces.zig b/test/incremental/llvm/dereferencing_though_multiple_pointers_with_address_spaces.zig
deleted file mode 100644
index 8f3670075717006113252c90086f21059337b61f..0000000000000000000000000000000000000000
--- a/test/incremental/llvm/dereferencing_though_multiple_pointers_with_address_spaces.zig
+++ /dev/null
@@ -1,12 +0,0 @@
-fn entry(a: *addrspace(.fs) *addrspace(.gs) *i32) *i32 {
-    return a.*.*;
-}
-pub fn main() void {
-    _ = entry;
-}
-
-// error
-// output_mode=Exe
-// backend=stage2,llvm
-// target=x86_64-linux,x86_64-macos
-//
diff --git a/test/incremental/llvm/f_segment_address_space_reading_and_writing.zig b/test/incremental/llvm/f_segment_address_space_reading_and_writing.zig
deleted file mode 100644
index 62db92668b4da29b83dc36fdbb531eba4124a882..0000000000000000000000000000000000000000
--- a/test/incremental/llvm/f_segment_address_space_reading_and_writing.zig
+++ /dev/null
@@ -1,48 +0,0 @@
-fn assert(ok: bool) void {
-    if (!ok) unreachable;
-}
-
-fn setFs(value: c_ulong) void {
-    asm volatile (
-        \\syscall
-        :
-        : [number] "{rax}" (158),
-          [code] "{rdi}" (0x1002),
-          [val] "{rsi}" (value),
-        : "rcx", "r11", "memory"
-    );
-}
-
-fn getFs() c_ulong {
-    var result: c_ulong = undefined;
-    asm volatile (
-        \\syscall
-        :
-        : [number] "{rax}" (158),
-          [code] "{rdi}" (0x1003),
-          [ptr] "{rsi}" (@ptrToInt(&result)),
-        : "rcx", "r11", "memory"
-    );
-    return result;
-}
-
-var test_value: u64 = 12345;
-
-pub fn main() void {
-    const orig_fs = getFs();
-
-    setFs(@ptrToInt(&test_value));
-    assert(getFs() == @ptrToInt(&test_value));
-
-    var test_ptr = @intToPtr(*allowzero addrspace(.fs) u64, 0);
-    assert(test_ptr.* == 12345);
-    test_ptr.* = 98765;
-    assert(test_value == 98765);
-
-    setFs(orig_fs);
-}
-
-// run
-// backend=llvm
-// target=x86_64-linux
-//
diff --git a/test/incremental/llvm/for_loop.zig b/test/incremental/llvm/for_loop.zig
deleted file mode 100644
index e7e701aafaa88ddd9617e9b24db34fe27b71133e..0000000000000000000000000000000000000000
--- a/test/incremental/llvm/for_loop.zig
+++ /dev/null
@@ -1,16 +0,0 @@
-fn assert(ok: bool) void {
-    if (!ok) unreachable;
-}
-
-pub fn main() void {
-    var x: u32 = 0;
-    for ("hello") |_| {
-        x += 1;
-    }
-    assert("hello".len == x);
-}
-
-// run
-// backend=stage2,llvm
-// target=x86_64-linux,x86_64-macos
-//
diff --git a/test/incremental/llvm/hello_world.zig b/test/incremental/llvm/hello_world.zig
deleted file mode 100644
index 4243191b0fb7a82da70c8f00ad28e72439b968f1..0000000000000000000000000000000000000000
--- a/test/incremental/llvm/hello_world.zig
+++ /dev/null
@@ -1,12 +0,0 @@
-extern fn puts(s: [*:0]const u8) c_int;
-
-pub fn main() void {
-    _ = puts("hello world!");
-}
-
-// run
-// backend=llvm
-// target=x86_64-linux,x86_64-macos
-//
-// hello world!
-//
diff --git a/test/incremental/llvm/invalid_address_space_coercion.zig b/test/incremental/llvm/invalid_address_space_coercion.zig
deleted file mode 100644
index 6b72f1d5a8ada2bebfecc79b0b780d9af20eb3d8..0000000000000000000000000000000000000000
--- a/test/incremental/llvm/invalid_address_space_coercion.zig
+++ /dev/null
@@ -1,13 +0,0 @@
-fn entry(a: *addrspace(.gs) i32) *i32 {
-    return a;
-}
-pub fn main() void {
-    _ = entry;
-}
-
-// error
-// output_mode=Exe
-// backend=stage2,llvm
-// target=x86_64-linux,x86_64-macos
-//
-// :2:12: error: expected *i32, found *addrspace(.gs) i32
diff --git a/test/incremental/llvm/invalid_pointer_keeps_address_space_when_taking_address_of_dereference.zig b/test/incremental/llvm/invalid_pointer_keeps_address_space_when_taking_address_of_dereference.zig
deleted file mode 100644
index 26f68ce7895207a301eb192fc679156573e9d39d..0000000000000000000000000000000000000000
--- a/test/incremental/llvm/invalid_pointer_keeps_address_space_when_taking_address_of_dereference.zig
+++ /dev/null
@@ -1,13 +0,0 @@
-fn entry(a: *addrspace(.gs) i32) *i32 {
-    return &a.*;
-}
-pub fn main() void {
-    _ = entry;
-}
-
-// error
-// output_mode=Exe
-// backend=stage2,llvm
-// target=x86_64-linux,x86_64-macos
-//
-// :2:12: error: expected *i32, found *addrspace(.gs) i32
diff --git a/test/incremental/llvm/nested_blocks.zig b/test/incremental/llvm/nested_blocks.zig
deleted file mode 100644
index 47b6c5069bffb04c825bd70c695eaca0d7854269..0000000000000000000000000000000000000000
--- a/test/incremental/llvm/nested_blocks.zig
+++ /dev/null
@@ -1,24 +0,0 @@
-fn assert(ok: bool) void {
-    if (!ok) unreachable;
-}
-
-fn foo(ok: bool) i32 {
-    var val: i32 = blk: {
-        const val2: i32 = another: {
-            if (!ok) break :blk 10;
-            break :another 10;
-        };
-        break :blk val2 + 10;
-    };
-    return val;
-}
-
-pub fn main() void {
-    assert(foo(false) == 10);
-    assert(foo(true) == 20);
-}
-
-// run
-// backend=stage2, llvm
-// target=x86_64-linux,x86_64-macos
-//
diff --git a/test/incremental/llvm/optionals.zig b/test/incremental/llvm/optionals.zig
deleted file mode 100644
index 7d52fc0f17d73b201c3aad46adf461cfe0fe5de2..0000000000000000000000000000000000000000
--- a/test/incremental/llvm/optionals.zig
+++ /dev/null
@@ -1,45 +0,0 @@
-fn assert(ok: bool) void {
-    if (!ok) unreachable;
-}
-
-pub fn main() void {
-    var opt_val: ?i32 = 10;
-    var null_val: ?i32 = null;
-
-    var val1: i32 = opt_val.?;
-    const val1_1: i32 = opt_val.?;
-    var ptr_val1 = &(opt_val.?);
-    const ptr_val1_1 = &(opt_val.?);
-
-    var val2: i32 = null_val orelse 20;
-    const val2_2: i32 = null_val orelse 20;
-
-    var value: i32 = 20;
-    var ptr_val2 = &(null_val orelse value);
-
-    const val3 = opt_val orelse 30;
-    var val3_var = opt_val orelse 30;
-
-    assert(val1 == 10);
-    assert(val1_1 == 10);
-    assert(ptr_val1.* == 10);
-    assert(ptr_val1_1.* == 10);
-
-    assert(val2 == 20);
-    assert(val2_2 == 20);
-    assert(ptr_val2.* == 20);
-
-    assert(val3 == 10);
-    assert(val3_var == 10);
-
-    (null_val orelse val2) = 1234;
-    assert(val2 == 1234);
-
-    (opt_val orelse val2) = 5678;
-    assert(opt_val.? == 5678);
-}
-
-// run
-// backend=llvm
-// target=x86_64-linux,x86_64-macos
-//
diff --git a/test/incremental/llvm/pointer_keeps_address_space.zig b/test/incremental/llvm/pointer_keeps_address_space.zig
deleted file mode 100644
index bfd40566f840e493e335031ae44b30c7059e9cf0..0000000000000000000000000000000000000000
--- a/test/incremental/llvm/pointer_keeps_address_space.zig
+++ /dev/null
@@ -1,12 +0,0 @@
-fn entry(a: *addrspace(.gs) i32) *addrspace(.gs) i32 {
-    return a;
-}
-pub fn main() void {
-    _ = entry;
-}
-
-// error
-// output_mode=Exe
-// backend=stage2,llvm
-// target=x86_64-linux,x86_64-macos
-//
diff --git a/test/incremental/llvm/pointer_keeps_address_space_when_taking_address_of_dereference.zig b/test/incremental/llvm/pointer_keeps_address_space_when_taking_address_of_dereference.zig
deleted file mode 100644
index 8114e86c5da0b836592fbb851fc82d9d0c0ea56c..0000000000000000000000000000000000000000
--- a/test/incremental/llvm/pointer_keeps_address_space_when_taking_address_of_dereference.zig
+++ /dev/null
@@ -1,12 +0,0 @@
-fn entry(a: *addrspace(.gs) i32) *addrspace(.gs) i32 {
-    return &a.*;
-}
-pub fn main() void {
-    _ = entry;
-}
-
-// error
-// output_mode=Exe
-// backend=stage2,llvm
-// target=x86_64-linux,x86_64-macos
-//
diff --git a/test/incremental/llvm/pointer_to_explicit_generic_address_space_coerces_to_implicit_pointer.zig b/test/incremental/llvm/pointer_to_explicit_generic_address_space_coerces_to_implicit_pointer.zig
deleted file mode 100644
index 78bc3e4bd6f42e5babba073ffa042ce04fffb071..0000000000000000000000000000000000000000
--- a/test/incremental/llvm/pointer_to_explicit_generic_address_space_coerces_to_implicit_pointer.zig
+++ /dev/null
@@ -1,12 +0,0 @@
-fn entry(a: *addrspace(.generic) i32) *i32 {
-    return a;
-}
-pub fn main() void {
-    _ = entry;
-}
-
-// error
-// output_mode=Exe
-// backend=stage2,llvm
-// target=x86_64-linux,x86_64-macos
-//
diff --git a/test/incremental/llvm/pointer_with_different_address_spaces.zig b/test/incremental/llvm/pointer_with_different_address_spaces.zig
deleted file mode 100644
index 8fbd8b07cfccbcd8f8897881ca38d868c68eff4b..0000000000000000000000000000000000000000
--- a/test/incremental/llvm/pointer_with_different_address_spaces.zig
+++ /dev/null
@@ -1,13 +0,0 @@
-fn entry(a: *addrspace(.gs) i32) *addrspace(.fs) i32 {
-    return a;
-}
-pub fn main() void {
-    _ = entry;
-}
-
-// error
-// output_mode=Exe
-// backend=stage2,llvm
-// target=x86_64-linux,x86_64-macos
-//
-// :2:12: error: expected *addrspace(.fs) i32, found *addrspace(.gs) i32
diff --git a/test/incremental/llvm/pointers_with_different_address_spaces.zig b/test/incremental/llvm/pointers_with_different_address_spaces.zig
deleted file mode 100644
index 39e5e6a6d176e58fd8237a425e06a9517edf3590..0000000000000000000000000000000000000000
--- a/test/incremental/llvm/pointers_with_different_address_spaces.zig
+++ /dev/null
@@ -1,13 +0,0 @@
-fn entry(a: ?*addrspace(.gs) i32) *i32 {
-    return a.?;
-}
-pub fn main() void {
-    _ = entry;
-}
-
-// error
-// output_mode=Exe
-// backend=stage2,llvm
-// target=x86_64-linux,x86_64-macos
-//
-// :2:13: error: expected *i32, found *addrspace(.gs) i32
diff --git a/test/incremental/llvm/rem.zig b/test/incremental/llvm/rem.zig
deleted file mode 100644
index 9804338ea6f946fbac06a3e8737929002ab5bf0b..0000000000000000000000000000000000000000
--- a/test/incremental/llvm/rem.zig
+++ /dev/null
@@ -1,15 +0,0 @@
-fn assert(ok: bool) void {
-    if (!ok) unreachable;
-}
-fn rem(lhs: i32, rhs: i32, expected: i32) bool {
-    return @rem(lhs, rhs) == expected;
-}
-pub fn main() void {
-    assert(rem(-5, 3, -2));
-    assert(rem(5, 3, 2));
-}
-
-// run
-// backend=stage2,llvm
-// target=x86_64-linux,x86_64-macos
-//
diff --git a/test/incremental/llvm/shift_right_plus_left.0.zig b/test/incremental/llvm/shift_right_plus_left.0.zig
deleted file mode 100644
index 23b733c4934ba1dc65ea50ecac37ef447142104a..0000000000000000000000000000000000000000
--- a/test/incremental/llvm/shift_right_plus_left.0.zig
+++ /dev/null
@@ -1,12 +0,0 @@
-pub fn main() void {
-    var i: u32 = 16;
-    assert(i >> 1, 8);
-}
-fn assert(a: u32, b: u32) void {
-    if (a != b) unreachable;
-}
-
-// run
-// backend=llvm
-// target=x86_64-linux,x86_64-macos
-//
diff --git a/test/incremental/llvm/shift_right_plus_left.1.zig b/test/incremental/llvm/shift_right_plus_left.1.zig
deleted file mode 100644
index 994b67b9d0bc4c8da0c1c344503885c2a8a0dd16..0000000000000000000000000000000000000000
--- a/test/incremental/llvm/shift_right_plus_left.1.zig
+++ /dev/null
@@ -1,10 +0,0 @@
-pub fn main() void {
-    var i: u32 = 16;
-    assert(i << 1, 32);
-}
-fn assert(a: u32, b: u32) void {
-    if (a != b) unreachable;
-}
-
-// run
-//
diff --git a/test/incremental/llvm/simple_addition_and_subtraction.zig b/test/incremental/llvm/simple_addition_and_subtraction.zig
deleted file mode 100644
index 8a6f419f4a5c64649aa3f7618394c0264b667304..0000000000000000000000000000000000000000
--- a/test/incremental/llvm/simple_addition_and_subtraction.zig
+++ /dev/null
@@ -1,20 +0,0 @@
-fn add(a: i32, b: i32) i32 {
-    return a + b;
-}
-
-pub fn main() void {
-    var a: i32 = -5;
-    const x = add(a, 7);
-    var y = add(2, 0);
-    y -= x;
-    assert(y == 0);
-}
-
-fn assert(ok: bool) void {
-    if (!ok) unreachable;
-}
-
-// run
-// backend=stage2,llvm
-// target=x86_64-linux,x86_64-macos
-//
diff --git a/test/incremental/llvm/simple_if_statement.zig b/test/incremental/llvm/simple_if_statement.zig
deleted file mode 100644
index 73cf08cda2b45477f87b222dbf5b46cadd6917d9..0000000000000000000000000000000000000000
--- a/test/incremental/llvm/simple_if_statement.zig
+++ /dev/null
@@ -1,16 +0,0 @@
-fn add(a: i32, b: i32) i32 {
-    return a + b;
-}
-
-fn assert(ok: bool) void {
-    if (!ok) unreachable;
-}
-
-pub fn main() void {
-    assert(add(1, 2) == 3);
-}
-
-// run
-// backend=stage2,llvm
-// target=x86_64-linux,x86_64-macos
-//
diff --git a/test/incremental/llvm/while_loops.zig b/test/incremental/llvm/while_loops.zig
deleted file mode 100644
index 3b9276cf7f31fd3fc22e5db640533026ce6f0834..0000000000000000000000000000000000000000
--- a/test/incremental/llvm/while_loops.zig
+++ /dev/null
@@ -1,18 +0,0 @@
-fn assert(ok: bool) void {
-    if (!ok) unreachable;
-}
-
-pub fn main() void {
-    var sum: u32 = 0;
-    var i: u32 = 0;
-    while (i < 5) : (i += 1) {
-        sum += i;
-    }
-    assert(sum == 10);
-    assert(i == 5);
-}
-
-// run
-// backend=stage2,llvm
-// target=x86_64-linux,x86_64-macos
-//
diff --git a/test/incremental/lower_unnamed_consts_structs.0.zig b/test/incremental/lower_unnamed_consts_structs.0.zig
deleted file mode 100644
index 31232996461ac972b886c5bb30b9c91ff6840d52..0000000000000000000000000000000000000000
--- a/test/incremental/lower_unnamed_consts_structs.0.zig
+++ /dev/null
@@ -1,25 +0,0 @@
-const Foo = struct {
-    a: u8,
-    b: u32,
-
-    fn first(self: *Foo) u8 {
-        return self.a;
-    }
-
-    fn second(self: *Foo) u32 {
-        return self.b;
-    }
-};
-
-pub fn main() void {
-    var foo = Foo{ .a = 1, .b = 5 };
-    assert(foo.first() == 1);
-    assert(foo.second() == 5);
-}
-
-fn assert(ok: bool) void {
-    if (!ok) unreachable;
-}
-
-// run
-//
diff --git a/test/incremental/lower_unnamed_consts_structs.1.zig b/test/incremental/lower_unnamed_consts_structs.1.zig
deleted file mode 100644
index 37afdc8a09c0f08f0351a4d0201416e17455b07b..0000000000000000000000000000000000000000
--- a/test/incremental/lower_unnamed_consts_structs.1.zig
+++ /dev/null
@@ -1,35 +0,0 @@
-const Foo = struct {
-    a: u8,
-    b: u32,
-
-    fn first(self: *Foo) u8 {
-        return self.a;
-    }
-
-    fn second(self: *Foo) u32 {
-        return self.b;
-    }
-};
-
-pub fn main() void {
-    var foo = Foo{ .a = 1, .b = 5 };
-    assert(foo.first() == 1);
-    assert(foo.second() == 5);
-
-    foo.a = 10;
-    foo.b = 255;
-
-    assert(foo.first() == 10);
-    assert(foo.second() == 255);
-
-    var foo2 = Foo{ .a = 15, .b = 255 };
-    assert(foo2.first() == 15);
-    assert(foo2.second() == 255);
-}
-
-fn assert(ok: bool) void {
-    if (!ok) unreachable;
-}
-
-// run
-//
diff --git a/test/incremental/lower_unnamed_consts_structs.2.zig b/test/incremental/lower_unnamed_consts_structs.2.zig
deleted file mode 100644
index b437c4a030aae4842b371abef19074f27b76d556..0000000000000000000000000000000000000000
--- a/test/incremental/lower_unnamed_consts_structs.2.zig
+++ /dev/null
@@ -1,25 +0,0 @@
-const Foo = struct {
-    a: u8,
-    b: u32,
-
-    fn first(self: *Foo) u8 {
-        return self.a;
-    }
-
-    fn second(self: *Foo) u32 {
-        return self.b;
-    }
-};
-
-pub fn main() void {
-    var foo2 = Foo{ .a = 15, .b = 255 };
-    assert(foo2.first() == 15);
-    assert(foo2.second() == 255);
-}
-
-fn assert(ok: bool) void {
-    if (!ok) unreachable;
-}
-
-// run
-//
diff --git a/test/incremental/merge_error_sets.0.zig b/test/incremental/merge_error_sets.0.zig
deleted file mode 100644
index f1f3b968830988d3d8e6105f1bd97d49345a8d08..0000000000000000000000000000000000000000
--- a/test/incremental/merge_error_sets.0.zig
+++ /dev/null
@@ -1,18 +0,0 @@
-pub fn main() void {
-    const E = error{ A, B, D } || error{ A, B, C };
-    E.A catch {};
-    E.B catch {};
-    E.C catch {};
-    E.D catch {};
-    const E2 = error{ X, Y } || @TypeOf(error.Z);
-    E2.X catch {};
-    E2.Y catch {};
-    E2.Z catch {};
-    assert(anyerror || error{Z} == anyerror);
-}
-fn assert(b: bool) void {
-    if (!b) unreachable;
-}
-
-// run
-//
diff --git a/test/incremental/merge_error_sets.1.zig b/test/incremental/merge_error_sets.1.zig
deleted file mode 100644
index 81c1cad134ec58f46201197a827608b88389f344..0000000000000000000000000000000000000000
--- a/test/incremental/merge_error_sets.1.zig
+++ /dev/null
@@ -1,9 +0,0 @@
-pub fn main() void {
-    const z = true || false;
-    _ = z;
-}
-
-// error
-//
-// :2:15: error: expected error set type, found 'bool'
-// :2:20: note: '||' merges error sets; 'or' performs boolean OR
diff --git a/test/incremental/multiplying_numbers_at_runtime_and_comptime.0.zig b/test/incremental/multiplying_numbers_at_runtime_and_comptime.0.zig
deleted file mode 100644
index f113928982fbeedd44b3eab66d73c46bba0b3721..0000000000000000000000000000000000000000
--- a/test/incremental/multiplying_numbers_at_runtime_and_comptime.0.zig
+++ /dev/null
@@ -1,11 +0,0 @@
-pub fn main() void {
-    mul(3, 4);
-}
-
-fn mul(a: u32, b: u32) void {
-    if (a * b != 12) unreachable;
-}
-
-// run
-// target=x86_64-linux,x86_64-macos
-//
diff --git a/test/incremental/multiplying_numbers_at_runtime_and_comptime.1.zig b/test/incremental/multiplying_numbers_at_runtime_and_comptime.1.zig
deleted file mode 100644
index 1dff884900dcf2811722ea7a9cc6d99484d0f913..0000000000000000000000000000000000000000
--- a/test/incremental/multiplying_numbers_at_runtime_and_comptime.1.zig
+++ /dev/null
@@ -1,12 +0,0 @@
-pub fn main() void {
-    if (x - 12 != 0) unreachable;
-}
-
-fn mul(a: u32, b: u32) u32 {
-    return a * b;
-}
-
-const x = mul(3, 4);
-
-// run
-//
diff --git a/test/incremental/multiplying_numbers_at_runtime_and_comptime.2.zig b/test/incremental/multiplying_numbers_at_runtime_and_comptime.2.zig
deleted file mode 100644
index 31093729baa7924f2f6461d8049ad5e2f40a2ba5..0000000000000000000000000000000000000000
--- a/test/incremental/multiplying_numbers_at_runtime_and_comptime.2.zig
+++ /dev/null
@@ -1,12 +0,0 @@
-pub fn main() void {
-    var x: usize = 5;
-    const y = mul(2, 3, x);
-    if (y - 30 != 0) unreachable;
-}
-
-inline fn mul(a: usize, b: usize, c: usize) usize {
-    return a * b * c;
-}
-
-// run
-//
diff --git a/test/incremental/non_leaf_functions.zig b/test/incremental/non_leaf_functions.zig
deleted file mode 100644
index cb1737130e0e2cebd51b96e1c11ca8d8f7ee799f..0000000000000000000000000000000000000000
--- a/test/incremental/non_leaf_functions.zig
+++ /dev/null
@@ -1,12 +0,0 @@
-pub fn main() void {
-    foo();
-}
-
-fn foo() void {
-    bar();
-}
-
-fn bar() void {}
-
-// run
-//
diff --git a/test/incremental/optional_payload.0.zig b/test/incremental/optional_payload.0.zig
deleted file mode 100644
index 65296875ff1c27542bf6ee87b3e66d720b023cf5..0000000000000000000000000000000000000000
--- a/test/incremental/optional_payload.0.zig
+++ /dev/null
@@ -1,19 +0,0 @@
-pub fn main() void {
-    var x: u32 = undefined;
-    const maybe_x = byPtr(&x);
-    assert(maybe_x != null);
-    maybe_x.?.* = 123;
-    assert(x == 123);
-}
-
-fn byPtr(x: *u32) ?*u32 {
-    return x;
-}
-
-fn assert(ok: bool) void {
-    if (!ok) unreachable;
-}
-
-// run
-// target=x86_64-linux,x86_64-macos
-//
diff --git a/test/incremental/optional_payload.1.zig b/test/incremental/optional_payload.1.zig
deleted file mode 100644
index 2d4dafffb9bdb898c20465beba6ec86a7ef54985..0000000000000000000000000000000000000000
--- a/test/incremental/optional_payload.1.zig
+++ /dev/null
@@ -1,17 +0,0 @@
-pub fn main() void {
-    var x: u32 = undefined;
-    const maybe_x = byPtr(&x);
-    assert(maybe_x == null);
-}
-
-fn byPtr(x: *u32) ?*u32 {
-    _ = x;
-    return null;
-}
-
-fn assert(ok: bool) void {
-    if (!ok) unreachable;
-}
-
-// run
-//
diff --git a/test/incremental/optional_payload.2.zig b/test/incremental/optional_payload.2.zig
deleted file mode 100644
index 608310923bad2f4a376c63f6673c7f66c2275679..0000000000000000000000000000000000000000
--- a/test/incremental/optional_payload.2.zig
+++ /dev/null
@@ -1,18 +0,0 @@
-pub fn main() void {
-    var x: u8 = undefined;
-    const maybe_x = byPtr(&x);
-    assert(maybe_x != null);
-    maybe_x.?.* = 255;
-    assert(x == 255);
-}
-
-fn byPtr(x: *u8) ?*u8 {
-    return x;
-}
-
-fn assert(ok: bool) void {
-    if (!ok) unreachable;
-}
-
-// run
-//
diff --git a/test/incremental/optional_payload.3.zig b/test/incremental/optional_payload.3.zig
deleted file mode 100644
index b81ec398c7a28ed88b5dab7295fcbf9fafa19c83..0000000000000000000000000000000000000000
--- a/test/incremental/optional_payload.3.zig
+++ /dev/null
@@ -1,18 +0,0 @@
-pub fn main() void {
-    var x: i8 = undefined;
-    const maybe_x = byPtr(&x);
-    assert(maybe_x != null);
-    maybe_x.?.* = -1;
-    assert(x == -1);
-}
-
-fn byPtr(x: *i8) ?*i8 {
-    return x;
-}
-
-fn assert(ok: bool) void {
-    if (!ok) unreachable;
-}
-
-// run
-//
diff --git a/test/incremental/orelse_at_comptime.0.zig b/test/incremental/orelse_at_comptime.0.zig
deleted file mode 100644
index 5397ca3b0afae077fb60745b35c3011576c8a49d..0000000000000000000000000000000000000000
--- a/test/incremental/orelse_at_comptime.0.zig
+++ /dev/null
@@ -1,11 +0,0 @@
-pub fn main() void {
-    const i: ?u64 = 0;
-    const result = i orelse 5;
-    assert(result == 0);
-}
-fn assert(b: bool) void {
-    if (!b) unreachable;
-}
-
-// run
-//
diff --git a/test/incremental/orelse_at_comptime.1.zig b/test/incremental/orelse_at_comptime.1.zig
deleted file mode 100644
index 7d4fcd3178a34fc251f78f49b54857c759dc9254..0000000000000000000000000000000000000000
--- a/test/incremental/orelse_at_comptime.1.zig
+++ /dev/null
@@ -1,11 +0,0 @@
-pub fn main() void {
-    const i: ?u64 = null;
-    const result = i orelse 5;
-    assert(result == 5);
-}
-fn assert(b: bool) void {
-    if (!b) unreachable;
-}
-
-// run
-//
diff --git a/test/incremental/passing_u0_to_function.zig b/test/incremental/passing_u0_to_function.zig
deleted file mode 100644
index f84c30be8a4128afa10d50a576ad2600bc8ad5a0..0000000000000000000000000000000000000000
--- a/test/incremental/passing_u0_to_function.zig
+++ /dev/null
@@ -1,9 +0,0 @@
-pub fn main() void {
-    doNothing(0);
-}
-fn doNothing(arg: u0) void {
-    _ = arg;
-}
-
-// run
-//
diff --git a/test/incremental/plan9/exit.zig b/test/incremental/plan9/exit.zig
deleted file mode 100644
index 735818fb8336c564521926398a7f7d57e7607c07..0000000000000000000000000000000000000000
--- a/test/incremental/plan9/exit.zig
+++ /dev/null
@@ -1,5 +0,0 @@
-pub fn main() void {}
-
-// run
-// target=x86_64-plan9,aarch64-plan9
-//
diff --git a/test/incremental/plan9/hello_world_with_updates.0.zig b/test/incremental/plan9/hello_world_with_updates.0.zig
deleted file mode 100644
index 7e7c3732518c776f31450f33083af7289c7f6e19..0000000000000000000000000000000000000000
--- a/test/incremental/plan9/hello_world_with_updates.0.zig
+++ /dev/null
@@ -1,28 +0,0 @@
-pub fn main() void {
-    const str = "Hello World!\n";
-    asm volatile (
-        \\push $0
-        \\push %%r10
-        \\push %%r11
-        \\push $1
-        \\push $0
-        \\syscall
-        \\pop %%r11
-        \\pop %%r11
-        \\pop %%r11
-        \\pop %%r11
-        \\pop %%r11
-        :
-        // pwrite
-        : [syscall_number] "{rbp}" (51),
-          [hey] "{r11}" (@ptrToInt(str)),
-          [strlen] "{r10}" (str.len),
-        : "rcx", "rbp", "r11", "memory"
-    );
-}
-
-// run
-// target=x86_64-plan9
-//
-// Hello World
-//
diff --git a/test/incremental/plan9/hello_world_with_updates.1.zig b/test/incremental/plan9/hello_world_with_updates.1.zig
deleted file mode 100644
index 4111a8dc08738a33687e328cb75e92c3c9112d98..0000000000000000000000000000000000000000
--- a/test/incremental/plan9/hello_world_with_updates.1.zig
+++ /dev/null
@@ -1,10 +0,0 @@
-const std = @import("std");
-pub fn main() void {
-    const str = "Hello World!\n";
-    _ = std.os.plan9.pwrite(1, str, str.len, 0);
-}
-
-// run
-//
-// Hello World
-//
diff --git a/test/incremental/recursive_fibonacci.zig b/test/incremental/recursive_fibonacci.zig
deleted file mode 100644
index 4e284e3fc1807365381c1fd4098ae8ffc31298d5..0000000000000000000000000000000000000000
--- a/test/incremental/recursive_fibonacci.zig
+++ /dev/null
@@ -1,24 +0,0 @@
-pub fn main() void {
-    assert(fib(0) == 0);
-    assert(fib(1) == 1);
-    assert(fib(2) == 1);
-    assert(fib(3) == 2);
-    assert(fib(10) == 55);
-    assert(fib(20) == 6765);
-}
-
-fn fib(n: u32) u32 {
-    if (n < 2) {
-        return n;
-    } else {
-        return fib(n - 2) + fib(n - 1);
-    }
-}
-
-fn assert(ok: bool) void {
-    if (!ok) unreachable;
-}
-
-// run
-// target=arm-linux,x86_64-linux,x86_64-macos,wasm32-wasi
-//
diff --git a/test/incremental/recursive_inline_function.0.zig b/test/incremental/recursive_inline_function.0.zig
deleted file mode 100644
index c8333c906516bccd45128a99106fc510a0ea4d9f..0000000000000000000000000000000000000000
--- a/test/incremental/recursive_inline_function.0.zig
+++ /dev/null
@@ -1,12 +0,0 @@
-pub fn main() void {
-    const y = fibonacci(7);
-    if (y - 21 != 0) unreachable;
-}
-
-inline fn fibonacci(n: usize) usize {
-    if (n <= 2) return n;
-    return fibonacci(n - 2) + fibonacci(n - 1);
-}
-
-// run
-//
diff --git a/test/incremental/recursive_inline_function.1.zig b/test/incremental/recursive_inline_function.1.zig
deleted file mode 100644
index 139da1c371292c2cbf196d87c3cb80c4fcd3315b..0000000000000000000000000000000000000000
--- a/test/incremental/recursive_inline_function.1.zig
+++ /dev/null
@@ -1,16 +0,0 @@
-// This additionally tests that the compile error reports the correct source location.
-// Without storing source locations relative to the owner decl, the compile error
-// here would be off by 2 bytes (from the "7" -> "999").
-pub fn main() void {
-    const y = fibonacci(999);
-    if (y - 21 != 0) unreachable;
-}
-
-inline fn fibonacci(n: usize) usize {
-    if (n <= 2) return n;
-    return fibonacci(n - 2) + fibonacci(n - 1);
-}
-
-// error
-//
-// :11:21: error: evaluation exceeded 1000 backwards branches
diff --git a/test/incremental/redundant_comptime.0.zig b/test/incremental/redundant_comptime.0.zig
deleted file mode 100644
index c1ecbf7acec79ac1c60f9f09780e317b609ccd12..0000000000000000000000000000000000000000
--- a/test/incremental/redundant_comptime.0.zig
+++ /dev/null
@@ -1,7 +0,0 @@
-pub fn main() void {
-    var a: comptime u32 = 0;
-}
-
-// error
-//
-// :2:12: error: redundant comptime keyword in already comptime scope
diff --git a/test/incremental/redundant_comptime.1.zig b/test/incremental/redundant_comptime.1.zig
deleted file mode 100644
index 79226ae8a6b2799dc4e87cfad71219f09a47fc34..0000000000000000000000000000000000000000
--- a/test/incremental/redundant_comptime.1.zig
+++ /dev/null
@@ -1,9 +0,0 @@
-pub fn main() void {
-    comptime {
-        var a: u32 = comptime 0;
-    }
-}
-
-// error
-//
-// :3:22: error: redundant comptime keyword in already comptime scope
diff --git a/test/incremental/returns_in_try.zig b/test/incremental/returns_in_try.zig
deleted file mode 100644
index de5a9a3258288c1357d96172f1e8458abe45d4d1..0000000000000000000000000000000000000000
--- a/test/incremental/returns_in_try.zig
+++ /dev/null
@@ -1,16 +0,0 @@
-pub fn main() !void {
-    try a();
-    try b();
-}
-
-pub fn a() !void {
-    defer try b();
-}
-pub fn b() !void {
-    defer return a();
-}
-
-// error
-//
-// :7:11: error: 'try' not allowed inside defer expression
-// :10:11: error: cannot return from defer expression
diff --git a/test/incremental/riscv64-linux/hello_world_with_updates.0.zig b/test/incremental/riscv64-linux/hello_world_with_updates.0.zig
deleted file mode 100644
index dd119fd1f4366a089f62a796daf96cf437a43f04..0000000000000000000000000000000000000000
--- a/test/incremental/riscv64-linux/hello_world_with_updates.0.zig
+++ /dev/null
@@ -1,21 +0,0 @@
-pub fn main() void {
-    print();
-}
-
-fn print() void {
-    asm volatile ("ecall"
-        :
-        : [number] "{a7}" (64),
-          [arg1] "{a0}" (1),
-          [arg2] "{a1}" (@ptrToInt("Hello, World!\n")),
-          [arg3] "{a2}" ("Hello, World!\n".len),
-        : "rcx", "r11", "memory"
-    );
-    return;
-}
-
-// run
-// target=riscv64-linux
-//
-// Hello, World!
-//
diff --git a/test/incremental/riscv64-linux/hello_world_with_updates.1.zig b/test/incremental/riscv64-linux/hello_world_with_updates.1.zig
deleted file mode 100644
index 26718738a9ed459aeb650db31628ad2f2b7de0c6..0000000000000000000000000000000000000000
--- a/test/incremental/riscv64-linux/hello_world_with_updates.1.zig
+++ /dev/null
@@ -1,27 +0,0 @@
-pub fn main() void {
-    print();
-    print();
-    print();
-    print();
-}
-
-fn print() void {
-    asm volatile ("ecall"
-        :
-        : [number] "{a7}" (64),
-          [arg1] "{a0}" (1),
-          [arg2] "{a1}" (@ptrToInt("Hello, World!\n")),
-          [arg3] "{a2}" ("Hello, World!\n".len),
-        : "rcx", "r11", "memory"
-    );
-    return;
-}
-
-// run
-// target=riscv64-linux
-//
-// Hello, World!
-// Hello, World!
-// Hello, World!
-// Hello, World!
-//
diff --git a/test/incremental/runtime_bitwise_and.zig b/test/incremental/runtime_bitwise_and.zig
deleted file mode 100644
index 3ba3d3124cc400d5ccd309f392c3fd2c593732e3..0000000000000000000000000000000000000000
--- a/test/incremental/runtime_bitwise_and.zig
+++ /dev/null
@@ -1,16 +0,0 @@
-pub fn main() void {
-    var i: u32 = 10;
-    var j: u32 = 11;
-    assert(i & 1 == 0);
-    assert(j & 1 == 1);
-    var m1: u32 = 0b1111;
-    var m2: u32 = 0b0000;
-    assert(m1 & 0b1010 == 0b1010);
-    assert(m2 & 0b1010 == 0b0000);
-}
-fn assert(b: bool) void {
-    if (!b) unreachable;
-}
-
-// run
-//
diff --git a/test/incremental/runtime_bitwise_or.zig b/test/incremental/runtime_bitwise_or.zig
deleted file mode 100644
index b97c2acf0228a3314eccb4ab859eee3a7dc2d77b..0000000000000000000000000000000000000000
--- a/test/incremental/runtime_bitwise_or.zig
+++ /dev/null
@@ -1,16 +0,0 @@
-pub fn main() void {
-    var i: u32 = 10;
-    var j: u32 = 11;
-    assert(i | 1 == 11);
-    assert(j | 1 == 11);
-    var m1: u32 = 0b1111;
-    var m2: u32 = 0b0000;
-    assert(m1 | 0b1010 == 0b1111);
-    assert(m2 | 0b1010 == 0b1010);
-}
-fn assert(b: bool) void {
-    if (!b) unreachable;
-}
-
-// run
-//
diff --git a/test/incremental/save_function_return_values_in_callee_preserved_register.zig b/test/incremental/save_function_return_values_in_callee_preserved_register.zig
deleted file mode 100644
index a2019038082b4f978de13ebfef6a1439ccbb79f7..0000000000000000000000000000000000000000
--- a/test/incremental/save_function_return_values_in_callee_preserved_register.zig
+++ /dev/null
@@ -1,22 +0,0 @@
-pub fn main() void {
-    assert(foo() == 43);
-}
-
-fn foo() u32 {
-    return bar() + baz(42);
-}
-
-fn bar() u32 {
-    return 1;
-}
-
-fn baz(x: u32) u32 {
-    return x;
-}
-
-fn assert(ok: bool) void {
-    if (!ok) unreachable;
-}
-
-// run
-//
diff --git a/test/incremental/setting_an_address_space_on_a_local_variable.zig b/test/incremental/setting_an_address_space_on_a_local_variable.zig
deleted file mode 100644
index dad282dc318cdf22005f31b55a5eda38bd8018a4..0000000000000000000000000000000000000000
--- a/test/incremental/setting_an_address_space_on_a_local_variable.zig
+++ /dev/null
@@ -1,8 +0,0 @@
-export fn entry() i32 {
-    var foo: i32 addrspace(".general") = 1234;
-    return foo;
-}
-
-// error
-//
-// :2:28: error: cannot set address space of local variable 'foo'
diff --git a/test/incremental/sparcv9-linux/hello_world.zig b/test/incremental/sparcv9-linux/hello_world.zig
deleted file mode 100644
index 327a8c56ad64fb22e31dc190c076b0886cd6cdde..0000000000000000000000000000000000000000
--- a/test/incremental/sparcv9-linux/hello_world.zig
+++ /dev/null
@@ -1,27 +0,0 @@
-const msg = "Hello, World!\n";
-
-pub export fn _start() noreturn {
-    asm volatile ("ta 0x6d"
-        :
-        : [number] "{g1}" (4),
-          [arg1] "{o0}" (1),
-          [arg2] "{o1}" (@ptrToInt(msg)),
-          [arg3] "{o2}" (msg.len),
-        : "o0", "o1", "o2", "o3", "o4", "o5", "o6", "o7", "memory"
-    );
-
-    asm volatile ("ta 0x6d"
-        :
-        : [number] "{g1}" (1),
-          [arg1] "{o0}" (0),
-        : "o0", "o1", "o2", "o3", "o4", "o5", "o6", "o7", "memory"
-    );
-
-    unreachable;
-}
-
-// run
-// target=sparcv9-linux
-//
-// Hello, World!
-//
diff --git a/test/incremental/try_in_comptime_in_struct_in_test.zig b/test/incremental/try_in_comptime_in_struct_in_test.zig
deleted file mode 100644
index e88aa13a7b05977ee51d2b63f20baa8f76af159f..0000000000000000000000000000000000000000
--- a/test/incremental/try_in_comptime_in_struct_in_test.zig
+++ /dev/null
@@ -1,13 +0,0 @@
-test "@unionInit on union w/ tag but no fields" {
-    const S = struct {
-        comptime {
-            try expect(false);
-        }
-    };
-    _ = S;
-}
-
-// error
-// is_test=1
-//
-// :4:13: error: 'try' outside function scope
diff --git a/test/incremental/type_of.0.zig b/test/incremental/type_of.0.zig
deleted file mode 100644
index d8a97d144470eff0d74fb59464146a17c52f328d..0000000000000000000000000000000000000000
--- a/test/incremental/type_of.0.zig
+++ /dev/null
@@ -1,13 +0,0 @@
-pub fn main() void {
-    var x: usize = 0;
-    _ = x;
-    const z = @TypeOf(x, @as(u128, 5));
-    assert(z == u128);
-}
-
-pub fn assert(ok: bool) void {
-    if (!ok) unreachable; // assertion failure
-}
-
-// run
-//
diff --git a/test/incremental/type_of.1.zig b/test/incremental/type_of.1.zig
deleted file mode 100644
index 86d7d87a19da452234bebb83b69d8cb0ee1fa1a8..0000000000000000000000000000000000000000
--- a/test/incremental/type_of.1.zig
+++ /dev/null
@@ -1,11 +0,0 @@
-pub fn main() void {
-    const z = @TypeOf(true);
-    assert(z == bool);
-}
-
-pub fn assert(ok: bool) void {
-    if (!ok) unreachable; // assertion failure
-}
-
-// run
-//
diff --git a/test/incremental/type_of.2.zig b/test/incremental/type_of.2.zig
deleted file mode 100644
index cdbc8121fd71bc5f6603e8c2ab399154ba9b0c84..0000000000000000000000000000000000000000
--- a/test/incremental/type_of.2.zig
+++ /dev/null
@@ -1,9 +0,0 @@
-pub fn main() void {
-    _ = @TypeOf(true, 1);
-}
-
-// error
-//
-// :2:9: error: incompatible types: 'bool' and 'comptime_int'
-// :2:17: note: type 'bool' here
-// :2:23: note: type 'comptime_int' here
diff --git a/test/incremental/unused_labels.0.zig b/test/incremental/unused_labels.0.zig
deleted file mode 100644
index 9afa5facdde2c412bd30cd0d43463c2f90cd2cf2..0000000000000000000000000000000000000000
--- a/test/incremental/unused_labels.0.zig
+++ /dev/null
@@ -1,8 +0,0 @@
-comptime {
-    foo: {}
-}
-
-// error
-// output_mode=Exe
-//
-// :2:5: error: unused block label
diff --git a/test/incremental/unused_labels.1.zig b/test/incremental/unused_labels.1.zig
deleted file mode 100644
index c7ff576875dcea1d493816bb78ee56b863023707..0000000000000000000000000000000000000000
--- a/test/incremental/unused_labels.1.zig
+++ /dev/null
@@ -1,7 +0,0 @@
-comptime {
-    foo: while (true) {}
-}
-
-// error
-//
-// :2:5: error: unused while loop label
diff --git a/test/incremental/unused_labels.2.zig b/test/incremental/unused_labels.2.zig
deleted file mode 100644
index babe3c7b0a1dda7aac83115faf4c60d00aa06543..0000000000000000000000000000000000000000
--- a/test/incremental/unused_labels.2.zig
+++ /dev/null
@@ -1,7 +0,0 @@
-comptime {
-    foo: for ("foo") |_| {}
-}
-
-// error
-//
-// :2:5: error: unused for loop label
diff --git a/test/incremental/unused_labels.3.zig b/test/incremental/unused_labels.3.zig
deleted file mode 100644
index e4f3ac05a404667fb60cad6f5fc8bfe43abb457c..0000000000000000000000000000000000000000
--- a/test/incremental/unused_labels.3.zig
+++ /dev/null
@@ -1,8 +0,0 @@
-comptime {
-    blk: {blk: {}}
-}
-
-// error
-//
-// :2:11: error: redefinition of label 'blk'
-// :2:5: note: previous definition here
diff --git a/test/incremental/unused_vars.zig b/test/incremental/unused_vars.zig
deleted file mode 100644
index 85e168d19a9e479bf93e1500c141551a1f8e2fad..0000000000000000000000000000000000000000
--- a/test/incremental/unused_vars.zig
+++ /dev/null
@@ -1,7 +0,0 @@
-pub fn main() void {
-    const x = 1;
-}
-
-// error
-//
-// :2:11: error: unused local constant
diff --git a/test/incremental/variable_shadowing.0.zig b/test/incremental/variable_shadowing.0.zig
deleted file mode 100644
index 0ab53a78f929e43ba4edb678f290b05dd042b35f..0000000000000000000000000000000000000000
--- a/test/incremental/variable_shadowing.0.zig
+++ /dev/null
@@ -1,9 +0,0 @@
-pub fn main() void {
-    var i: u32 = 10;
-    var i: u32 = 10;
-}
-
-// error
-//
-// :3:9: error: redeclaration of local variable 'i'
-// :2:9: note: previous declaration here
diff --git a/test/incremental/variable_shadowing.1.zig b/test/incremental/variable_shadowing.1.zig
deleted file mode 100644
index af24af038dfc0da511879b35a0edd97415320621..0000000000000000000000000000000000000000
--- a/test/incremental/variable_shadowing.1.zig
+++ /dev/null
@@ -1,9 +0,0 @@
-var testing: i64 = 10;
-pub fn main() void {
-    var testing: i64 = 20;
-}
-
-// error
-//
-// :3:9: error: local shadows declaration of 'testing'
-// :1:1: note: declared here
diff --git a/test/incremental/variable_shadowing.2.zig b/test/incremental/variable_shadowing.2.zig
deleted file mode 100644
index a44372f9b978ce8ed3eef164ce81364637fb2313..0000000000000000000000000000000000000000
--- a/test/incremental/variable_shadowing.2.zig
+++ /dev/null
@@ -1,13 +0,0 @@
-fn a() type {
-    return struct {
-        pub fn b() void {
-            const c = 6;
-            const c = 69;
-        }
-    };
-}
-
-// error
-//
-// :5:19: error: redeclaration of local constant 'c'
-// :4:19: note: previous declaration here
diff --git a/test/incremental/variable_shadowing.3.zig b/test/incremental/variable_shadowing.3.zig
deleted file mode 100644
index 89288705e1b1d70326edefcc81da2ae02cca7ecf..0000000000000000000000000000000000000000
--- a/test/incremental/variable_shadowing.3.zig
+++ /dev/null
@@ -1,10 +0,0 @@
-pub fn main() void {
-    var i = 0;
-    for ("n") |_, i| {
-    }
-}
-
-// error
-//
-// :3:19: error: redeclaration of local variable 'i'
-// :2:9: note: previous declaration here
diff --git a/test/incremental/variable_shadowing.4.zig b/test/incremental/variable_shadowing.4.zig
deleted file mode 100644
index b798cc13c1dc018a136fcca8ef4548839b8130fd..0000000000000000000000000000000000000000
--- a/test/incremental/variable_shadowing.4.zig
+++ /dev/null
@@ -1,10 +0,0 @@
-pub fn main() void {
-    var i = 0;
-    for ("n") |i| {
-    }
-}
-
-// error
-//
-// :3:16: error: redeclaration of local variable 'i'
-// :2:9: note: previous declaration here
diff --git a/test/incremental/variable_shadowing.5.zig b/test/incremental/variable_shadowing.5.zig
deleted file mode 100644
index 484d218ea20e1e46451a1947d8bbedd5aef61d95..0000000000000000000000000000000000000000
--- a/test/incremental/variable_shadowing.5.zig
+++ /dev/null
@@ -1,10 +0,0 @@
-pub fn main() void {
-    var i = 0;
-    while ("n") |i| {
-    }
-}
-
-// error
-//
-// :3:18: error: redeclaration of local variable 'i'
-// :2:9: note: previous declaration here
diff --git a/test/incremental/variable_shadowing.6.zig b/test/incremental/variable_shadowing.6.zig
deleted file mode 100644
index 3e53c4da2fcbb95783caf037ff8849ddd8d07999..0000000000000000000000000000000000000000
--- a/test/incremental/variable_shadowing.6.zig
+++ /dev/null
@@ -1,13 +0,0 @@
-pub fn main() void {
-    var i = 0;
-    while ("n") |bruh| {
-        _ = bruh;
-    } else |i| {
-
-    }
-}
-
-// error
-//
-// :5:13: error: redeclaration of local variable 'i'
-// :2:9: note: previous declaration here
diff --git a/test/incremental/variable_shadowing.7.zig b/test/incremental/variable_shadowing.7.zig
deleted file mode 100644
index 95888839a7107a446c9e850946b4f4484d599f00..0000000000000000000000000000000000000000
--- a/test/incremental/variable_shadowing.7.zig
+++ /dev/null
@@ -1,9 +0,0 @@
-pub fn main() void {
-    var i = 0;
-    if (true) |i| {}
-}
-
-// error
-//
-// :3:16: error: redeclaration of local variable 'i'
-// :2:9: note: previous declaration here
diff --git a/test/incremental/variable_shadowing.8.zig b/test/incremental/variable_shadowing.8.zig
deleted file mode 100644
index 57e616e1d699d2123eb62fc92acda0a0ec02e4fc..0000000000000000000000000000000000000000
--- a/test/incremental/variable_shadowing.8.zig
+++ /dev/null
@@ -1,9 +0,0 @@
-pub fn main() void {
-    var i = 0;
-    if (true) |i| {} else |e| {}
-}
-
-// error
-//
-// :3:16: error: redeclaration of local variable 'i'
-// :2:9: note: previous declaration here
diff --git a/test/incremental/variable_shadowing.9.zig b/test/incremental/variable_shadowing.9.zig
deleted file mode 100644
index b8a1198aed4608b4c8fde8f40e3f2f04fdcdef5a..0000000000000000000000000000000000000000
--- a/test/incremental/variable_shadowing.9.zig
+++ /dev/null
@@ -1,9 +0,0 @@
-pub fn main() void {
-    var i = 0;
-    if (true) |_| {} else |i| {}
-}
-
-// error
-//
-// :3:28: error: redeclaration of local variable 'i'
-// :2:9: note: previous declaration here
diff --git a/test/incremental/wasm-wasi/conditions.0.zig b/test/incremental/wasm-wasi/conditions.0.zig
deleted file mode 100644
index 1167ea85a4413757b8d481b1d672703b2a2ebd2f..0000000000000000000000000000000000000000
--- a/test/incremental/wasm-wasi/conditions.0.zig
+++ /dev/null
@@ -1,11 +0,0 @@
-pub fn main() u8 {
-    var i: u8 = 5;
-    if (i > @as(u8, 4)) {
-        i += 10;
-    }
-    return i - 15;
-}
-
-// run
-// target=wasm32-wasi
-//
diff --git a/test/incremental/wasm-wasi/conditions.1.zig b/test/incremental/wasm-wasi/conditions.1.zig
deleted file mode 100644
index f9f03808b97a134f78276875979f483e8ad317e5..0000000000000000000000000000000000000000
--- a/test/incremental/wasm-wasi/conditions.1.zig
+++ /dev/null
@@ -1,12 +0,0 @@
-pub fn main() u8 {
-    var i: u8 = 5;
-    if (i < @as(u8, 4)) {
-        i += 10;
-    } else {
-        i = 2;
-    }
-    return i - 2;
-}
-
-// run
-//
diff --git a/test/incremental/wasm-wasi/conditions.2.zig b/test/incremental/wasm-wasi/conditions.2.zig
deleted file mode 100644
index a80ead9ea54084317c55da133d91bf72f305909f..0000000000000000000000000000000000000000
--- a/test/incremental/wasm-wasi/conditions.2.zig
+++ /dev/null
@@ -1,12 +0,0 @@
-pub fn main() u8 {
-    var i: u8 = 5;
-    if (i < @as(u8, 4)) {
-        i += 10;
-    } else if (i == @as(u8, 5)) {
-        i = 20;
-    }
-    return i - 20;
-}
-
-// run
-//
diff --git a/test/incremental/wasm-wasi/conditions.3.zig b/test/incremental/wasm-wasi/conditions.3.zig
deleted file mode 100644
index bd016a47f3c78ec39512ad91d0cd373f35a8bed2..0000000000000000000000000000000000000000
--- a/test/incremental/wasm-wasi/conditions.3.zig
+++ /dev/null
@@ -1,16 +0,0 @@
-pub fn main() u8 {
-    var i: u8 = 11;
-    if (i < @as(u8, 4)) {
-        i += 10;
-    } else {
-        if (i > @as(u8, 10)) {
-            i += 20;
-        } else {
-            i = 20;
-        }
-    }
-    return i - 31;
-}
-
-// run
-//
diff --git a/test/incremental/wasm-wasi/conditions.4.zig b/test/incremental/wasm-wasi/conditions.4.zig
deleted file mode 100644
index e1bd9ce0f7b6b397c997f416143b0eac10ac7551..0000000000000000000000000000000000000000
--- a/test/incremental/wasm-wasi/conditions.4.zig
+++ /dev/null
@@ -1,15 +0,0 @@
-pub fn main() void {
-    assert(foo(true) != @as(i32, 30));
-}
-
-fn assert(ok: bool) void {
-    if (!ok) unreachable;
-}
-
-fn foo(ok: bool) i32 {
-    const x = if (ok) @as(i32, 20) else @as(i32, 10);
-    return x;
-}
-
-// run
-//
diff --git a/test/incremental/wasm-wasi/conditions.5.zig b/test/incremental/wasm-wasi/conditions.5.zig
deleted file mode 100644
index 2d5ba338c7aea87a6f059d6f119bd1e0f7641793..0000000000000000000000000000000000000000
--- a/test/incremental/wasm-wasi/conditions.5.zig
+++ /dev/null
@@ -1,20 +0,0 @@
-pub fn main() void {
-    assert(foo(false) == @as(i32, 20));
-    assert(foo(true) == @as(i32, 30));
-}
-
-fn assert(ok: bool) void {
-    if (!ok) unreachable;
-}
-
-fn foo(ok: bool) i32 {
-    const val: i32 = blk: {
-        var x: i32 = 1;
-        if (!ok) break :blk x + @as(i32, 9);
-        break :blk x + @as(i32, 19);
-    };
-    return val + 10;
-}
-
-// run
-//
diff --git a/test/incremental/wasm-wasi/error_unions.0.zig b/test/incremental/wasm-wasi/error_unions.0.zig
deleted file mode 100644
index 355698e4b66b7e43c16c1c0b4c92b9161f1c9a11..0000000000000000000000000000000000000000
--- a/test/incremental/wasm-wasi/error_unions.0.zig
+++ /dev/null
@@ -1,15 +0,0 @@
-pub fn main() void {
-    var e1 = error.Foo;
-    var e2 = error.Bar;
-    assert(e1 != e2);
-    assert(e1 == error.Foo);
-    assert(e2 == error.Bar);
-}
-
-fn assert(b: bool) void {
-    if (!b) unreachable;
-}
-
-// run
-// target=wasm32-wasi
-//
diff --git a/test/incremental/wasm-wasi/error_unions.1.zig b/test/incremental/wasm-wasi/error_unions.1.zig
deleted file mode 100644
index 526e1a110d4c74415d9c3036ae99b828efd133c7..0000000000000000000000000000000000000000
--- a/test/incremental/wasm-wasi/error_unions.1.zig
+++ /dev/null
@@ -1,8 +0,0 @@
-pub fn main() u8 {
-    var e: anyerror!u8 = 5;
-    const i = e catch 10;
-    return i - 5;
-}
-
-// run
-//
diff --git a/test/incremental/wasm-wasi/error_unions.2.zig b/test/incremental/wasm-wasi/error_unions.2.zig
deleted file mode 100644
index b66c7d78c073bb0ef4cd4365fed5873fb66901af..0000000000000000000000000000000000000000
--- a/test/incremental/wasm-wasi/error_unions.2.zig
+++ /dev/null
@@ -1,8 +0,0 @@
-pub fn main() u8 {
-    var e: anyerror!u8 = error.Foo;
-    const i = e catch 10;
-    return i - 10;
-}
-
-// run
-//
diff --git a/test/incremental/wasm-wasi/error_unions.3.zig b/test/incremental/wasm-wasi/error_unions.3.zig
deleted file mode 100644
index d37f826272dc32f990891837ed1a1a202a81fbd4..0000000000000000000000000000000000000000
--- a/test/incremental/wasm-wasi/error_unions.3.zig
+++ /dev/null
@@ -1,12 +0,0 @@
-pub fn main() u8 {
-    var e = foo();
-    const i = e catch 69;
-    return i - 5;
-}
-
-fn foo() anyerror!u8 {
-    return 5;
-}
-
-// run
-//
diff --git a/test/incremental/wasm-wasi/error_unions.4.zig b/test/incremental/wasm-wasi/error_unions.4.zig
deleted file mode 100644
index bbc8dd34da3b637871424a45678b5f5c5f67620c..0000000000000000000000000000000000000000
--- a/test/incremental/wasm-wasi/error_unions.4.zig
+++ /dev/null
@@ -1,12 +0,0 @@
-pub fn main() u8 {
-    var e = foo();
-    const i = e catch 69;
-    return i - 69;
-}
-
-fn foo() anyerror!u8 {
-    return error.Bruh;
-}
-
-// run
-//
diff --git a/test/incremental/wasm-wasi/error_unions.5.zig b/test/incremental/wasm-wasi/error_unions.5.zig
deleted file mode 100644
index 96d52d1de1f3a3eb31741f0bfdd8f8791f92e232..0000000000000000000000000000000000000000
--- a/test/incremental/wasm-wasi/error_unions.5.zig
+++ /dev/null
@@ -1,12 +0,0 @@
-pub fn main() u8 {
-    var e = foo();
-    const i = e catch 42;
-    return i - 42;
-}
-
-fn foo() anyerror!u8 {
-    return error.Dab;
-}
-
-// run
-//
diff --git a/test/incremental/wasm-wasi/locals.0.zig b/test/incremental/wasm-wasi/locals.0.zig
deleted file mode 100644
index f2df242792c6249864477ac4a69614f5032d6ceb..0000000000000000000000000000000000000000
--- a/test/incremental/wasm-wasi/locals.0.zig
+++ /dev/null
@@ -1,14 +0,0 @@
-pub fn main() void {
-    var i: u8 = 5;
-    var y: f32 = 42.0;
-    var x: u8 = 10;
-    if (false) {
-        y;
-        x;
-    }
-    if (i != 5) unreachable;
-}
-
-// run
-// target=wasm32-wasi
-//
diff --git a/test/incremental/wasm-wasi/locals.1.zig b/test/incremental/wasm-wasi/locals.1.zig
deleted file mode 100644
index f7e59e1c02e8a328b3bc84e7d0f1820c92b22d22..0000000000000000000000000000000000000000
--- a/test/incremental/wasm-wasi/locals.1.zig
+++ /dev/null
@@ -1,17 +0,0 @@
-pub fn main() void {
-    var i: u8 = 5;
-    var y: f32 = 42.0;
-    _ = y;
-    var x: u8 = 10;
-    foo(i, x);
-    i = x;
-    if (i != 10) unreachable;
-}
-fn foo(x: u8, y: u8) void {
-    _ = y;
-    var i: u8 = 10;
-    i = x;
-}
-
-// run
-//
diff --git a/test/incremental/wasm-wasi/optionals.0.zig b/test/incremental/wasm-wasi/optionals.0.zig
deleted file mode 100644
index e602bf1c8047d4b39bd8bb669df837b7842c3e5d..0000000000000000000000000000000000000000
--- a/test/incremental/wasm-wasi/optionals.0.zig
+++ /dev/null
@@ -1,12 +0,0 @@
-pub fn main() u8 {
-    var x: ?u8 = 5;
-    var y: u8 = 0;
-    if (x) |val| {
-        y = val;
-    }
-    return y - 5;
-}
-
-// run
-// target=wasm32-wasi
-//
diff --git a/test/incremental/wasm-wasi/optionals.1.zig b/test/incremental/wasm-wasi/optionals.1.zig
deleted file mode 100644
index 26e81b890983755980f6e5701d04faec506ff49d..0000000000000000000000000000000000000000
--- a/test/incremental/wasm-wasi/optionals.1.zig
+++ /dev/null
@@ -1,11 +0,0 @@
-pub fn main() u8 {
-    var x: ?u8 = null;
-    var y: u8 = 0;
-    if (x) |val| {
-        y = val;
-    }
-    return y;
-}
-
-// run
-//
diff --git a/test/incremental/wasm-wasi/optionals.2.zig b/test/incremental/wasm-wasi/optionals.2.zig
deleted file mode 100644
index b610c6d2e9669ccbbe921cce11695c0200e2ba25..0000000000000000000000000000000000000000
--- a/test/incremental/wasm-wasi/optionals.2.zig
+++ /dev/null
@@ -1,7 +0,0 @@
-pub fn main() u8 {
-    var x: ?u8 = 5;
-    return x.? - 5;
-}
-
-// run
-//
diff --git a/test/incremental/wasm-wasi/optionals.3.zig b/test/incremental/wasm-wasi/optionals.3.zig
deleted file mode 100644
index d513c102827858be70c41f43bda1f6698fad19ed..0000000000000000000000000000000000000000
--- a/test/incremental/wasm-wasi/optionals.3.zig
+++ /dev/null
@@ -1,8 +0,0 @@
-pub fn main() u8 {
-    var x: u8 = 5;
-    var y: ?u8 = x;
-    return y.? - 5;
-}
-
-// run
-//
diff --git a/test/incremental/wasm-wasi/optionals.4.zig b/test/incremental/wasm-wasi/optionals.4.zig
deleted file mode 100644
index af3400b322a9b9cec82f8a3798c1806e93aae4c4..0000000000000000000000000000000000000000
--- a/test/incremental/wasm-wasi/optionals.4.zig
+++ /dev/null
@@ -1,13 +0,0 @@
-pub fn main() u8 {
-    var val: ?u8 = 5;
-    while (val) |*v| {
-        v.* -= 1;
-        if (v.* == 2) {
-            val = null;
-        }
-    }
-    return 0;
-}
-
-// run
-//
diff --git a/test/incremental/wasm-wasi/pointers.0.zig b/test/incremental/wasm-wasi/pointers.0.zig
deleted file mode 100644
index 958ee5ac8860225eb4b5d5bfb051a8fb9ea97699..0000000000000000000000000000000000000000
--- a/test/incremental/wasm-wasi/pointers.0.zig
+++ /dev/null
@@ -1,14 +0,0 @@
-pub fn main() u8 {
-    var x: u8 = 0;
-
-    foo(&x);
-    return x - 2;
-}
-
-fn foo(x: *u8) void {
-    x.* = 2;
-}
-
-// run
-// target=wasm32-wasi
-//
diff --git a/test/incremental/wasm-wasi/pointers.1.zig b/test/incremental/wasm-wasi/pointers.1.zig
deleted file mode 100644
index b3649cf5204313da4d2979866de590a04d4494a1..0000000000000000000000000000000000000000
--- a/test/incremental/wasm-wasi/pointers.1.zig
+++ /dev/null
@@ -1,18 +0,0 @@
-pub fn main() u8 {
-    var x: u8 = 0;
-
-    foo(&x);
-    bar(&x);
-    return x - 4;
-}
-
-fn foo(x: *u8) void {
-    x.* = 2;
-}
-
-fn bar(x: *u8) void {
-    x.* += 2;
-}
-
-// run
-//
diff --git a/test/incremental/wasm-wasi/structs.0.zig b/test/incremental/wasm-wasi/structs.0.zig
deleted file mode 100644
index 03a8938d9ebcf80db462bb7f98d093b97a28003d..0000000000000000000000000000000000000000
--- a/test/incremental/wasm-wasi/structs.0.zig
+++ /dev/null
@@ -1,10 +0,0 @@
-const Example = struct { x: u8 };
-
-pub fn main() u8 {
-    var example: Example = .{ .x = 5 };
-    return example.x - 5;
-}
-
-// run
-// target=wasm32-wasi
-//
diff --git a/test/incremental/wasm-wasi/structs.1.zig b/test/incremental/wasm-wasi/structs.1.zig
deleted file mode 100644
index 8d4250e4a2ac87a7271f06275f2bd951f211180c..0000000000000000000000000000000000000000
--- a/test/incremental/wasm-wasi/structs.1.zig
+++ /dev/null
@@ -1,10 +0,0 @@
-const Example = struct { x: u8 };
-
-pub fn main() u8 {
-    var example: Example = .{ .x = 5 };
-    example.x = 10;
-    return example.x - 10;
-}
-
-// run
-//
diff --git a/test/incremental/wasm-wasi/structs.2.zig b/test/incremental/wasm-wasi/structs.2.zig
deleted file mode 100644
index b1d3cbf080accc76edd40158f4f7c5946f9c7c79..0000000000000000000000000000000000000000
--- a/test/incremental/wasm-wasi/structs.2.zig
+++ /dev/null
@@ -1,9 +0,0 @@
-const Example = struct { x: u8, y: u8 };
-
-pub fn main() u8 {
-    var example: Example = .{ .x = 5, .y = 10 };
-    return example.y + example.x - 15;
-}
-
-// run
-//
diff --git a/test/incremental/wasm-wasi/structs.3.zig b/test/incremental/wasm-wasi/structs.3.zig
deleted file mode 100644
index 558b5a1e2d7109fdf53d0c9b862718588178440e..0000000000000000000000000000000000000000
--- a/test/incremental/wasm-wasi/structs.3.zig
+++ /dev/null
@@ -1,12 +0,0 @@
-const Example = struct { x: u8, y: u8 };
-
-pub fn main() u8 {
-    var example: Example = .{ .x = 5, .y = 10 };
-    var example2: Example = .{ .x = 10, .y = 20 };
-
-    example = example2;
-    return example.y + example.x - 30;
-}
-
-// run
-//
diff --git a/test/incremental/wasm-wasi/structs.4.zig b/test/incremental/wasm-wasi/structs.4.zig
deleted file mode 100644
index 2d37446c5692f49b68d0de55488e995b1011e075..0000000000000000000000000000000000000000
--- a/test/incremental/wasm-wasi/structs.4.zig
+++ /dev/null
@@ -1,11 +0,0 @@
-const Example = struct { x: u8, y: u8 };
-
-pub fn main() u8 {
-    var example: Example = .{ .x = 5, .y = 10 };
-
-    example = .{ .x = 10, .y = 20 };
-    return example.y + example.x - 30;
-}
-
-// run
-//
diff --git a/test/incremental/wasm-wasi/switch.0.zig b/test/incremental/wasm-wasi/switch.0.zig
deleted file mode 100644
index d0c0e43f8fb8d9a5cc41e1636c41ec24e9ffce71..0000000000000000000000000000000000000000
--- a/test/incremental/wasm-wasi/switch.0.zig
+++ /dev/null
@@ -1,15 +0,0 @@
-pub fn main() u8 {
-    var val: u8 = 1;
-    var a: u8 = switch (val) {
-        0, 1 => 2,
-        2 => 3,
-        3 => 4,
-        else => 5,
-    };
-
-    return a - 2;
-}
-
-// run
-// target=wasm32-wasi
-//
diff --git a/test/incremental/wasm-wasi/switch.1.zig b/test/incremental/wasm-wasi/switch.1.zig
deleted file mode 100644
index fe503bf212e45fb1c74940b227b33221868e146e..0000000000000000000000000000000000000000
--- a/test/incremental/wasm-wasi/switch.1.zig
+++ /dev/null
@@ -1,14 +0,0 @@
-pub fn main() u8 {
-    var val: u8 = 2;
-    var a: u8 = switch (val) {
-        0, 1 => 2,
-        2 => 3,
-        3 => 4,
-        else => 5,
-    };
-
-    return a - 3;
-}
-
-// run
-//
diff --git a/test/incremental/wasm-wasi/switch.2.zig b/test/incremental/wasm-wasi/switch.2.zig
deleted file mode 100644
index 24f40d8402ca658e294b45e1d771b9f5697efb90..0000000000000000000000000000000000000000
--- a/test/incremental/wasm-wasi/switch.2.zig
+++ /dev/null
@@ -1,14 +0,0 @@
-pub fn main() u8 {
-    var val: u8 = 10;
-    var a: u8 = switch (val) {
-        0, 1 => 2,
-        2 => 3,
-        3 => 4,
-        else => 5,
-    };
-
-    return a - 5;
-}
-
-// run
-//
diff --git a/test/incremental/wasm-wasi/switch.3.zig b/test/incremental/wasm-wasi/switch.3.zig
deleted file mode 100644
index e0b55db3bff6a6809e7ce5285ccce49f40b8c82b..0000000000000000000000000000000000000000
--- a/test/incremental/wasm-wasi/switch.3.zig
+++ /dev/null
@@ -1,15 +0,0 @@
-const MyEnum = enum { One, Two, Three };
-
-pub fn main() u8 {
-    var val: MyEnum = .Two;
-    var a: u8 = switch (val) {
-        .One => 1,
-        .Two => 2,
-        .Three => 3,
-    };
-
-    return a - 2;
-}
-
-// run
-//
diff --git a/test/incremental/wasm-wasi/while_loops.0.zig b/test/incremental/wasm-wasi/while_loops.0.zig
deleted file mode 100644
index 721b127ff54aeb2d65f03dd4cfdc8315445529f6..0000000000000000000000000000000000000000
--- a/test/incremental/wasm-wasi/while_loops.0.zig
+++ /dev/null
@@ -1,12 +0,0 @@
-pub fn main() u8 {
-    var i: u8 = 0;
-    while (i < @as(u8, 5)) {
-        i += 1;
-    }
-
-    return i - 5;
-}
-
-// run
-// target=wasm32-wasi
-//
diff --git a/test/incremental/wasm-wasi/while_loops.1.zig b/test/incremental/wasm-wasi/while_loops.1.zig
deleted file mode 100644
index 715a813b65e66c4b1f42e4b00b397b5933b0de35..0000000000000000000000000000000000000000
--- a/test/incremental/wasm-wasi/while_loops.1.zig
+++ /dev/null
@@ -1,11 +0,0 @@
-pub fn main() u8 {
-    var i: u8 = 0;
-    while (i < @as(u8, 10)) {
-        var x: u8 = 1;
-        i += x;
-    }
-    return i - 10;
-}
-
-// run
-//
diff --git a/test/incremental/wasm-wasi/while_loops.2.zig b/test/incremental/wasm-wasi/while_loops.2.zig
deleted file mode 100644
index 7ad8101c3777d2a94289fedd8406693f4b7c0861..0000000000000000000000000000000000000000
--- a/test/incremental/wasm-wasi/while_loops.2.zig
+++ /dev/null
@@ -1,12 +0,0 @@
-pub fn main() u8 {
-    var i: u8 = 0;
-    while (i < @as(u8, 10)) {
-        var x: u8 = 1;
-        i += x;
-        if (i == @as(u8, 5)) break;
-    }
-    return i - 5;
-}
-
-// run
-//
diff --git a/test/incremental/x86_64-linux/assert_function.0.zig b/test/incremental/x86_64-linux/assert_function.0.zig
deleted file mode 100644
index ab34f5328dc90498078384ce434c0e11905f0487..0000000000000000000000000000000000000000
--- a/test/incremental/x86_64-linux/assert_function.0.zig
+++ /dev/null
@@ -1,15 +0,0 @@
-pub fn main() void {
-    add(3, 4);
-}
-
-fn add(a: u32, b: u32) void {
-    assert(a + b == 7);
-}
-
-pub fn assert(ok: bool) void {
-    if (!ok) unreachable; // assertion failure
-}
-
-// run
-// target=x86_64-linux
-//
diff --git a/test/incremental/x86_64-linux/assert_function.1.zig b/test/incremental/x86_64-linux/assert_function.1.zig
deleted file mode 100644
index ac2df25d8556c661b48a9382d200283073d5d00b..0000000000000000000000000000000000000000
--- a/test/incremental/x86_64-linux/assert_function.1.zig
+++ /dev/null
@@ -1,17 +0,0 @@
-pub fn main() void {
-    add(3, 4);
-}
-
-fn add(a: u32, b: u32) void {
-    const c = a + b; // 7
-    const d = a + c; // 10
-    const e = d + b; // 14
-    assert(e == 14);
-}
-
-pub fn assert(ok: bool) void {
-    if (!ok) unreachable; // assertion failure
-}
-
-// run
-//
diff --git a/test/incremental/x86_64-linux/assert_function.10.zig b/test/incremental/x86_64-linux/assert_function.10.zig
deleted file mode 100644
index b3f1610cd62b71553f20959ef9cf4cec51d8f498..0000000000000000000000000000000000000000
--- a/test/incremental/x86_64-linux/assert_function.10.zig
+++ /dev/null
@@ -1,27 +0,0 @@
-pub fn main() void {
-    assert(add(3, 4) == 116);
-}
-
-fn add(a: u32, b: u32) u32 {
-    const x: u32 = blk: {
-        const c = a + b; // 7
-        const d = a + c; // 10
-        const e = d + b; // 14
-        const f = d + e; // 24
-        const g = e + f; // 38
-        const h = f + g; // 62
-        const i = g + h; // 100
-        const j = i + d; // 110
-        break :blk j;
-    };
-    const y = x + a; // 113
-    const z = y + a; // 116
-    return z;
-}
-
-pub fn assert(ok: bool) void {
-    if (!ok) unreachable; // assertion failure
-}
-
-// run
-//
diff --git a/test/incremental/x86_64-linux/assert_function.11.zig b/test/incremental/x86_64-linux/assert_function.11.zig
deleted file mode 100644
index d64130a6775b250ca18a5900e912391dc732a7f7..0000000000000000000000000000000000000000
--- a/test/incremental/x86_64-linux/assert_function.11.zig
+++ /dev/null
@@ -1,66 +0,0 @@
-pub fn main() void {
-    assert(add(3, 4) == 1221);
-    assert(mul(3, 4) == 21609);
-}
-
-fn add(a: u32, b: u32) u32 {
-    const x: u32 = blk: {
-        const c = a + b; // 7
-        const d = a + c; // 10
-        const e = d + b; // 14
-        const f = d + e; // 24
-        const g = e + f; // 38
-        const h = f + g; // 62
-        const i = g + h; // 100
-        const j = i + d; // 110
-        const k = i + j; // 210
-        const l = j + k; // 320
-        const m = l + c; // 327
-        const n = m + d; // 337
-        const o = n + e; // 351
-        const p = o + f; // 375
-        const q = p + g; // 413
-        const r = q + h; // 475
-        const s = r + i; // 575
-        const t = s + j; // 685
-        const u = t + k; // 895
-        const v = u + l; // 1215
-        break :blk v;
-    };
-    const y = x + a; // 1218
-    const z = y + a; // 1221
-    return z;
-}
-
-fn mul(a: u32, b: u32) u32 {
-    const x: u32 = blk: {
-        const c = a * a * a * a; // 81
-        const d = a * a * a * b; // 108
-        const e = a * a * b * a; // 108
-        const f = a * a * b * b; // 144
-        const g = a * b * a * a; // 108
-        const h = a * b * a * b; // 144
-        const i = a * b * b * a; // 144
-        const j = a * b * b * b; // 192
-        const k = b * a * a * a; // 108
-        const l = b * a * a * b; // 144
-        const m = b * a * b * a; // 144
-        const n = b * a * b * b; // 192
-        const o = b * b * a * a; // 144
-        const p = b * b * a * b; // 192
-        const q = b * b * b * a; // 192
-        const r = b * b * b * b; // 256
-        const s = c + d + e + f + g + h + i + j + k + l + m + n + o + p + q + r; // 2401
-        break :blk s;
-    };
-    const y = x * a; // 7203
-    const z = y * a; // 21609
-    return z;
-}
-
-pub fn assert(ok: bool) void {
-    if (!ok) unreachable; // assertion failure
-}
-
-// run
-//
diff --git a/test/incremental/x86_64-linux/assert_function.12.zig b/test/incremental/x86_64-linux/assert_function.12.zig
deleted file mode 100644
index 4f64c1e0626879a2004d66080292dc7cf962065d..0000000000000000000000000000000000000000
--- a/test/incremental/x86_64-linux/assert_function.12.zig
+++ /dev/null
@@ -1,47 +0,0 @@
-pub fn main() void {
-    assert(add(3, 4) == 791);
-    assert(add(4, 3) == 79);
-}
-
-fn add(a: u32, b: u32) u32 {
-    const x: u32 = if (a < b) blk: {
-        const c = a + b; // 7
-        const d = a + c; // 10
-        const e = d + b; // 14
-        const f = d + e; // 24
-        const g = e + f; // 38
-        const h = f + g; // 62
-        const i = g + h; // 100
-        const j = i + d; // 110
-        const k = i + j; // 210
-        const l = k + c; // 217
-        const m = l + d; // 227
-        const n = m + e; // 241
-        const o = n + f; // 265
-        const p = o + g; // 303
-        const q = p + h; // 365
-        const r = q + i; // 465
-        const s = r + j; // 575
-        const t = s + k; // 785
-        break :blk t;
-    } else blk: {
-        const t = b + b + a; // 10
-        const c = a + t; // 14
-        const d = c + t; // 24
-        const e = d + t; // 34
-        const f = e + t; // 44
-        const g = f + t; // 54
-        const h = c + g; // 68
-        break :blk h + b; // 71
-    };
-    const y = x + a; // 788, 75
-    const z = y + a; // 791, 79
-    return z;
-}
-
-pub fn assert(ok: bool) void {
-    if (!ok) unreachable; // assertion failure
-}
-
-// run
-//
diff --git a/test/incremental/x86_64-linux/assert_function.13.zig b/test/incremental/x86_64-linux/assert_function.13.zig
deleted file mode 100644
index 240abf0108dbe8c08040533524872e543fd6d621..0000000000000000000000000000000000000000
--- a/test/incremental/x86_64-linux/assert_function.13.zig
+++ /dev/null
@@ -1,19 +0,0 @@
-pub fn main() void {
-    const ignore =
-        \\ cool thx
-        \\
-    ;
-    _ = ignore;
-    add('ぁ', '\x03');
-}
-
-fn add(a: u32, b: u32) void {
-    assert(a + b == 12356);
-}
-
-pub fn assert(ok: bool) void {
-    if (!ok) unreachable; // assertion failure
-}
-
-// run
-//
diff --git a/test/incremental/x86_64-linux/assert_function.14.zig b/test/incremental/x86_64-linux/assert_function.14.zig
deleted file mode 100644
index d25100dccee2bda1f615c2d870ee477c1252bed3..0000000000000000000000000000000000000000
--- a/test/incremental/x86_64-linux/assert_function.14.zig
+++ /dev/null
@@ -1,17 +0,0 @@
-pub fn main() void {
-    add(aa, bb);
-}
-
-const aa = 'ぁ';
-const bb = '\x03';
-
-fn add(a: u32, b: u32) void {
-    assert(a + b == 12356);
-}
-
-pub fn assert(ok: bool) void {
-    if (!ok) unreachable; // assertion failure
-}
-
-// run
-//
diff --git a/test/incremental/x86_64-linux/assert_function.15.zig b/test/incremental/x86_64-linux/assert_function.15.zig
deleted file mode 100644
index 33ae1ed5af1279b74f089003e7b9665b55c2489b..0000000000000000000000000000000000000000
--- a/test/incremental/x86_64-linux/assert_function.15.zig
+++ /dev/null
@@ -1,10 +0,0 @@
-pub fn main() void {
-    assert("hello"[0] == 'h');
-}
-
-pub fn assert(ok: bool) void {
-    if (!ok) unreachable; // assertion failure
-}
-
-// run
-//
diff --git a/test/incremental/x86_64-linux/assert_function.16.zig b/test/incremental/x86_64-linux/assert_function.16.zig
deleted file mode 100644
index eef113642324434c4af1723aac512a57192ce726..0000000000000000000000000000000000000000
--- a/test/incremental/x86_64-linux/assert_function.16.zig
+++ /dev/null
@@ -1,11 +0,0 @@
-const hello = "hello".*;
-pub fn main() void {
-    assert(hello[1] == 'e');
-}
-
-pub fn assert(ok: bool) void {
-    if (!ok) unreachable; // assertion failure
-}
-
-// run
-//
diff --git a/test/incremental/x86_64-linux/assert_function.17.zig b/test/incremental/x86_64-linux/assert_function.17.zig
deleted file mode 100644
index ac9dce3079f6444476afd65757675726390946cf..0000000000000000000000000000000000000000
--- a/test/incremental/x86_64-linux/assert_function.17.zig
+++ /dev/null
@@ -1,11 +0,0 @@
-pub fn main() void {
-    var i: u64 = 0xFFEEDDCCBBAA9988;
-    assert(i == 0xFFEEDDCCBBAA9988);
-}
-
-pub fn assert(ok: bool) void {
-    if (!ok) unreachable; // assertion failure
-}
-
-// run
-//
diff --git a/test/incremental/x86_64-linux/assert_function.18.zig b/test/incremental/x86_64-linux/assert_function.18.zig
deleted file mode 100644
index 31cf1207f3dc07541a4210641ee136eb0ba385b0..0000000000000000000000000000000000000000
--- a/test/incremental/x86_64-linux/assert_function.18.zig
+++ /dev/null
@@ -1,35 +0,0 @@
-const builtin = @import("builtin");
-
-extern "c" fn write(usize, usize, usize) usize;
-
-pub fn main() void {
-    for ("hello") |_| print();
-}
-
-fn print() void {
-    switch (builtin.os.tag) {
-        .linux => {
-            asm volatile ("syscall"
-                :
-                : [number] "{rax}" (1),
-                  [arg1] "{rdi}" (1),
-                  [arg2] "{rsi}" (@ptrToInt("hello\n")),
-                  [arg3] "{rdx}" (6),
-                : "rcx", "r11", "memory"
-            );
-        },
-        .macos => {
-            _ = write(1, @ptrToInt("hello\n"), 6);
-        },
-        else => unreachable,
-    }
-}
-
-// run
-//
-// hello
-// hello
-// hello
-// hello
-// hello
-//
diff --git a/test/incremental/x86_64-linux/assert_function.2.zig b/test/incremental/x86_64-linux/assert_function.2.zig
deleted file mode 100644
index 8c1c510486185f4116841577473c901e13528283..0000000000000000000000000000000000000000
--- a/test/incremental/x86_64-linux/assert_function.2.zig
+++ /dev/null
@@ -1,21 +0,0 @@
-pub fn main() void {
-    add(3, 4);
-}
-
-fn add(a: u32, b: u32) void {
-    const c = a + b; // 7
-    const d = a + c; // 10
-    const e = d + b; // 14
-    const f = d + e; // 24
-    const g = e + f; // 38
-    const h = f + g; // 62
-    const i = g + h; // 100
-    assert(i == 100);
-}
-
-pub fn assert(ok: bool) void {
-    if (!ok) unreachable; // assertion failure
-}
-
-// run
-//
diff --git a/test/incremental/x86_64-linux/assert_function.3.zig b/test/incremental/x86_64-linux/assert_function.3.zig
deleted file mode 100644
index a6829f8e0239f8c01f0a1e4e1cf42e9ed035176b..0000000000000000000000000000000000000000
--- a/test/incremental/x86_64-linux/assert_function.3.zig
+++ /dev/null
@@ -1,22 +0,0 @@
-pub fn main() void {
-    add(3, 4);
-}
-
-fn add(a: u32, b: u32) void {
-    const c = a + b; // 7
-    const d = a + c; // 10
-    const e = d + b; // 14
-    const f = d + e; // 24
-    const g = e + f; // 38
-    const h = f + g; // 62
-    const i = g + h; // 100
-    const j = i + d; // 110
-    assert(j == 110);
-}
-
-pub fn assert(ok: bool) void {
-    if (!ok) unreachable; // assertion failure
-}
-
-// run
-//
diff --git a/test/incremental/x86_64-linux/assert_function.4.zig b/test/incremental/x86_64-linux/assert_function.4.zig
deleted file mode 100644
index 69df4354c3eb8d72d4c91b226fbf4b4c0eddedaf..0000000000000000000000000000000000000000
--- a/test/incremental/x86_64-linux/assert_function.4.zig
+++ /dev/null
@@ -1,15 +0,0 @@
-pub fn main() void {
-    assert(add(3, 4) == 7);
-    assert(add(20, 10) == 30);
-}
-
-fn add(a: u32, b: u32) u32 {
-    return a + b;
-}
-
-pub fn assert(ok: bool) void {
-    if (!ok) unreachable; // assertion failure
-}
-
-// run
-//
diff --git a/test/incremental/x86_64-linux/assert_function.5.zig b/test/incremental/x86_64-linux/assert_function.5.zig
deleted file mode 100644
index 89f3f7df4fd3f42da6650c27dff3c8160b281860..0000000000000000000000000000000000000000
--- a/test/incremental/x86_64-linux/assert_function.5.zig
+++ /dev/null
@@ -1,19 +0,0 @@
-pub fn main() void {
-    assert(add(3, 4) == 7);
-    assert(add(20, 10) == 30);
-}
-
-fn add(a: u32, b: u32) u32 {
-    var x: u32 = undefined;
-    x = 0;
-    x += a;
-    x += b;
-    return x;
-}
-
-pub fn assert(ok: bool) void {
-    if (!ok) unreachable; // assertion failure
-}
-
-// run
-//
diff --git a/test/incremental/x86_64-linux/assert_function.6.zig b/test/incremental/x86_64-linux/assert_function.6.zig
deleted file mode 100644
index 1b1b75e68ea72902208bd0889c38202922b89a51..0000000000000000000000000000000000000000
--- a/test/incremental/x86_64-linux/assert_function.6.zig
+++ /dev/null
@@ -1,9 +0,0 @@
-pub fn main() void {
-    const a: u32 = 2;
-    const b: ?u32 = a;
-    const c = b.?;
-    if (c != 2) unreachable;
-}
-
-// run
-//
diff --git a/test/incremental/x86_64-linux/assert_function.7.zig b/test/incremental/x86_64-linux/assert_function.7.zig
deleted file mode 100644
index e6d18a5c3f7e1f2f71ffce96c309b8f862541fb0..0000000000000000000000000000000000000000
--- a/test/incremental/x86_64-linux/assert_function.7.zig
+++ /dev/null
@@ -1,28 +0,0 @@
-pub fn main() void {
-    var i: u32 = 0;
-    while (i < 4) : (i += 1) print();
-    assert(i == 4);
-}
-
-fn print() void {
-    asm volatile ("syscall"
-        :
-        : [number] "{rax}" (1),
-          [arg1] "{rdi}" (1),
-          [arg2] "{rsi}" (@ptrToInt("hello\n")),
-          [arg3] "{rdx}" (6),
-        : "rcx", "r11", "memory"
-    );
-}
-
-pub fn assert(ok: bool) void {
-    if (!ok) unreachable; // assertion failure
-}
-
-// run
-//
-// hello
-// hello
-// hello
-// hello
-//
diff --git a/test/incremental/x86_64-linux/assert_function.8.zig b/test/incremental/x86_64-linux/assert_function.8.zig
deleted file mode 100644
index ae618cc063eb8921371563dfa6b185f2e0c3ade7..0000000000000000000000000000000000000000
--- a/test/incremental/x86_64-linux/assert_function.8.zig
+++ /dev/null
@@ -1,24 +0,0 @@
-pub fn main() void {
-    var i: u32 = 0;
-    inline while (i < 4) : (i += 1) print();
-    assert(i == 4);
-}
-
-fn print() void {
-    asm volatile ("syscall"
-        :
-        : [number] "{rax}" (1),
-          [arg1] "{rdi}" (1),
-          [arg2] "{rsi}" (@ptrToInt("hello\n")),
-          [arg3] "{rdx}" (6),
-        : "rcx", "r11", "memory"
-    );
-}
-
-pub fn assert(ok: bool) void {
-    if (!ok) unreachable; // assertion failure
-}
-
-// error
-//
-// :3:21: error: unable to resolve comptime value
diff --git a/test/incremental/x86_64-linux/assert_function.9.zig b/test/incremental/x86_64-linux/assert_function.9.zig
deleted file mode 100644
index c754bb771133d8b3a595ec9fe46c48c4c6408e61..0000000000000000000000000000000000000000
--- a/test/incremental/x86_64-linux/assert_function.9.zig
+++ /dev/null
@@ -1,22 +0,0 @@
-pub fn main() void {
-    assert(add(3, 4) == 20);
-}
-
-fn add(a: u32, b: u32) u32 {
-    const x: u32 = blk: {
-        const c = a + b; // 7
-        const d = a + c; // 10
-        const e = d + b; // 14
-        break :blk e;
-    };
-    const y = x + a; // 17
-    const z = y + a; // 20
-    return z;
-}
-
-pub fn assert(ok: bool) void {
-    if (!ok) unreachable; // assertion failure
-}
-
-// run
-//
diff --git a/test/incremental/x86_64-linux/comptime_var.0.zig b/test/incremental/x86_64-linux/comptime_var.0.zig
deleted file mode 100644
index 45f87ecaa13835c447536cbc60dfb84572025a80..0000000000000000000000000000000000000000
--- a/test/incremental/x86_64-linux/comptime_var.0.zig
+++ /dev/null
@@ -1,12 +0,0 @@
-pub fn main() void {
-    var a: u32 = 0;
-    comptime var b: u32 = 0;
-    if (a == 0) b = 3;
-}
-
-// error
-// output_mode=Exe
-// target=x86_64-linux
-//
-// :4:21: error: store to comptime variable depends on runtime condition
-// :4:11: note: runtime condition here
diff --git a/test/incremental/x86_64-linux/comptime_var.1.zig b/test/incremental/x86_64-linux/comptime_var.1.zig
deleted file mode 100644
index efc51aafe3e7572bb8815d5e75ec4e4b00761499..0000000000000000000000000000000000000000
--- a/test/incremental/x86_64-linux/comptime_var.1.zig
+++ /dev/null
@@ -1,13 +0,0 @@
-pub fn main() void {
-    var a: u32 = 0;
-    comptime var b: u32 = 0;
-    switch (a) {
-        0 => {},
-        else => b = 3,
-    }
-}
-
-// error
-//
-// :6:21: error: store to comptime variable depends on runtime condition
-// :4:13: note: runtime condition here
diff --git a/test/incremental/x86_64-linux/comptime_var.2.zig b/test/incremental/x86_64-linux/comptime_var.2.zig
deleted file mode 100644
index 72bdfad90c34a452e3be002cc82ad7315e9fe7d3..0000000000000000000000000000000000000000
--- a/test/incremental/x86_64-linux/comptime_var.2.zig
+++ /dev/null
@@ -1,22 +0,0 @@
-pub fn main() void {
-    comptime var len: u32 = 5;
-    print(len);
-    len += 9;
-    print(len);
-}
-
-fn print(len: usize) void {
-    asm volatile ("syscall"
-        :
-        : [number] "{rax}" (1),
-          [arg1] "{rdi}" (1),
-          [arg2] "{rsi}" (@ptrToInt("Hello, World!\n")),
-          [arg3] "{rdx}" (len),
-        : "rcx", "r11", "memory"
-    );
-}
-
-// run
-//
-// HelloHello, World!
-//
diff --git a/test/incremental/x86_64-linux/comptime_var.3.zig b/test/incremental/x86_64-linux/comptime_var.3.zig
deleted file mode 100644
index 5d25d6556e4f378d4288acda9ceffcb19397230f..0000000000000000000000000000000000000000
--- a/test/incremental/x86_64-linux/comptime_var.3.zig
+++ /dev/null
@@ -1,10 +0,0 @@
-comptime {
-    var x: i32 = 1;
-    x += 1;
-    if (x != 1) unreachable;
-}
-pub fn main() void {}
-
-// error
-//
-// :4:17: error: reached unreachable code
diff --git a/test/incremental/x86_64-linux/comptime_var.4.zig b/test/incremental/x86_64-linux/comptime_var.4.zig
deleted file mode 100644
index 74da6ef448edd5534b49b1f850673863b4188b99..0000000000000000000000000000000000000000
--- a/test/incremental/x86_64-linux/comptime_var.4.zig
+++ /dev/null
@@ -1,9 +0,0 @@
-pub fn main() void {
-    comptime var i: u64 = 0;
-    while (i < 5) : (i += 1) {}
-}
-
-// error
-//
-// :3:24: error: cannot store to comptime variable in non-inline loop
-// :3:5: note: non-inline loop here
diff --git a/test/incremental/x86_64-linux/comptime_var.5.zig b/test/incremental/x86_64-linux/comptime_var.5.zig
deleted file mode 100644
index 76a06f3d4b5931e8fd23271dcc593e07ff414a7f..0000000000000000000000000000000000000000
--- a/test/incremental/x86_64-linux/comptime_var.5.zig
+++ /dev/null
@@ -1,15 +0,0 @@
-pub fn main() void {
-    var a: u32 = 0;
-    if (a == 0) {
-        comptime var b: u32 = 0;
-        b = 1;
-    }
-}
-comptime {
-    var x: i32 = 1;
-    x += 1;
-    if (x != 2) unreachable;
-}
-
-// run
-//
diff --git a/test/incremental/x86_64-linux/comptime_var.6.zig b/test/incremental/x86_64-linux/comptime_var.6.zig
deleted file mode 100644
index 2790949561cb9d11c777288410d34feebc35a1f0..0000000000000000000000000000000000000000
--- a/test/incremental/x86_64-linux/comptime_var.6.zig
+++ /dev/null
@@ -1,20 +0,0 @@
-pub fn main() void {
-    comptime var i: u64 = 2;
-    inline while (i < 6) : (i += 1) {
-        print(i);
-    }
-}
-fn print(len: usize) void {
-    asm volatile ("syscall"
-        :
-        : [number] "{rax}" (1),
-          [arg1] "{rdi}" (1),
-          [arg2] "{rsi}" (@ptrToInt("Hello")),
-          [arg3] "{rdx}" (len),
-        : "rcx", "r11", "memory"
-    );
-}
-
-// run
-//
-// HeHelHellHello
diff --git a/test/incremental/x86_64-linux/hello_world_with_updates.0.zig b/test/incremental/x86_64-linux/hello_world_with_updates.0.zig
deleted file mode 100644
index 47b5e9db7abbcfbe9c42c409e943dffeeb988272..0000000000000000000000000000000000000000
--- a/test/incremental/x86_64-linux/hello_world_with_updates.0.zig
+++ /dev/null
@@ -1,5 +0,0 @@
-// error
-// output_mode=Exe
-// target=x86_64-linux
-//
-// :107:9: error: struct 'tmp.tmp' has no member named 'main'
diff --git a/test/incremental/x86_64-linux/hello_world_with_updates.1.zig b/test/incremental/x86_64-linux/hello_world_with_updates.1.zig
deleted file mode 100644
index 0f347b7f5069ccefb13bd680334cbba2a4beb4e7..0000000000000000000000000000000000000000
--- a/test/incremental/x86_64-linux/hello_world_with_updates.1.zig
+++ /dev/null
@@ -1,5 +0,0 @@
-pub export fn _start() noreturn {}
-
-// error
-//
-// :1:34: error: expected noreturn, found void
diff --git a/test/incremental/x86_64-linux/hello_world_with_updates.2.zig b/test/incremental/x86_64-linux/hello_world_with_updates.2.zig
deleted file mode 100644
index fcea1870ce59ef67264c3be650beafabbd5a97e3..0000000000000000000000000000000000000000
--- a/test/incremental/x86_64-linux/hello_world_with_updates.2.zig
+++ /dev/null
@@ -1,32 +0,0 @@
-pub export fn _start() noreturn {
-    print();
-
-    exit();
-}
-
-fn print() void {
-    asm volatile ("syscall"
-        :
-        : [number] "{rax}" (1),
-          [arg1] "{rdi}" (1),
-          [arg2] "{rsi}" (@ptrToInt("Hello, World!\n")),
-          [arg3] "{rdx}" (14),
-        : "rcx", "r11", "memory"
-    );
-    return;
-}
-
-fn exit() noreturn {
-    asm volatile ("syscall"
-        :
-        : [number] "{rax}" (231),
-          [arg1] "{rdi}" (0),
-        : "rcx", "r11", "memory"
-    );
-    unreachable;
-}
-
-// run
-//
-// Hello, World!
-//
diff --git a/test/incremental/x86_64-linux/hello_world_with_updates.3.zig b/test/incremental/x86_64-linux/hello_world_with_updates.3.zig
deleted file mode 100644
index 7812023372e14acc9c4c93441e913126d1e7de1d..0000000000000000000000000000000000000000
--- a/test/incremental/x86_64-linux/hello_world_with_updates.3.zig
+++ /dev/null
@@ -1,20 +0,0 @@
-pub fn main() void {
-    print();
-}
-
-fn print() void {
-    asm volatile ("syscall"
-        :
-        : [number] "{rax}" (1),
-          [arg1] "{rdi}" (1),
-          [arg2] "{rsi}" (@ptrToInt("Hello, World!\n")),
-          [arg3] "{rdx}" (14),
-        : "rcx", "r11", "memory"
-    );
-    return;
-}
-
-// run
-//
-// Hello, World!
-//
diff --git a/test/incremental/x86_64-linux/hello_world_with_updates.4.zig b/test/incremental/x86_64-linux/hello_world_with_updates.4.zig
deleted file mode 100644
index cdf47012b8306d2a234871842bfe00da550522de..0000000000000000000000000000000000000000
--- a/test/incremental/x86_64-linux/hello_world_with_updates.4.zig
+++ /dev/null
@@ -1,20 +0,0 @@
-pub fn main() void {
-    print();
-}
-
-fn print() void {
-    asm volatile ("syscall"
-        :
-        : [number] "{rax}" (1),
-          [arg1] "{rdi}" (1),
-          [arg2] "{rsi}" (@ptrToInt("What is up? This is a longer message that will force the data to be relocated in virtual address space.\n")),
-          [arg3] "{rdx}" (104),
-        : "rcx", "r11", "memory"
-    );
-    return;
-}
-
-// run
-//
-// What is up? This is a longer message that will force the data to be relocated in virtual address space.
-//
diff --git a/test/incremental/x86_64-linux/hello_world_with_updates.5.zig b/test/incremental/x86_64-linux/hello_world_with_updates.5.zig
deleted file mode 100644
index 68c1e305f713135321cd2000bdd9b50dc2020c8e..0000000000000000000000000000000000000000
--- a/test/incremental/x86_64-linux/hello_world_with_updates.5.zig
+++ /dev/null
@@ -1,22 +0,0 @@
-pub fn main() void {
-    print();
-    print();
-}
-
-fn print() void {
-    asm volatile ("syscall"
-        :
-        : [number] "{rax}" (1),
-          [arg1] "{rdi}" (1),
-          [arg2] "{rsi}" (@ptrToInt("What is up? This is a longer message that will force the data to be relocated in virtual address space.\n")),
-          [arg3] "{rdx}" (104),
-        : "rcx", "r11", "memory"
-    );
-    return;
-}
-
-// run
-//
-// What is up? This is a longer message that will force the data to be relocated in virtual address space.
-// What is up? This is a longer message that will force the data to be relocated in virtual address space.
-//
diff --git a/test/incremental/x86_64-linux/inline_assembly.0.zig b/test/incremental/x86_64-linux/inline_assembly.0.zig
deleted file mode 100644
index e3c0f3badbb61fa8a53a63bcabb7b90edbe4657b..0000000000000000000000000000000000000000
--- a/test/incremental/x86_64-linux/inline_assembly.0.zig
+++ /dev/null
@@ -1,16 +0,0 @@
-pub fn main() void {
-    const number = 1234;
-    const x = asm volatile ("syscall"
-        : [o] "{rax}" (-> number),
-        : [number] "{rax}" (231),
-          [arg1] "{rdi}" (60),
-        : "rcx", "r11", "memory"
-    );
-    _ = x;
-}
-
-// error
-// output_mode=Exe
-// target=x86_64-linux
-//
-// :4:27: error: expected type, found comptime_int
diff --git a/test/incremental/x86_64-linux/inline_assembly.1.zig b/test/incremental/x86_64-linux/inline_assembly.1.zig
deleted file mode 100644
index b35014b0f6b6afa26cd92e7496edbc70c2b90dbf..0000000000000000000000000000000000000000
--- a/test/incremental/x86_64-linux/inline_assembly.1.zig
+++ /dev/null
@@ -1,15 +0,0 @@
-const S = struct {
-    comptime {
-        asm volatile (
-            \\zig_moment:
-            \\syscall
-        );
-    }
-};
-pub fn main() void {
-    _ = S;
-}
-
-// error
-//
-// :3:13: error: volatile is meaningless on global assembly
diff --git a/test/incremental/x86_64-linux/inline_assembly.2.zig b/test/incremental/x86_64-linux/inline_assembly.2.zig
deleted file mode 100644
index 1695265ab4ebcbb6a2625bb9abdffb0d751eec07..0000000000000000000000000000000000000000
--- a/test/incremental/x86_64-linux/inline_assembly.2.zig
+++ /dev/null
@@ -1,12 +0,0 @@
-pub fn main() void {
-    var bruh: u32 = 1;
-    asm (""
-        :
-        : [bruh] "{rax}" (4)
-        : "memory"
-    );
-}
-
-// error
-//
-// :3:5: error: assembly expression with no output must be marked volatile
diff --git a/test/incremental/x86_64-linux/inline_assembly.3.zig b/test/incremental/x86_64-linux/inline_assembly.3.zig
deleted file mode 100644
index 765eaeb97eb2f8373afff7399051a2fca6269070..0000000000000000000000000000000000000000
--- a/test/incremental/x86_64-linux/inline_assembly.3.zig
+++ /dev/null
@@ -1,12 +0,0 @@
-pub fn main() void {}
-comptime {
-    asm (""
-        :
-        : [bruh] "{rax}" (4)
-        : "memory"
-    );
-}
-
-// error
-//
-// :3:5: error: global assembly cannot have inputs, outputs, or clobbers
diff --git a/test/incremental/x86_64-linux/only_1_function_and_it_gets_updated.0.zig b/test/incremental/x86_64-linux/only_1_function_and_it_gets_updated.0.zig
deleted file mode 100644
index ecba1c8133714f48d0423b98c9a213a057550ad1..0000000000000000000000000000000000000000
--- a/test/incremental/x86_64-linux/only_1_function_and_it_gets_updated.0.zig
+++ /dev/null
@@ -1,13 +0,0 @@
-pub export fn _start() noreturn {
-    asm volatile ("syscall"
-        :
-        : [number] "{rax}" (60), // exit
-          [arg1] "{rdi}" (0),
-        : "rcx", "r11", "memory"
-    );
-    unreachable;
-}
-
-// run
-// target=x86_64-linux
-//
diff --git a/test/incremental/x86_64-linux/only_1_function_and_it_gets_updated.1.zig b/test/incremental/x86_64-linux/only_1_function_and_it_gets_updated.1.zig
deleted file mode 100644
index 529acbcf38132bb09f0a47adc2a128ac7c7b7ac5..0000000000000000000000000000000000000000
--- a/test/incremental/x86_64-linux/only_1_function_and_it_gets_updated.1.zig
+++ /dev/null
@@ -1,12 +0,0 @@
-pub export fn _start() noreturn {
-    asm volatile ("syscall"
-        :
-        : [number] "{rax}" (231), // exit_group
-          [arg1] "{rdi}" (0),
-        : "rcx", "r11", "memory"
-    );
-    unreachable;
-}
-
-// run
-//
diff --git a/test/incremental/x86_64-macos/assert_function.0.zig b/test/incremental/x86_64-macos/assert_function.0.zig
deleted file mode 100644
index 20e5cf0b97a96116457be9805f66190f5d7f8b4c..0000000000000000000000000000000000000000
--- a/test/incremental/x86_64-macos/assert_function.0.zig
+++ /dev/null
@@ -1,15 +0,0 @@
-pub fn main() void {
-    add(3, 4);
-}
-
-fn add(a: u32, b: u32) void {
-    assert(a + b == 7);
-}
-
-pub fn assert(ok: bool) void {
-    if (!ok) unreachable; // assertion failure
-}
-
-// run
-// target=x86_64-macos
-//
diff --git a/test/incremental/x86_64-macos/assert_function.1.zig b/test/incremental/x86_64-macos/assert_function.1.zig
deleted file mode 100644
index ac2df25d8556c661b48a9382d200283073d5d00b..0000000000000000000000000000000000000000
--- a/test/incremental/x86_64-macos/assert_function.1.zig
+++ /dev/null
@@ -1,17 +0,0 @@
-pub fn main() void {
-    add(3, 4);
-}
-
-fn add(a: u32, b: u32) void {
-    const c = a + b; // 7
-    const d = a + c; // 10
-    const e = d + b; // 14
-    assert(e == 14);
-}
-
-pub fn assert(ok: bool) void {
-    if (!ok) unreachable; // assertion failure
-}
-
-// run
-//
diff --git a/test/incremental/x86_64-macos/assert_function.10.zig b/test/incremental/x86_64-macos/assert_function.10.zig
deleted file mode 100644
index b3f1610cd62b71553f20959ef9cf4cec51d8f498..0000000000000000000000000000000000000000
--- a/test/incremental/x86_64-macos/assert_function.10.zig
+++ /dev/null
@@ -1,27 +0,0 @@
-pub fn main() void {
-    assert(add(3, 4) == 116);
-}
-
-fn add(a: u32, b: u32) u32 {
-    const x: u32 = blk: {
-        const c = a + b; // 7
-        const d = a + c; // 10
-        const e = d + b; // 14
-        const f = d + e; // 24
-        const g = e + f; // 38
-        const h = f + g; // 62
-        const i = g + h; // 100
-        const j = i + d; // 110
-        break :blk j;
-    };
-    const y = x + a; // 113
-    const z = y + a; // 116
-    return z;
-}
-
-pub fn assert(ok: bool) void {
-    if (!ok) unreachable; // assertion failure
-}
-
-// run
-//
diff --git a/test/incremental/x86_64-macos/assert_function.11.zig b/test/incremental/x86_64-macos/assert_function.11.zig
deleted file mode 100644
index d64130a6775b250ca18a5900e912391dc732a7f7..0000000000000000000000000000000000000000
--- a/test/incremental/x86_64-macos/assert_function.11.zig
+++ /dev/null
@@ -1,66 +0,0 @@
-pub fn main() void {
-    assert(add(3, 4) == 1221);
-    assert(mul(3, 4) == 21609);
-}
-
-fn add(a: u32, b: u32) u32 {
-    const x: u32 = blk: {
-        const c = a + b; // 7
-        const d = a + c; // 10
-        const e = d + b; // 14
-        const f = d + e; // 24
-        const g = e + f; // 38
-        const h = f + g; // 62
-        const i = g + h; // 100
-        const j = i + d; // 110
-        const k = i + j; // 210
-        const l = j + k; // 320
-        const m = l + c; // 327
-        const n = m + d; // 337
-        const o = n + e; // 351
-        const p = o + f; // 375
-        const q = p + g; // 413
-        const r = q + h; // 475
-        const s = r + i; // 575
-        const t = s + j; // 685
-        const u = t + k; // 895
-        const v = u + l; // 1215
-        break :blk v;
-    };
-    const y = x + a; // 1218
-    const z = y + a; // 1221
-    return z;
-}
-
-fn mul(a: u32, b: u32) u32 {
-    const x: u32 = blk: {
-        const c = a * a * a * a; // 81
-        const d = a * a * a * b; // 108
-        const e = a * a * b * a; // 108
-        const f = a * a * b * b; // 144
-        const g = a * b * a * a; // 108
-        const h = a * b * a * b; // 144
-        const i = a * b * b * a; // 144
-        const j = a * b * b * b; // 192
-        const k = b * a * a * a; // 108
-        const l = b * a * a * b; // 144
-        const m = b * a * b * a; // 144
-        const n = b * a * b * b; // 192
-        const o = b * b * a * a; // 144
-        const p = b * b * a * b; // 192
-        const q = b * b * b * a; // 192
-        const r = b * b * b * b; // 256
-        const s = c + d + e + f + g + h + i + j + k + l + m + n + o + p + q + r; // 2401
-        break :blk s;
-    };
-    const y = x * a; // 7203
-    const z = y * a; // 21609
-    return z;
-}
-
-pub fn assert(ok: bool) void {
-    if (!ok) unreachable; // assertion failure
-}
-
-// run
-//
diff --git a/test/incremental/x86_64-macos/assert_function.12.zig b/test/incremental/x86_64-macos/assert_function.12.zig
deleted file mode 100644
index 4f64c1e0626879a2004d66080292dc7cf962065d..0000000000000000000000000000000000000000
--- a/test/incremental/x86_64-macos/assert_function.12.zig
+++ /dev/null
@@ -1,47 +0,0 @@
-pub fn main() void {
-    assert(add(3, 4) == 791);
-    assert(add(4, 3) == 79);
-}
-
-fn add(a: u32, b: u32) u32 {
-    const x: u32 = if (a < b) blk: {
-        const c = a + b; // 7
-        const d = a + c; // 10
-        const e = d + b; // 14
-        const f = d + e; // 24
-        const g = e + f; // 38
-        const h = f + g; // 62
-        const i = g + h; // 100
-        const j = i + d; // 110
-        const k = i + j; // 210
-        const l = k + c; // 217
-        const m = l + d; // 227
-        const n = m + e; // 241
-        const o = n + f; // 265
-        const p = o + g; // 303
-        const q = p + h; // 365
-        const r = q + i; // 465
-        const s = r + j; // 575
-        const t = s + k; // 785
-        break :blk t;
-    } else blk: {
-        const t = b + b + a; // 10
-        const c = a + t; // 14
-        const d = c + t; // 24
-        const e = d + t; // 34
-        const f = e + t; // 44
-        const g = f + t; // 54
-        const h = c + g; // 68
-        break :blk h + b; // 71
-    };
-    const y = x + a; // 788, 75
-    const z = y + a; // 791, 79
-    return z;
-}
-
-pub fn assert(ok: bool) void {
-    if (!ok) unreachable; // assertion failure
-}
-
-// run
-//
diff --git a/test/incremental/x86_64-macos/assert_function.13.zig b/test/incremental/x86_64-macos/assert_function.13.zig
deleted file mode 100644
index 240abf0108dbe8c08040533524872e543fd6d621..0000000000000000000000000000000000000000
--- a/test/incremental/x86_64-macos/assert_function.13.zig
+++ /dev/null
@@ -1,19 +0,0 @@
-pub fn main() void {
-    const ignore =
-        \\ cool thx
-        \\
-    ;
-    _ = ignore;
-    add('ぁ', '\x03');
-}
-
-fn add(a: u32, b: u32) void {
-    assert(a + b == 12356);
-}
-
-pub fn assert(ok: bool) void {
-    if (!ok) unreachable; // assertion failure
-}
-
-// run
-//
diff --git a/test/incremental/x86_64-macos/assert_function.14.zig b/test/incremental/x86_64-macos/assert_function.14.zig
deleted file mode 100644
index d25100dccee2bda1f615c2d870ee477c1252bed3..0000000000000000000000000000000000000000
--- a/test/incremental/x86_64-macos/assert_function.14.zig
+++ /dev/null
@@ -1,17 +0,0 @@
-pub fn main() void {
-    add(aa, bb);
-}
-
-const aa = 'ぁ';
-const bb = '\x03';
-
-fn add(a: u32, b: u32) void {
-    assert(a + b == 12356);
-}
-
-pub fn assert(ok: bool) void {
-    if (!ok) unreachable; // assertion failure
-}
-
-// run
-//
diff --git a/test/incremental/x86_64-macos/assert_function.15.zig b/test/incremental/x86_64-macos/assert_function.15.zig
deleted file mode 100644
index 33ae1ed5af1279b74f089003e7b9665b55c2489b..0000000000000000000000000000000000000000
--- a/test/incremental/x86_64-macos/assert_function.15.zig
+++ /dev/null
@@ -1,10 +0,0 @@
-pub fn main() void {
-    assert("hello"[0] == 'h');
-}
-
-pub fn assert(ok: bool) void {
-    if (!ok) unreachable; // assertion failure
-}
-
-// run
-//
diff --git a/test/incremental/x86_64-macos/assert_function.16.zig b/test/incremental/x86_64-macos/assert_function.16.zig
deleted file mode 100644
index eef113642324434c4af1723aac512a57192ce726..0000000000000000000000000000000000000000
--- a/test/incremental/x86_64-macos/assert_function.16.zig
+++ /dev/null
@@ -1,11 +0,0 @@
-const hello = "hello".*;
-pub fn main() void {
-    assert(hello[1] == 'e');
-}
-
-pub fn assert(ok: bool) void {
-    if (!ok) unreachable; // assertion failure
-}
-
-// run
-//
diff --git a/test/incremental/x86_64-macos/assert_function.17.zig b/test/incremental/x86_64-macos/assert_function.17.zig
deleted file mode 100644
index ac9dce3079f6444476afd65757675726390946cf..0000000000000000000000000000000000000000
--- a/test/incremental/x86_64-macos/assert_function.17.zig
+++ /dev/null
@@ -1,11 +0,0 @@
-pub fn main() void {
-    var i: u64 = 0xFFEEDDCCBBAA9988;
-    assert(i == 0xFFEEDDCCBBAA9988);
-}
-
-pub fn assert(ok: bool) void {
-    if (!ok) unreachable; // assertion failure
-}
-
-// run
-//
diff --git a/test/incremental/x86_64-macos/assert_function.18.zig b/test/incremental/x86_64-macos/assert_function.18.zig
deleted file mode 100644
index 31cf1207f3dc07541a4210641ee136eb0ba385b0..0000000000000000000000000000000000000000
--- a/test/incremental/x86_64-macos/assert_function.18.zig
+++ /dev/null
@@ -1,35 +0,0 @@
-const builtin = @import("builtin");
-
-extern "c" fn write(usize, usize, usize) usize;
-
-pub fn main() void {
-    for ("hello") |_| print();
-}
-
-fn print() void {
-    switch (builtin.os.tag) {
-        .linux => {
-            asm volatile ("syscall"
-                :
-                : [number] "{rax}" (1),
-                  [arg1] "{rdi}" (1),
-                  [arg2] "{rsi}" (@ptrToInt("hello\n")),
-                  [arg3] "{rdx}" (6),
-                : "rcx", "r11", "memory"
-            );
-        },
-        .macos => {
-            _ = write(1, @ptrToInt("hello\n"), 6);
-        },
-        else => unreachable,
-    }
-}
-
-// run
-//
-// hello
-// hello
-// hello
-// hello
-// hello
-//
diff --git a/test/incremental/x86_64-macos/assert_function.2.zig b/test/incremental/x86_64-macos/assert_function.2.zig
deleted file mode 100644
index 8c1c510486185f4116841577473c901e13528283..0000000000000000000000000000000000000000
--- a/test/incremental/x86_64-macos/assert_function.2.zig
+++ /dev/null
@@ -1,21 +0,0 @@
-pub fn main() void {
-    add(3, 4);
-}
-
-fn add(a: u32, b: u32) void {
-    const c = a + b; // 7
-    const d = a + c; // 10
-    const e = d + b; // 14
-    const f = d + e; // 24
-    const g = e + f; // 38
-    const h = f + g; // 62
-    const i = g + h; // 100
-    assert(i == 100);
-}
-
-pub fn assert(ok: bool) void {
-    if (!ok) unreachable; // assertion failure
-}
-
-// run
-//
diff --git a/test/incremental/x86_64-macos/assert_function.3.zig b/test/incremental/x86_64-macos/assert_function.3.zig
deleted file mode 100644
index a6829f8e0239f8c01f0a1e4e1cf42e9ed035176b..0000000000000000000000000000000000000000
--- a/test/incremental/x86_64-macos/assert_function.3.zig
+++ /dev/null
@@ -1,22 +0,0 @@
-pub fn main() void {
-    add(3, 4);
-}
-
-fn add(a: u32, b: u32) void {
-    const c = a + b; // 7
-    const d = a + c; // 10
-    const e = d + b; // 14
-    const f = d + e; // 24
-    const g = e + f; // 38
-    const h = f + g; // 62
-    const i = g + h; // 100
-    const j = i + d; // 110
-    assert(j == 110);
-}
-
-pub fn assert(ok: bool) void {
-    if (!ok) unreachable; // assertion failure
-}
-
-// run
-//
diff --git a/test/incremental/x86_64-macos/assert_function.4.zig b/test/incremental/x86_64-macos/assert_function.4.zig
deleted file mode 100644
index 69df4354c3eb8d72d4c91b226fbf4b4c0eddedaf..0000000000000000000000000000000000000000
--- a/test/incremental/x86_64-macos/assert_function.4.zig
+++ /dev/null
@@ -1,15 +0,0 @@
-pub fn main() void {
-    assert(add(3, 4) == 7);
-    assert(add(20, 10) == 30);
-}
-
-fn add(a: u32, b: u32) u32 {
-    return a + b;
-}
-
-pub fn assert(ok: bool) void {
-    if (!ok) unreachable; // assertion failure
-}
-
-// run
-//
diff --git a/test/incremental/x86_64-macos/assert_function.5.zig b/test/incremental/x86_64-macos/assert_function.5.zig
deleted file mode 100644
index 89f3f7df4fd3f42da6650c27dff3c8160b281860..0000000000000000000000000000000000000000
--- a/test/incremental/x86_64-macos/assert_function.5.zig
+++ /dev/null
@@ -1,19 +0,0 @@
-pub fn main() void {
-    assert(add(3, 4) == 7);
-    assert(add(20, 10) == 30);
-}
-
-fn add(a: u32, b: u32) u32 {
-    var x: u32 = undefined;
-    x = 0;
-    x += a;
-    x += b;
-    return x;
-}
-
-pub fn assert(ok: bool) void {
-    if (!ok) unreachable; // assertion failure
-}
-
-// run
-//
diff --git a/test/incremental/x86_64-macos/assert_function.6.zig b/test/incremental/x86_64-macos/assert_function.6.zig
deleted file mode 100644
index 1b1b75e68ea72902208bd0889c38202922b89a51..0000000000000000000000000000000000000000
--- a/test/incremental/x86_64-macos/assert_function.6.zig
+++ /dev/null
@@ -1,9 +0,0 @@
-pub fn main() void {
-    const a: u32 = 2;
-    const b: ?u32 = a;
-    const c = b.?;
-    if (c != 2) unreachable;
-}
-
-// run
-//
diff --git a/test/incremental/x86_64-macos/assert_function.7.zig b/test/incremental/x86_64-macos/assert_function.7.zig
deleted file mode 100644
index 27ba37029a8bee825a2676c78bcbeded35108033..0000000000000000000000000000000000000000
--- a/test/incremental/x86_64-macos/assert_function.7.zig
+++ /dev/null
@@ -1,23 +0,0 @@
-extern "c" fn write(usize, usize, usize) usize;
-
-pub fn main() void {
-    var i: u32 = 0;
-    while (i < 4) : (i += 1) print();
-    assert(i == 4);
-}
-
-fn print() void {
-    _ = write(1, @ptrToInt("hello\n"), 6);
-}
-
-pub fn assert(ok: bool) void {
-    if (!ok) unreachable; // assertion failure
-}
-
-// run
-//
-// hello
-// hello
-// hello
-// hello
-//
diff --git a/test/incremental/x86_64-macos/assert_function.8.zig b/test/incremental/x86_64-macos/assert_function.8.zig
deleted file mode 100644
index 801cd2e3be148fc847869d92babb8d92ef7a146f..0000000000000000000000000000000000000000
--- a/test/incremental/x86_64-macos/assert_function.8.zig
+++ /dev/null
@@ -1,19 +0,0 @@
-extern "c" fn write(usize, usize, usize) usize;
-
-pub fn main() void {
-    var i: u32 = 0;
-    inline while (i < 4) : (i += 1) print();
-    assert(i == 4);
-}
-
-fn print() void {
-    _ = write(1, @ptrToInt("hello\n"), 6);
-}
-
-pub fn assert(ok: bool) void {
-    if (!ok) unreachable; // assertion failure
-}
-
-// error
-//
-// :5:21: error: unable to resolve comptime value
diff --git a/test/incremental/x86_64-macos/assert_function.9.zig b/test/incremental/x86_64-macos/assert_function.9.zig
deleted file mode 100644
index c754bb771133d8b3a595ec9fe46c48c4c6408e61..0000000000000000000000000000000000000000
--- a/test/incremental/x86_64-macos/assert_function.9.zig
+++ /dev/null
@@ -1,22 +0,0 @@
-pub fn main() void {
-    assert(add(3, 4) == 20);
-}
-
-fn add(a: u32, b: u32) u32 {
-    const x: u32 = blk: {
-        const c = a + b; // 7
-        const d = a + c; // 10
-        const e = d + b; // 14
-        break :blk e;
-    };
-    const y = x + a; // 17
-    const z = y + a; // 20
-    return z;
-}
-
-pub fn assert(ok: bool) void {
-    if (!ok) unreachable; // assertion failure
-}
-
-// run
-//
diff --git a/test/incremental/x86_64-macos/comptime_var.0.zig b/test/incremental/x86_64-macos/comptime_var.0.zig
deleted file mode 100644
index da82b35c6fb12795af2ce139adc3766a5ee53483..0000000000000000000000000000000000000000
--- a/test/incremental/x86_64-macos/comptime_var.0.zig
+++ /dev/null
@@ -1,12 +0,0 @@
-pub fn main() void {
-    var a: u32 = 0;
-    comptime var b: u32 = 0;
-    if (a == 0) b = 3;
-}
-
-// error
-// output_mode=Exe
-// target=x86_64-macos
-//
-// :4:21: error: store to comptime variable depends on runtime condition
-// :4:11: note: runtime condition here
diff --git a/test/incremental/x86_64-macos/comptime_var.1.zig b/test/incremental/x86_64-macos/comptime_var.1.zig
deleted file mode 100644
index efc51aafe3e7572bb8815d5e75ec4e4b00761499..0000000000000000000000000000000000000000
--- a/test/incremental/x86_64-macos/comptime_var.1.zig
+++ /dev/null
@@ -1,13 +0,0 @@
-pub fn main() void {
-    var a: u32 = 0;
-    comptime var b: u32 = 0;
-    switch (a) {
-        0 => {},
-        else => b = 3,
-    }
-}
-
-// error
-//
-// :6:21: error: store to comptime variable depends on runtime condition
-// :4:13: note: runtime condition here
diff --git a/test/incremental/x86_64-macos/comptime_var.2.zig b/test/incremental/x86_64-macos/comptime_var.2.zig
deleted file mode 100644
index abd34255cdc70c519f9166c8a686d0febf5a9669..0000000000000000000000000000000000000000
--- a/test/incremental/x86_64-macos/comptime_var.2.zig
+++ /dev/null
@@ -1,17 +0,0 @@
-extern "c" fn write(usize, usize, usize) usize;
-
-pub fn main() void {
-    comptime var len: u32 = 5;
-    print(len);
-    len += 9;
-    print(len);
-}
-
-fn print(len: usize) void {
-    _ = write(1, @ptrToInt("Hello, World!\n"), len);
-}
-
-// run
-//
-// HelloHello, World!
-//
diff --git a/test/incremental/x86_64-macos/comptime_var.3.zig b/test/incremental/x86_64-macos/comptime_var.3.zig
deleted file mode 100644
index 5d25d6556e4f378d4288acda9ceffcb19397230f..0000000000000000000000000000000000000000
--- a/test/incremental/x86_64-macos/comptime_var.3.zig
+++ /dev/null
@@ -1,10 +0,0 @@
-comptime {
-    var x: i32 = 1;
-    x += 1;
-    if (x != 1) unreachable;
-}
-pub fn main() void {}
-
-// error
-//
-// :4:17: error: reached unreachable code
diff --git a/test/incremental/x86_64-macos/comptime_var.4.zig b/test/incremental/x86_64-macos/comptime_var.4.zig
deleted file mode 100644
index 74da6ef448edd5534b49b1f850673863b4188b99..0000000000000000000000000000000000000000
--- a/test/incremental/x86_64-macos/comptime_var.4.zig
+++ /dev/null
@@ -1,9 +0,0 @@
-pub fn main() void {
-    comptime var i: u64 = 0;
-    while (i < 5) : (i += 1) {}
-}
-
-// error
-//
-// :3:24: error: cannot store to comptime variable in non-inline loop
-// :3:5: note: non-inline loop here
diff --git a/test/incremental/x86_64-macos/comptime_var.5.zig b/test/incremental/x86_64-macos/comptime_var.5.zig
deleted file mode 100644
index 76a06f3d4b5931e8fd23271dcc593e07ff414a7f..0000000000000000000000000000000000000000
--- a/test/incremental/x86_64-macos/comptime_var.5.zig
+++ /dev/null
@@ -1,15 +0,0 @@
-pub fn main() void {
-    var a: u32 = 0;
-    if (a == 0) {
-        comptime var b: u32 = 0;
-        b = 1;
-    }
-}
-comptime {
-    var x: i32 = 1;
-    x += 1;
-    if (x != 2) unreachable;
-}
-
-// run
-//
diff --git a/test/incremental/x86_64-macos/comptime_var.6.zig b/test/incremental/x86_64-macos/comptime_var.6.zig
deleted file mode 100644
index 381e609bd1143f8284d3323ec63266e604d6719b..0000000000000000000000000000000000000000
--- a/test/incremental/x86_64-macos/comptime_var.6.zig
+++ /dev/null
@@ -1,15 +0,0 @@
-extern "c" fn write(usize, usize, usize) usize;
-
-pub fn main() void {
-    comptime var i: u64 = 2;
-    inline while (i < 6) : (i += 1) {
-        print(i);
-    }
-}
-fn print(len: usize) void {
-    _ = write(1, @ptrToInt("Hello"), len);
-}
-
-// run
-//
-// HeHelHellHello
diff --git a/test/incremental/x86_64-macos/hello_world_with_updates.0.zig b/test/incremental/x86_64-macos/hello_world_with_updates.0.zig
deleted file mode 100644
index dd43748e6ebae04fefc21487192228666c7d15ed..0000000000000000000000000000000000000000
--- a/test/incremental/x86_64-macos/hello_world_with_updates.0.zig
+++ /dev/null
@@ -1,5 +0,0 @@
-// error
-// output_mode=Exe
-// target=x86_64-macos
-//
-// :107:9: error: struct 'tmp.tmp' has no member named 'main'
diff --git a/test/incremental/x86_64-macos/hello_world_with_updates.1.zig b/test/incremental/x86_64-macos/hello_world_with_updates.1.zig
deleted file mode 100644
index 909fc9ccfbcb343f761414446c0ec4d52e98aeef..0000000000000000000000000000000000000000
--- a/test/incremental/x86_64-macos/hello_world_with_updates.1.zig
+++ /dev/null
@@ -1,5 +0,0 @@
-pub export fn main() noreturn {}
-
-// error
-//
-// :1:32: error: expected noreturn, found void
diff --git a/test/incremental/x86_64-macos/hello_world_with_updates.2.zig b/test/incremental/x86_64-macos/hello_world_with_updates.2.zig
deleted file mode 100644
index fb8cb39eddf859f843ce61b068c0f6f8f9feb387..0000000000000000000000000000000000000000
--- a/test/incremental/x86_64-macos/hello_world_with_updates.2.zig
+++ /dev/null
@@ -1,19 +0,0 @@
-extern "c" fn write(usize, usize, usize) usize;
-extern "c" fn exit(usize) noreturn;
-
-pub export fn main() noreturn {
-    print();
-
-    exit(0);
-}
-
-fn print() void {
-    const msg = @ptrToInt("Hello, World!\n");
-    const len = 14;
-    _ = write(1, msg, len);
-}
-
-// run
-//
-// Hello, World!
-//
diff --git a/test/incremental/x86_64-macos/hello_world_with_updates.3.zig b/test/incremental/x86_64-macos/hello_world_with_updates.3.zig
deleted file mode 100644
index f6e233886b0a7d616f92dd11ffb4232191c997de..0000000000000000000000000000000000000000
--- a/test/incremental/x86_64-macos/hello_world_with_updates.3.zig
+++ /dev/null
@@ -1,16 +0,0 @@
-extern "c" fn write(usize, usize, usize) usize;
-
-pub fn main() void {
-    print();
-}
-
-fn print() void {
-    const msg = @ptrToInt("Hello, World!\n");
-    const len = 14;
-    _ = write(1, msg, len);
-}
-
-// run
-//
-// Hello, World!
-//
diff --git a/test/incremental/x86_64-macos/hello_world_with_updates.4.zig b/test/incremental/x86_64-macos/hello_world_with_updates.4.zig
deleted file mode 100644
index f89cef73543ce1f3e51a4e0152c0a8c367edf537..0000000000000000000000000000000000000000
--- a/test/incremental/x86_64-macos/hello_world_with_updates.4.zig
+++ /dev/null
@@ -1,22 +0,0 @@
-extern "c" fn write(usize, usize, usize) usize;
-
-pub fn main() void {
-    print();
-    print();
-    print();
-    print();
-}
-
-fn print() void {
-    const msg = @ptrToInt("Hello, World!\n");
-    const len = 14;
-    _ = write(1, msg, len);
-}
-
-// run
-//
-// Hello, World!
-// Hello, World!
-// Hello, World!
-// Hello, World!
-//
diff --git a/test/incremental/x86_64-macos/hello_world_with_updates.5.zig b/test/incremental/x86_64-macos/hello_world_with_updates.5.zig
deleted file mode 100644
index 0d7f97578afe1274d1c8e3d356ce702992edca61..0000000000000000000000000000000000000000
--- a/test/incremental/x86_64-macos/hello_world_with_updates.5.zig
+++ /dev/null
@@ -1,16 +0,0 @@
-extern "c" fn write(usize, usize, usize) usize;
-
-pub fn main() void {
-    print();
-}
-
-fn print() void {
-    const msg = @ptrToInt("What is up? This is a longer message that will force the data to be relocated in virtual address space.\n");
-    const len = 104;
-    _ = write(1, msg, len);
-}
-
-// run
-//
-// What is up? This is a longer message that will force the data to be relocated in virtual address space.
-//
diff --git a/test/incremental/x86_64-macos/hello_world_with_updates.6.zig b/test/incremental/x86_64-macos/hello_world_with_updates.6.zig
deleted file mode 100644
index 3ce2cb717639d663c2679dcdef2a4583c3c3f8ec..0000000000000000000000000000000000000000
--- a/test/incremental/x86_64-macos/hello_world_with_updates.6.zig
+++ /dev/null
@@ -1,18 +0,0 @@
-extern "c" fn write(usize, usize, usize) usize;
-
-pub fn main() void {
-    print();
-    print();
-}
-
-fn print() void {
-    const msg = @ptrToInt("What is up? This is a longer message that will force the data to be relocated in virtual address space.\n");
-    const len = 104;
-    _ = write(1, msg, len);
-}
-
-// run
-//
-// What is up? This is a longer message that will force the data to be relocated in virtual address space.
-// What is up? This is a longer message that will force the data to be relocated in virtual address space.
-//