diff --git a/lib/std/zig/parse.zig b/lib/std/zig/parse.zig
index 03473701e2818affeb90c7a95226e66c11ef4c8c..0155cf0d753be044e7c0bb500e9351d5a8e3dbb5 100644
--- a/lib/std/zig/parse.zig
+++ b/lib/std/zig/parse.zig
@@ -286,7 +286,7 @@ const Parser = struct {
                 .keyword_comptime => switch (p.token_tags[p.tok_i + 1]) {
                     .l_brace => {
                         if (doc_comment) |some| {
-                            try p.warnMsg(.{ .tag = .test_doc_comment, .token = some });
+                            try p.warnMsg(.{ .tag = .comptime_doc_comment, .token = some });
                         }
                         const comptime_token = p.nextToken();
                         const block = p.parseBlock() catch |err| switch (err) {
diff --git a/lib/std/zig/parser_test.zig b/lib/std/zig/parser_test.zig
index b72164d39093771726242a5a0cd174637415355d..c8c6199bf4a2628a647c739b7cb4b6bc67dc9656 100644
--- a/lib/std/zig/parser_test.zig
+++ b/lib/std/zig/parser_test.zig
@@ -4210,6 +4210,18 @@ test "zig fmt: remove newlines surrounding doc comment within container decl" {
     );
 }
 
+test "zig fmt: invalid else branch statement" {
+    try testError(
+        \\/// This is a doc comment for a comptime block.
+        \\comptime {}
+        \\/// This is a doc comment for a test
+        \\test "This is my test" {}
+    , &[_]Error{
+        .comptime_doc_comment,
+        .test_doc_comment,
+    });
+}
+
 test "zig fmt: invalid else branch statement" {
     try testError(
         \\comptime {
diff --git a/src/Compilation.zig b/src/Compilation.zig
index 911089df0222b9d0f00d0a2852dec7789583bafe..1d0997d20cc65e7d894c13348394d5a7247dee16 100644
--- a/src/Compilation.zig
+++ b/src/Compilation.zig
@@ -31,6 +31,7 @@ const clangMain = @import("main.zig").clangMain;
 const Module = @import("Module.zig");
 const Cache = @import("Cache.zig");
 const translate_c = @import("translate_c.zig");
+const clang = @import("clang.zig");
 const c_codegen = @import("codegen/c.zig");
 const ThreadPool = @import("ThreadPool.zig");
 const WaitGroup = @import("WaitGroup.zig");
@@ -2749,6 +2750,9 @@ pub fn totalErrorCount(self: *Compilation) usize {
             const decl = module.declPtr(key);
             if (decl.getFileScope().okToReportErrors()) {
                 total += 1;
+                if (module.cimport_errors.get(key)) |errors| {
+                    total += errors.len;
+                }
             }
         }
         if (module.emit_h) |emit_h| {
@@ -2858,6 +2862,23 @@ pub fn getAllErrorsAlloc(self: *Compilation) !AllErrors {
                 // We'll try again once parsing succeeds.
                 if (decl.getFileScope().okToReportErrors()) {
                     try AllErrors.add(module, &arena, &errors, entry.value_ptr.*.*);
+                    if (module.cimport_errors.get(entry.key_ptr.*)) |cimport_errors| for (cimport_errors) |c_error| {
+                        if (c_error.path) |some|
+                            try errors.append(.{
+                                .src = .{
+                                    .src_path = try arena_allocator.dupe(u8, std.mem.span(some)),
+                                    .span = .{ .start = c_error.offset, .end = c_error.offset + 1, .main = c_error.offset },
+                                    .msg = try arena_allocator.dupe(u8, std.mem.span(c_error.msg)),
+                                    .line = c_error.line,
+                                    .column = c_error.column,
+                                    .source_line = if (c_error.source_line) |line| try arena_allocator.dupe(u8, std.mem.span(line)) else null,
+                                },
+                            })
+                        else
+                            try errors.append(.{
+                                .plain = .{ .msg = try arena_allocator.dupe(u8, std.mem.span(c_error.msg)) },
+                            });
+                    };
                 }
             }
         }
@@ -3524,7 +3545,7 @@ test "cImport" {
 
 const CImportResult = struct {
     out_zig_path: []u8,
-    errors: []translate_c.ClangErrMsg,
+    errors: []clang.ErrorMsg,
 };
 
 /// Caller owns returned memory.
@@ -3599,7 +3620,7 @@ pub fn cImport(comp: *Compilation, c_src: []const u8) !CImportResult {
 
         const c_headers_dir_path = try comp.zig_lib_directory.join(arena, &[_][]const u8{"include"});
         const c_headers_dir_path_z = try arena.dupeZ(u8, c_headers_dir_path);
-        var clang_errors: []translate_c.ClangErrMsg = &[0]translate_c.ClangErrMsg{};
+        var clang_errors: []clang.ErrorMsg = &[0]clang.ErrorMsg{};
         var tree = translate_c.translate(
             comp.gpa,
             new_argv.ptr,
@@ -3665,7 +3686,7 @@ pub fn cImport(comp: *Compilation, c_src: []const u8) !CImportResult {
     }
     return CImportResult{
         .out_zig_path = out_zig_path,
-        .errors = &[0]translate_c.ClangErrMsg{},
+        .errors = &[0]clang.ErrorMsg{},
     };
 }
 
diff --git a/src/Module.zig b/src/Module.zig
index 57745a32765fa0d0953d043b539c5cb7342f3832..83294f30687ec0a5dac171a8ad98bd85318dc6c0 100644
--- a/src/Module.zig
+++ b/src/Module.zig
@@ -31,6 +31,7 @@ const target_util = @import("target.zig");
 const build_options = @import("build_options");
 const Liveness = @import("Liveness.zig");
 const isUpDir = @import("introspect.zig").isUpDir;
+const clang = @import("clang.zig");
 
 /// General-purpose allocator. Used for both temporary and long-term storage.
 gpa: Allocator,
@@ -111,6 +112,9 @@ failed_embed_files: std.AutoArrayHashMapUnmanaged(*EmbedFile, *ErrorMsg) = .{},
 /// Using a map here for consistency with the other fields here.
 /// The ErrorMsg memory is owned by the `Export`, using Module's general purpose allocator.
 failed_exports: std.AutoArrayHashMapUnmanaged(*Export, *ErrorMsg) = .{},
+/// If a decl failed due to a cimport error, the corresponding Clang errors
+/// are stored here.
+cimport_errors: std.AutoArrayHashMapUnmanaged(Decl.Index, []CImportError) = .{},
 
 /// Candidates for deletion. After a semantic analysis update completes, this list
 /// contains Decls that need to be deleted if they end up having no references to them.
@@ -172,6 +176,21 @@ reference_table: std.AutoHashMapUnmanaged(Decl.Index, struct {
     src: LazySrcLoc,
 }) = .{},
 
+pub const CImportError = struct {
+    offset: u32,
+    line: u32,
+    column: u32,
+    path: ?[*:0]u8,
+    source_line: ?[*:0]u8,
+    msg: [*:0]u8,
+
+    pub fn deinit(err: CImportError, gpa: Allocator) void {
+        if (err.path) |some| gpa.free(std.mem.span(some));
+        if (err.source_line) |some| gpa.free(std.mem.span(some));
+        gpa.free(std.mem.span(err.msg));
+    }
+};
+
 pub const StringLiteralContext = struct {
     bytes: *ArrayListUnmanaged(u8),
 
@@ -3449,6 +3468,11 @@ pub fn deinit(mod: *Module) void {
     }
     mod.failed_exports.deinit(gpa);
 
+    for (mod.cimport_errors.values()) |errs| {
+        for (errs) |err| err.deinit(gpa);
+    }
+    mod.cimport_errors.deinit(gpa);
+
     mod.compile_log_decls.deinit(gpa);
 
     for (mod.decl_exports.values()) |*export_list| {
@@ -5381,6 +5405,9 @@ pub fn clearDecl(
     if (mod.failed_decls.fetchSwapRemove(decl_index)) |kv| {
         kv.value.destroy(gpa);
     }
+    if (mod.cimport_errors.fetchSwapRemove(decl_index)) |kv| {
+        for (kv.value) |err| err.deinit(gpa);
+    }
     if (mod.emit_h) |emit_h| {
         if (emit_h.failed_decls.fetchSwapRemove(decl_index)) |kv| {
             kv.value.destroy(gpa);
@@ -5768,6 +5795,9 @@ fn markOutdatedDecl(mod: *Module, decl_index: Decl.Index) !void {
     if (mod.failed_decls.fetchSwapRemove(decl_index)) |kv| {
         kv.value.destroy(mod.gpa);
     }
+    if (mod.cimport_errors.fetchSwapRemove(decl_index)) |kv| {
+        for (kv.value) |err| err.deinit(mod.gpa);
+    }
     if (decl.has_tv and decl.owns_tv) {
         if (decl.val.castTag(.function)) |payload| {
             const func = payload.data;
diff --git a/src/Sema.zig b/src/Sema.zig
index 885cdeb277c25e0bfc1ce0a3f2c3b788aab15c78..8c7c8b0dd712882afacceca170b479a59b90e8d9 100644
--- a/src/Sema.zig
+++ b/src/Sema.zig
@@ -2257,6 +2257,9 @@ fn failWithOwnedErrorMsg(sema: *Sema, err_msg: *Module.ErrorMsg) CompileError {
         sema.owner_decl.analysis = .sema_failure;
         sema.owner_decl.generation = mod.generation;
     }
+    if (sema.func) |func| {
+        func.state = .sema_failure;
+    }
     const gop = mod.failed_decls.getOrPutAssumeCapacity(sema.owner_decl_index);
     if (gop.found_existing) {
         // If there are multiple errors for the same Decl, prefer the first one added.
@@ -4109,6 +4112,8 @@ fn validateUnionInit(
         const union_init = try sema.addConstant(union_ty, union_val);
         try sema.storePtr2(block, init_src, union_ptr, init_src, union_init, init_src, .store);
         return;
+    } else if (try sema.typeRequiresComptime(union_ty)) {
+        return sema.failWithNeededComptime(block, field_ptr_data.src(), "initializer of comptime only union must be comptime-known");
     }
 
     const new_tag = try sema.addConstant(tag_ty, tag_val);
@@ -4226,6 +4231,7 @@ fn validateStructInit(
     var first_block_index = block.instructions.items.len;
     var make_runtime = false;
 
+    const require_comptime = try sema.typeRequiresComptime(struct_ty);
     const air_tags = sema.air_instructions.items(.tag);
     const air_datas = sema.air_instructions.items(.data);
 
@@ -4301,6 +4307,9 @@ fn validateStructInit(
                 }
                 if (try sema.resolveMaybeUndefValAllowVariablesMaybeRuntime(bin_op.rhs, &make_runtime)) |val| {
                     field_values[i] = val;
+                } else if (require_comptime) {
+                    const field_ptr_data = sema.code.instructions.items(.data)[field_ptr].pl_node;
+                    return sema.failWithNeededComptime(block, field_ptr_data.src(), "initializer of comptime only struct must be comptime-known");
                 } else {
                     struct_is_comptime = false;
                 }
@@ -5121,20 +5130,58 @@ fn zirCImport(sema: *Sema, parent_block: *Block, inst: Zir.Inst.Index) CompileEr
 
     if (c_import_res.errors.len != 0) {
         const msg = msg: {
+            defer @import("clang.zig").ErrorMsg.delete(c_import_res.errors.ptr, c_import_res.errors.len);
+
             const msg = try sema.errMsg(&child_block, src, "C import failed", .{});
             errdefer msg.destroy(sema.gpa);
 
             if (!mod.comp.bin_file.options.link_libc)
                 try sema.errNote(&child_block, src, msg, "libc headers not available; compilation does not link against libc", .{});
 
-            for (c_import_res.errors) |_| {
-                // TODO integrate with LazySrcLoc
-                // try mod.errNoteNonLazy(.{}, msg, "{s}", .{clang_err.msg_ptr[0..clang_err.msg_len]});
-                // if (clang_err.filename_ptr) |p| p[0..clang_err.filename_len] else "(no file)",
-                // clang_err.line + 1,
-                // clang_err.column + 1,
+            const gop = try sema.mod.cimport_errors.getOrPut(sema.gpa, sema.owner_decl_index);
+            if (!gop.found_existing) {
+                var errs = try std.ArrayListUnmanaged(Module.CImportError).initCapacity(sema.gpa, c_import_res.errors.len);
+                errdefer {
+                    for (errs.items) |err| err.deinit(sema.gpa);
+                    errs.deinit(sema.gpa);
+                }
+
+                for (c_import_res.errors) |c_error| {
+                    const path = if (c_error.filename_ptr) |some|
+                        try sema.gpa.dupeZ(u8, some[0..c_error.filename_len])
+                    else
+                        null;
+                    errdefer if (path) |some| sema.gpa.free(some);
+
+                    const c_msg = try sema.gpa.dupeZ(u8, c_error.msg_ptr[0..c_error.msg_len]);
+                    errdefer sema.gpa.free(c_msg);
+
+                    const line = line: {
+                        const source = c_error.source orelse break :line null;
+                        var start = c_error.offset;
+                        while (start > 0) : (start -= 1) {
+                            if (source[start - 1] == '\n') break;
+                        }
+                        var end = c_error.offset;
+                        while (true) : (end += 1) {
+                            if (source[end] == 0) break;
+                            if (source[end] == '\n') break;
+                        }
+                        break :line try sema.gpa.dupeZ(u8, source[start..end]);
+                    };
+                    errdefer if (line) |some| sema.gpa.free(some);
+
+                    errs.appendAssumeCapacity(.{
+                        .path = path orelse null,
+                        .source_line = line orelse null,
+                        .line = c_error.line,
+                        .column = c_error.column,
+                        .offset = c_error.offset,
+                        .msg = c_msg,
+                    });
+                }
+                gop.value_ptr.* = errs.items;
             }
-            @import("clang.zig").Stage2ErrorMsg.delete(c_import_res.errors.ptr, c_import_res.errors.len);
             break :msg msg;
         };
         return sema.failWithOwnedErrorMsg(msg);
@@ -5402,7 +5449,7 @@ fn zirExport(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!void
     const options = sema.resolveExportOptions(block, .unneeded, extra.options) catch |err| switch (err) {
         error.NeededSourceLocation => {
             _ = try sema.resolveExportOptions(block, options_src, extra.options);
-            return error.AnalysisFail;
+            unreachable;
         },
         else => |e| return e,
     };
@@ -5429,7 +5476,7 @@ fn zirExportValue(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError
     const options = sema.resolveExportOptions(block, .unneeded, extra.options) catch |err| switch (err) {
         error.NeededSourceLocation => {
             _ = try sema.resolveExportOptions(block, options_src, extra.options);
-            return error.AnalysisFail;
+            unreachable;
         },
         else => |e| return e,
     };
@@ -6379,6 +6426,7 @@ fn analyzeCall(
             }),
             else => unreachable,
         };
+        if (!is_comptime_call and module_fn.state == .sema_failure) return error.AnalysisFail;
 
         // Analyze the ZIR. The same ZIR gets analyzed into a runtime function
         // or an inlined call depending on what union tag the `label` field is
@@ -6512,7 +6560,7 @@ fn analyzeCall(
                         func_ty_info.param_types,
                         func,
                     );
-                    return error.AnalysisFail;
+                    unreachable;
                 },
                 else => |e| return e,
             };
@@ -6674,7 +6722,7 @@ fn analyzeCall(
                             uncasted_arg,
                             opts,
                         );
-                        return error.AnalysisFail;
+                        unreachable;
                     },
                     else => |e| return e,
                 };
@@ -6687,7 +6735,7 @@ fn analyzeCall(
                             uncasted_arg,
                             Module.argSrc(call_src.node_offset.x, sema.gpa, decl, i, bound_arg_src),
                         );
-                        return error.AnalysisFail;
+                        unreachable;
                     },
                     else => |e| return e,
                 };
@@ -6991,7 +7039,7 @@ fn instantiateGenericCall(
                         const decl = sema.mod.declPtr(block.src_decl);
                         const arg_src = Module.argSrc(call_src.node_offset.x, sema.gpa, decl, i, bound_arg_src);
                         _ = try sema.analyzeGenericCallArgVal(block, arg_src, uncasted_args[i]);
-                        return error.AnalysisFail;
+                        unreachable;
                     },
                     else => |e| return e,
                 };
@@ -7174,7 +7222,7 @@ fn instantiateGenericCall(
                             const decl = sema.mod.declPtr(block.src_decl);
                             const arg_src = Module.argSrc(call_src.node_offset.x, sema.gpa, decl, arg_i, bound_arg_src);
                             _ = try sema.resolveConstValue(block, arg_src, arg, "argument to parameter with comptime-only type must be comptime-known");
-                            return error.AnalysisFail;
+                            unreachable;
                         },
                         else => |e| return e,
                     };
@@ -7330,7 +7378,7 @@ fn instantiateGenericCall(
                         new_fn_info,
                         &runtime_i,
                     );
-                    return error.AnalysisFail;
+                    unreachable;
                 },
                 else => |e| return e,
             };
@@ -8417,6 +8465,10 @@ fn funcCommon(
         const param_types = try sema.arena.alloc(Type, block.params.items.len);
         const comptime_params = try sema.arena.alloc(bool, block.params.items.len);
         for (block.params.items) |param, i| {
+            const is_noalias = blk: {
+                const index = std.math.cast(u5, i) orelse break :blk false;
+                break :blk @truncate(u1, noalias_bits >> index) != 0;
+            };
             param_types[i] = param.ty;
             sema.analyzeParameter(
                 block,
@@ -8427,6 +8479,7 @@ fn funcCommon(
                 &is_generic,
                 cc_resolved,
                 has_body,
+                is_noalias,
             ) catch |err| switch (err) {
                 error.NeededSourceLocation => {
                     const decl = sema.mod.declPtr(block.src_decl);
@@ -8439,8 +8492,9 @@ fn funcCommon(
                         &is_generic,
                         cc_resolved,
                         has_body,
+                        is_noalias,
                     );
-                    return error.AnalysisFail;
+                    unreachable;
                 },
                 else => |e| return e,
             };
@@ -8689,6 +8743,7 @@ fn analyzeParameter(
     is_generic: *bool,
     cc: std.builtin.CallingConvention,
     has_body: bool,
+    is_noalias: bool,
 ) !void {
     const requires_comptime = try sema.typeRequiresComptime(param.ty);
     comptime_params[i] = param.is_comptime or requires_comptime;
@@ -8743,6 +8798,9 @@ fn analyzeParameter(
         };
         return sema.failWithOwnedErrorMsg(msg);
     }
+    if (!this_generic and is_noalias and !param.ty.isPtrAtRuntime()) {
+        return sema.fail(block, param_src, "non-pointer parameter declared noalias", .{});
+    }
 }
 
 fn zirParam(
@@ -10633,7 +10691,7 @@ fn zirSwitchBlock(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError
                             const case_src = Module.SwitchProngSrc{ .range = .{ .prong = multi_i, .item = range_i } };
                             const decl = sema.mod.declPtr(case_block.src_decl);
                             try sema.emitBackwardBranch(block, case_src.resolve(sema.gpa, decl, src_node_offset, .none));
-                            return error.AnalysisFail;
+                            unreachable;
                         },
                         else => return err,
                     };
@@ -10669,7 +10727,7 @@ fn zirSwitchBlock(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError
                         const case_src = Module.SwitchProngSrc{ .multi = .{ .prong = multi_i, .item = @intCast(u32, item_i) } };
                         const decl = sema.mod.declPtr(case_block.src_decl);
                         try sema.emitBackwardBranch(block, case_src.resolve(sema.gpa, decl, src_node_offset, .none));
-                        return error.AnalysisFail;
+                        unreachable;
                     },
                     else => return err,
                 };
@@ -11101,10 +11159,8 @@ fn resolveSwitchItemVal(
     } else |err| switch (err) {
         error.NeededSourceLocation => {
             const src = switch_prong_src.resolve(sema.gpa, sema.mod.declPtr(block.src_decl), switch_node_offset, range_expand);
-            return TypedValue{
-                .ty = item_ty,
-                .val = try sema.resolveConstValue(block, src, item, "switch prong values must be comptime-known"),
-            };
+            _ = try sema.resolveConstValue(block, src, item, "switch prong values must be comptime-known");
+            unreachable;
         },
         else => |e| return e,
     }
@@ -11618,6 +11674,21 @@ fn zirShl(
                 });
             }
         }
+        if (rhs_ty.zigTypeTag() == .Vector) {
+            var i: usize = 0;
+            while (i < rhs_ty.vectorLen()) : (i += 1) {
+                if (rhs_val.indexVectorlike(i).compareHetero(.lt, Value.zero, target)) {
+                    return sema.fail(block, rhs_src, "shift by negative amount '{}' at index '{d}'", .{
+                        rhs_val.indexVectorlike(i).fmtValue(scalar_ty, sema.mod),
+                        i,
+                    });
+                }
+            }
+        } else if (rhs_val.compareHetero(.lt, Value.zero, target)) {
+            return sema.fail(block, rhs_src, "shift by negative amount '{}'", .{
+                rhs_val.fmtValue(scalar_ty, sema.mod),
+            });
+        }
     }
 
     const runtime_src = if (maybe_lhs_val) |lhs_val| rs: {
@@ -11787,6 +11858,21 @@ fn zirShr(
                 });
             }
         }
+        if (rhs_ty.zigTypeTag() == .Vector) {
+            var i: usize = 0;
+            while (i < rhs_ty.vectorLen()) : (i += 1) {
+                if (rhs_val.indexVectorlike(i).compareHetero(.lt, Value.zero, target)) {
+                    return sema.fail(block, rhs_src, "shift by negative amount '{}' at index '{d}'", .{
+                        rhs_val.indexVectorlike(i).fmtValue(scalar_ty, sema.mod),
+                        i,
+                    });
+                }
+            }
+        } else if (rhs_val.compareHetero(.lt, Value.zero, target)) {
+            return sema.fail(block, rhs_src, "shift by negative amount '{}'", .{
+                rhs_val.fmtValue(scalar_ty, sema.mod),
+            });
+        }
         if (maybe_lhs_val) |lhs_val| {
             if (lhs_val.isUndef()) {
                 return sema.addConstUndef(lhs_ty);
@@ -14721,7 +14807,9 @@ fn analyzeCmp(
 ) CompileError!Air.Inst.Ref {
     const lhs_ty = sema.typeOf(lhs);
     const rhs_ty = sema.typeOf(rhs);
-    try sema.checkVectorizableBinaryOperands(block, src, lhs_ty, rhs_ty, lhs_src, rhs_src);
+    if (lhs_ty.zigTypeTag() != .Optional and rhs_ty.zigTypeTag() != .Optional) {
+        try sema.checkVectorizableBinaryOperands(block, src, lhs_ty, rhs_ty, lhs_src, rhs_src);
+    }
 
     if (lhs_ty.zigTypeTag() == .Vector and rhs_ty.zigTypeTag() == .Vector) {
         return sema.cmpVector(block, src, lhs, rhs, op, lhs_src, rhs_src);
@@ -15217,12 +15305,17 @@ fn zirTypeInfo(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai
                         try Value.Tag.ty.create(params_anon_decl.arena(), try param_ty.copy(params_anon_decl.arena())),
                     );
 
+                const is_noalias = blk: {
+                    const index = std.math.cast(u5, i) orelse break :blk false;
+                    break :blk @truncate(u1, info.noalias_bits >> index) != 0;
+                };
+
                 const param_fields = try params_anon_decl.arena().create([3]Value);
                 param_fields.* = .{
                     // is_generic: bool,
                     Value.makeBool(is_generic),
                     // is_noalias: bool,
-                    Value.false, // TODO
+                    Value.makeBool(is_noalias),
                     // arg_type: ?type,
                     param_ty_val,
                 };
@@ -17409,7 +17502,7 @@ fn zirStructInitAnon(
             const decl = sema.mod.declPtr(block.src_decl);
             const field_src = Module.initSrc(src.node_offset.x, sema.gpa, decl, runtime_index);
             try sema.requireRuntimeBlock(block, src, field_src);
-            return error.AnalysisFail;
+            unreachable;
         },
         else => |e| return e,
     };
@@ -17474,25 +17567,31 @@ fn zirArrayInit(
     defer gpa.free(resolved_args);
     for (args[1..]) |arg, i| {
         const resolved_arg = try sema.resolveInst(arg);
-        const arg_src = src; // TODO better source location
         const elem_ty = if (array_ty.zigTypeTag() == .Struct)
             array_ty.structFieldType(i)
         else
             array_ty.elemType2();
-        resolved_args[i] = try sema.coerce(block, elem_ty, resolved_arg, arg_src);
+        resolved_args[i] = sema.coerce(block, elem_ty, resolved_arg, .unneeded) catch |err| switch (err) {
+            error.NeededSourceLocation => {
+                const decl = sema.mod.declPtr(block.src_decl);
+                const elem_src = Module.initSrc(src.node_offset.x, sema.gpa, decl, i);
+                _ = try sema.coerce(block, elem_ty, resolved_arg, elem_src);
+                unreachable;
+            },
+            else => return err,
+        };
     }
 
     if (sentinel_val) |some| {
         resolved_args[resolved_args.len - 1] = try sema.addConstant(array_ty.elemType2(), some);
     }
 
-    const opt_runtime_src: ?LazySrcLoc = for (resolved_args) |arg| {
-        const arg_src = src; // TODO better source location
+    const opt_runtime_index: ?u32 = for (resolved_args) |arg, i| {
         const comptime_known = try sema.isComptimeKnown(arg);
-        if (!comptime_known) break arg_src;
+        if (!comptime_known) break @intCast(u32, i);
     } else null;
 
-    const runtime_src = opt_runtime_src orelse {
+    const runtime_index = opt_runtime_index orelse {
         const elem_vals = try sema.arena.alloc(Value, resolved_args.len);
 
         for (resolved_args) |arg, i| {
@@ -17504,7 +17603,15 @@ fn zirArrayInit(
         return sema.addConstantMaybeRef(block, array_ty, array_val, is_ref);
     };
 
-    try sema.requireRuntimeBlock(block, src, runtime_src);
+    sema.requireRuntimeBlock(block, src, .unneeded) catch |err| switch (err) {
+        error.NeededSourceLocation => {
+            const decl = sema.mod.declPtr(block.src_decl);
+            const elem_src = Module.initSrc(src.node_offset.x, sema.gpa, decl, runtime_index);
+            try sema.requireRuntimeBlock(block, src, elem_src);
+            unreachable;
+        },
+        else => return err,
+    };
     try sema.queueFullTypeResolution(array_ty);
 
     if (is_ref) {
@@ -18502,10 +18609,47 @@ fn zirReify(sema: *Sema, block: *Block, extended: Zir.Inst.Extended.InstData, in
                 }
 
                 var buffer: Value.ToTypeBuffer = undefined;
+                const field_ty = try field_type_val.toType(&buffer).copy(new_decl_arena_allocator);
                 gop.value_ptr.* = .{
-                    .ty = try field_type_val.toType(&buffer).copy(new_decl_arena_allocator),
+                    .ty = field_ty,
                     .abi_align = @intCast(u32, (try alignment_val.getUnsignedIntAdvanced(target, sema)).?),
                 };
+
+                if (field_ty.zigTypeTag() == .Opaque) {
+                    const msg = msg: {
+                        const msg = try sema.errMsg(block, src, "opaque types have unknown size and therefore cannot be directly embedded in unions", .{});
+                        errdefer msg.destroy(sema.gpa);
+
+                        try sema.addDeclaredHereNote(msg, field_ty);
+                        break :msg msg;
+                    };
+                    return sema.failWithOwnedErrorMsg(msg);
+                }
+                if (union_obj.layout == .Extern and !try sema.validateExternType(field_ty, .union_field)) {
+                    const msg = msg: {
+                        const msg = try sema.errMsg(block, src, "extern unions cannot contain fields of type '{}'", .{field_ty.fmt(sema.mod)});
+                        errdefer msg.destroy(sema.gpa);
+
+                        const src_decl = sema.mod.declPtr(block.src_decl);
+                        try sema.explainWhyTypeIsNotExtern(msg, src.toSrcLoc(src_decl), field_ty, .union_field);
+
+                        try sema.addDeclaredHereNote(msg, field_ty);
+                        break :msg msg;
+                    };
+                    return sema.failWithOwnedErrorMsg(msg);
+                } else if (union_obj.layout == .Packed and !(validatePackedType(field_ty))) {
+                    const msg = msg: {
+                        const msg = try sema.errMsg(block, src, "packed unions cannot contain fields of type '{}'", .{field_ty.fmt(sema.mod)});
+                        errdefer msg.destroy(sema.gpa);
+
+                        const src_decl = sema.mod.declPtr(block.src_decl);
+                        try sema.explainWhyTypeIsNotPacked(msg, src.toSrcLoc(src_decl), field_ty);
+
+                        try sema.addDeclaredHereNote(msg, field_ty);
+                        break :msg msg;
+                    };
+                    return sema.failWithOwnedErrorMsg(msg);
+                }
             }
 
             if (tag_ty_field_names) |names| {
@@ -18587,21 +18731,25 @@ fn zirReify(sema: *Sema, block: *Block, extended: Zir.Inst.Extended.InstData, in
                 // is_noalias: bool,
                 const arg_is_noalias = arg_val[1].toBool();
                 // arg_type: ?type,
-                const param_type_val = arg_val[2];
+                const param_type_opt_val = arg_val[2];
 
                 if (arg_is_generic) {
                     return sema.fail(block, src, "Type.Fn.Param.is_generic must be false for @Type", .{});
                 }
 
+                const param_type_val = param_type_opt_val.optionalValue() orelse
+                    return sema.fail(block, src, "Type.Fn.Param.arg_type must be non-null for @Type", .{});
+                const param_type = try param_type_val.toType(&buf).copy(sema.arena);
+
                 if (arg_is_noalias) {
-                    noalias_bits = @as(u32, 1) << (std.math.cast(u5, i) orelse
+                    if (!param_type.isPtrAtRuntime()) {
+                        return sema.fail(block, src, "non-pointer parameter declared noalias", .{});
+                    }
+                    noalias_bits |= @as(u32, 1) << (std.math.cast(u5, i) orelse
                         return sema.fail(block, src, "this compiler implementation only supports 'noalias' on the first 32 parameters", .{}));
                 }
 
-                const param_type = param_type_val.optionalValue() orelse
-                    return sema.fail(block, src, "Type.Fn.Param.arg_type must be non-null for @Type", .{});
-
-                param_types[i] = try param_type.toType(&buf).copy(sema.arena);
+                param_types[i] = param_type;
                 comptime_params[i] = false;
             }
 
@@ -18745,13 +18893,60 @@ fn reifyStruct(
         }
 
         var buffer: Value.ToTypeBuffer = undefined;
+        const field_ty = try field_type_val.toType(&buffer).copy(new_decl_arena_allocator);
         gop.value_ptr.* = .{
-            .ty = try field_type_val.toType(&buffer).copy(new_decl_arena_allocator),
+            .ty = field_ty,
             .abi_align = abi_align,
             .default_val = default_val,
             .is_comptime = is_comptime_val.toBool(),
             .offset = undefined,
         };
+
+        if (field_ty.zigTypeTag() == .Opaque) {
+            const msg = msg: {
+                const msg = try sema.errMsg(block, src, "opaque types have unknown size and therefore cannot be directly embedded in structs", .{});
+                errdefer msg.destroy(sema.gpa);
+
+                try sema.addDeclaredHereNote(msg, field_ty);
+                break :msg msg;
+            };
+            return sema.failWithOwnedErrorMsg(msg);
+        }
+        if (field_ty.zigTypeTag() == .NoReturn) {
+            const msg = msg: {
+                const msg = try sema.errMsg(block, src, "struct fields cannot be 'noreturn'", .{});
+                errdefer msg.destroy(sema.gpa);
+
+                try sema.addDeclaredHereNote(msg, field_ty);
+                break :msg msg;
+            };
+            return sema.failWithOwnedErrorMsg(msg);
+        }
+        if (struct_obj.layout == .Extern and !try sema.validateExternType(field_ty, .struct_field)) {
+            const msg = msg: {
+                const msg = try sema.errMsg(block, src, "extern structs cannot contain fields of type '{}'", .{field_ty.fmt(sema.mod)});
+                errdefer msg.destroy(sema.gpa);
+
+                const src_decl = sema.mod.declPtr(block.src_decl);
+                try sema.explainWhyTypeIsNotExtern(msg, src.toSrcLoc(src_decl), field_ty, .struct_field);
+
+                try sema.addDeclaredHereNote(msg, field_ty);
+                break :msg msg;
+            };
+            return sema.failWithOwnedErrorMsg(msg);
+        } else if (struct_obj.layout == .Packed and !(validatePackedType(field_ty))) {
+            const msg = msg: {
+                const msg = try sema.errMsg(block, src, "packed structs cannot contain fields of type '{}'", .{field_ty.fmt(sema.mod)});
+                errdefer msg.destroy(sema.gpa);
+
+                const src_decl = sema.mod.declPtr(block.src_decl);
+                try sema.explainWhyTypeIsNotPacked(msg, src.toSrcLoc(src_decl), field_ty);
+
+                try sema.addDeclaredHereNote(msg, field_ty);
+                break :msg msg;
+            };
+            return sema.failWithOwnedErrorMsg(msg);
+        }
     }
 
     if (layout == .Packed) {
@@ -21544,7 +21739,7 @@ fn zirPrefetch(
     const options = sema.resolvePrefetchOptions(block, .unneeded, extra.rhs) catch |err| switch (err) {
         error.NeededSourceLocation => {
             _ = try sema.resolvePrefetchOptions(block, opts_src, extra.rhs);
-            return error.AnalysisFail;
+            unreachable;
         },
         else => |e| return e,
     };
@@ -21637,7 +21832,7 @@ fn zirBuiltinExtern(
     const options = sema.resolveExternOptions(block, .unneeded, extra.rhs) catch |err| switch (err) {
         error.NeededSourceLocation => {
             _ = try sema.resolveExternOptions(block, options_src, extra.rhs);
-            return error.AnalysisFail;
+            unreachable;
         },
         else => |e| return e,
     };
@@ -24493,7 +24688,7 @@ fn coerceExtra(
                 }
                 if (try sema.resolveMaybeUndefVal(inst)) |val| {
                     const result_val = try val.floatCast(sema.arena, dest_ty, target);
-                    if (!val.eql(result_val, dest_ty, sema.mod)) {
+                    if (!val.eql(result_val, inst_ty, sema.mod)) {
                         return sema.fail(
                             block,
                             inst_src,
@@ -24987,7 +25182,7 @@ const InMemoryCoercionResult = union(enum) {
                 cur = param.child;
             },
             .fn_cc => |cc| {
-                try sema.errNote(block, src, msg, "calling convention {s} cannot cast into calling convention {s}", .{ @tagName(cc.actual), @tagName(cc.wanted) });
+                try sema.errNote(block, src, msg, "calling convention '{s}' cannot cast into calling convention '{s}'", .{ @tagName(cc.actual), @tagName(cc.wanted) });
                 break;
             },
             .fn_return_type => |pair| {
@@ -26842,6 +27037,9 @@ fn coerceCompatiblePtrs(
 ) !Air.Inst.Ref {
     const inst_ty = sema.typeOf(inst);
     if (try sema.resolveMaybeUndefVal(inst)) |val| {
+        if (!val.isUndef() and val.isNull() and !dest_ty.isAllowzeroPtr()) {
+            return sema.fail(block, inst_src, "null pointer casted to type '{}'", .{dest_ty.fmt(sema.mod)});
+        }
         // The comptime Value representation is compatible with both types.
         return sema.addConstant(dest_ty, val);
     }
@@ -30177,7 +30375,7 @@ fn semaStructFields(mod: *Module, struct_obj: *Module.Struct) CompileError!void
                         const tree = try sema.getAstTree(&block_scope);
                         const init_src = containerFieldInitSrcLoc(decl, tree.*, 0, i);
                         _ = try sema.coerce(&block_scope, field.ty, init, init_src);
-                        return error.AnalysisFail;
+                        unreachable;
                     },
                     else => |e| return e,
                 };
@@ -30304,6 +30502,25 @@ fn semaUnionFields(mod: *Module, union_obj: *Module.Union) CompileError!void {
             if (int_tag_ty.zigTypeTag() != .Int and int_tag_ty.zigTypeTag() != .ComptimeInt) {
                 return sema.fail(&block_scope, tag_ty_src, "expected integer tag type, found '{}'", .{int_tag_ty.fmt(sema.mod)});
             }
+
+            if (fields_len > 0) {
+                var field_count_val: Value.Payload.U64 = .{
+                    .base = .{ .tag = .int_u64 },
+                    .data = fields_len - 1,
+                };
+                if (!(try sema.intFitsInType(Value.initPayload(&field_count_val.base), int_tag_ty, null))) {
+                    const msg = msg: {
+                        const msg = try sema.errMsg(&block_scope, tag_ty_src, "specified integer tag type cannot represent every field", .{});
+                        errdefer msg.destroy(sema.gpa);
+                        try sema.errNote(&block_scope, tag_ty_src, msg, "type '{}' cannot fit values in range 0...{d}", .{
+                            int_tag_ty.fmt(sema.mod),
+                            fields_len - 1,
+                        });
+                        break :msg msg;
+                    };
+                    return sema.failWithOwnedErrorMsg(msg);
+                }
+            }
             union_obj.tag_ty = try sema.generateUnionTagTypeNumbered(&block_scope, fields_len, provided_ty, union_obj);
             const enum_obj = union_obj.tag_ty.castTag(.enum_numbered).?.data;
             enum_field_names = &enum_obj.fields;
@@ -30379,7 +30596,7 @@ fn semaUnionFields(mod: *Module, union_obj: *Module.Union) CompileError!void {
         } else .none;
 
         if (enum_value_map) |map| {
-            if (tag_ref != .none) {
+            const copied_val = if (tag_ref != .none) blk: {
                 const tag_src = src; // TODO better source location
                 const coerced = try sema.coerce(&block_scope, int_tag_ty, tag_ref, tag_src);
                 const val = try sema.resolveConstValue(&block_scope, tag_src, coerced, "enum tag value must be comptime-known");
@@ -30387,23 +30604,31 @@ fn semaUnionFields(mod: *Module, union_obj: *Module.Union) CompileError!void {
 
                 // This puts the memory into the union arena, not the enum arena, but
                 // it is OK since they share the same lifetime.
-                const copied_val = try val.copy(decl_arena_allocator);
-                map.putAssumeCapacityContext(copied_val, {}, .{
-                    .ty = int_tag_ty,
-                    .mod = mod,
-                });
-            } else {
+                break :blk try val.copy(decl_arena_allocator);
+            } else blk: {
                 const val = if (last_tag_val) |val|
                     try sema.intAdd(val, Value.one, int_tag_ty)
                 else
                     Value.zero;
                 last_tag_val = val;
 
-                const copied_val = try val.copy(decl_arena_allocator);
-                map.putAssumeCapacityContext(copied_val, {}, .{
-                    .ty = int_tag_ty,
-                    .mod = mod,
-                });
+                break :blk try val.copy(decl_arena_allocator);
+            };
+            const gop = map.getOrPutAssumeCapacityContext(copied_val, .{
+                .ty = int_tag_ty,
+                .mod = mod,
+            });
+            if (gop.found_existing) {
+                const tree = try sema.getAstTree(&block_scope);
+                const field_src = enumFieldSrcLoc(sema.mod.declPtr(block_scope.src_decl), tree.*, src.node_offset.x, field_i);
+                const other_field_src = enumFieldSrcLoc(sema.mod.declPtr(block_scope.src_decl), tree.*, src.node_offset.x, gop.index);
+                const msg = msg: {
+                    const msg = try sema.errMsg(&block_scope, field_src, "enum tag value {} already taken", .{copied_val.fmtValue(int_tag_ty, sema.mod)});
+                    errdefer msg.destroy(gpa);
+                    try sema.errNote(&block_scope, other_field_src, msg, "other occurrence here", .{});
+                    break :msg msg;
+                };
+                return sema.failWithOwnedErrorMsg(msg);
             }
         }
 
@@ -30574,16 +30799,17 @@ fn generateUnionTagTypeNumbered(
     new_decl.name_fully_qualified = true;
     errdefer mod.abortAnonDecl(new_decl_index);
 
+    const copied_int_ty = try int_ty.copy(new_decl_arena_allocator);
     enum_obj.* = .{
         .owner_decl = new_decl_index,
-        .tag_ty = int_ty,
+        .tag_ty = copied_int_ty,
         .fields = .{},
         .values = .{},
     };
     // Here we pre-allocate the maps using the decl arena.
     try enum_obj.fields.ensureTotalCapacity(new_decl_arena_allocator, fields_len);
     try enum_obj.values.ensureTotalCapacityContext(new_decl_arena_allocator, fields_len, .{
-        .ty = int_ty,
+        .ty = copied_int_ty,
         .mod = mod,
     });
     try new_decl.finalizeNewArena(&new_decl_arena);
diff --git a/src/clang.zig b/src/clang.zig
index 36b9c71a87326b47928d5cb2f868ad57fc7dc5ca..a3a364c0ecc6a82ea0b6b20efd1f585483bc86f2 100644
--- a/src/clang.zig
+++ b/src/clang.zig
@@ -1897,13 +1897,13 @@ pub const OffsetOfNode_Kind = enum(c_int) {
     Base,
 };
 
-pub const Stage2ErrorMsg = extern struct {
+pub const ErrorMsg = extern struct {
     filename_ptr: ?[*]const u8,
     filename_len: usize,
     msg_ptr: [*]const u8,
     msg_len: usize,
     // valid until the ASTUnit is freed
-    source: ?[*]const u8,
+    source: ?[*:0]const u8,
     // 0 based
     line: c_uint,
     // 0 based
@@ -1912,14 +1912,14 @@ pub const Stage2ErrorMsg = extern struct {
     offset: c_uint,
 
     pub const delete = ZigClangErrorMsg_delete;
-    extern fn ZigClangErrorMsg_delete(ptr: [*]Stage2ErrorMsg, len: usize) void;
+    extern fn ZigClangErrorMsg_delete(ptr: [*]ErrorMsg, len: usize) void;
 };
 
 pub const LoadFromCommandLine = ZigClangLoadFromCommandLine;
 extern fn ZigClangLoadFromCommandLine(
     args_begin: [*]?[*]const u8,
     args_end: [*]?[*]const u8,
-    errors_ptr: *[*]Stage2ErrorMsg,
+    errors_ptr: *[*]ErrorMsg,
     errors_len: *usize,
     resources_path: [*:0]const u8,
 ) ?*ASTUnit;
diff --git a/src/main.zig b/src/main.zig
index 9e428a3c3a8f07785dd4b783a44bcc9dde4c76b5..a7d4dc6f033b0a08ef7e8cfbfd47523c516621d3 100644
--- a/src/main.zig
+++ b/src/main.zig
@@ -19,6 +19,7 @@ const introspect = @import("introspect.zig");
 const LibCInstallation = @import("libc_installation.zig").LibCInstallation;
 const wasi_libc = @import("wasi_libc.zig");
 const translate_c = @import("translate_c.zig");
+const clang = @import("clang.zig");
 const Cache = @import("Cache.zig");
 const target_util = @import("target.zig");
 const ThreadPool = @import("ThreadPool.zig");
@@ -3552,7 +3553,7 @@ fn cmdTranslateC(comp: *Compilation, arena: Allocator, enable_cache: bool) !void
 
         const c_headers_dir_path = try comp.zig_lib_directory.join(arena, &[_][]const u8{"include"});
         const c_headers_dir_path_z = try arena.dupeZ(u8, c_headers_dir_path);
-        var clang_errors: []translate_c.ClangErrMsg = &[0]translate_c.ClangErrMsg{};
+        var clang_errors: []clang.ErrorMsg = &[0]clang.ErrorMsg{};
         var tree = translate_c.translate(
             comp.gpa,
             new_argv.ptr,
diff --git a/src/translate_c.zig b/src/translate_c.zig
index 8ead8e6a280678e2ab6da94f83341190d807a655..47a21f5b5ce029bebc04046b690899de4823c8a6 100644
--- a/src/translate_c.zig
+++ b/src/translate_c.zig
@@ -13,8 +13,6 @@ const Tag = Node.Tag;
 
 const CallingConvention = std.builtin.CallingConvention;
 
-pub const ClangErrMsg = clang.Stage2ErrorMsg;
-
 pub const Error = std.mem.Allocator.Error;
 const MacroProcessingError = Error || error{UnexpectedMacroToken};
 const TypeError = Error || error{UnsupportedType};
@@ -350,7 +348,7 @@ pub fn translate(
     gpa: mem.Allocator,
     args_begin: [*]?[*]const u8,
     args_end: [*]?[*]const u8,
-    errors: *[]ClangErrMsg,
+    errors: *[]clang.ErrorMsg,
     resources_path: [*:0]const u8,
 ) !std.zig.Ast {
     // TODO stage2 bug
@@ -5115,10 +5113,6 @@ pub fn failDecl(c: *Context, loc: clang.SourceLocation, name: []const u8, compti
     try c.global_scope.nodes.append(try Tag.warning.create(c.arena, location_comment));
 }
 
-pub fn freeErrors(errors: []ClangErrMsg) void {
-    errors.ptr.delete(errors.len);
-}
-
 const PatternList = struct {
     patterns: []Pattern,
 
diff --git a/src/type.zig b/src/type.zig
index 93e8c4b5023e5f7ef90df66ebc3d3154069c26ee..5e6f032798a9e634531d2b634a07e1af9a3e3c62 100644
--- a/src/type.zig
+++ b/src/type.zig
@@ -177,9 +177,10 @@ pub const Type = extern union {
             .Float,
             .ComptimeFloat,
             .ComptimeInt,
-            .Vector, // TODO some vectors require is_equality_cmp==true
             => true,
 
+            .Vector => ty.elemType2().isSelfComparable(is_equality_cmp),
+
             .Bool,
             .Type,
             .Void,
diff --git a/test/behavior/union.zig b/test/behavior/union.zig
index ef1e8bf37559fe7b39a8528198c184630a3e97c7..b6ec305eacda009b125a43e28b80dc0d501ee8f9 100644
--- a/test/behavior/union.zig
+++ b/test/behavior/union.zig
@@ -1465,3 +1465,12 @@ test "Namespace-like union" {
     var a: DepType.Version.Git = .tag;
     try expect(a.frozen());
 }
+
+test "union int tag type is properly managed" {
+    const Bar = union(enum(u2)) {
+        x: bool,
+        y: u8,
+        z: u8,
+    };
+    try expect(@sizeOf(Bar) + 1 == 3);
+}
diff --git a/test/cases/compile_errors/async/Frame_of_generic_function.zig b/test/cases/compile_errors/async/Frame_of_generic_function.zig
new file mode 100644
index 0000000000000000000000000000000000000000..d90e53eb4683dba5f55a8e99388d04f47aa91390
--- /dev/null
+++ b/test/cases/compile_errors/async/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/async/async_function_depends_on_its_own_frame.zig b/test/cases/compile_errors/async/async_function_depends_on_its_own_frame.zig
new file mode 100644
index 0000000000000000000000000000000000000000..4dde5860bafc4709d376e1703df95b14ce58420f
--- /dev/null
+++ b/test/cases/compile_errors/async/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/async/async_function_indirectly_depends_on_its_own_frame.zig b/test/cases/compile_errors/async/async_function_indirectly_depends_on_its_own_frame.zig
new file mode 100644
index 0000000000000000000000000000000000000000..4dac0d4fa33fbc45db20184af0c0734552b9df81
--- /dev/null
+++ b/test/cases/compile_errors/async/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/async/bad_alignment_in_asynccall.zig b/test/cases/compile_errors/async/bad_alignment_in_asynccall.zig
new file mode 100644
index 0000000000000000000000000000000000000000..399914000994b76b44c91e8200b74dafcd7aa1be
--- /dev/null
+++ b/test/cases/compile_errors/async/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/async/const_frame_cast_to_anyframe.zig b/test/cases/compile_errors/async/const_frame_cast_to_anyframe.zig
new file mode 100644
index 0000000000000000000000000000000000000000..affdb953d72f317ea094a806b6c08aa05c135256
--- /dev/null
+++ b/test/cases/compile_errors/async/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/async/exported_async_function.zig b/test/cases/compile_errors/async/exported_async_function.zig
new file mode 100644
index 0000000000000000000000000000000000000000..b9ac591227d95ea9cf01595a357c97d4e00950fb
--- /dev/null
+++ b/test/cases/compile_errors/async/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/async/frame_called_outside_of_function_definition.zig b/test/cases/compile_errors/async/frame_called_outside_of_function_definition.zig
new file mode 100644
index 0000000000000000000000000000000000000000..d14099815287f35321510c87104e0a5831a970a6
--- /dev/null
+++ b/test/cases/compile_errors/async/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/async/frame_causes_function_to_be_async.zig b/test/cases/compile_errors/async/frame_causes_function_to_be_async.zig
new file mode 100644
index 0000000000000000000000000000000000000000..f8493b08b2c9e3374ee9c5c8297601c397964dea
--- /dev/null
+++ b/test/cases/compile_errors/async/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/async/function_with_ccc_indirectly_calling_async_function.zig b/test/cases/compile_errors/async/function_with_ccc_indirectly_calling_async_function.zig
new file mode 100644
index 0000000000000000000000000000000000000000..9fadb992b4c68407ab3c65c208d968b29123bf7a
--- /dev/null
+++ b/test/cases/compile_errors/async/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/async/indirect_recursion_of_async_functions_detected.zig b/test/cases/compile_errors/async/indirect_recursion_of_async_functions_detected.zig
new file mode 100644
index 0000000000000000000000000000000000000000..d845dc7930a73e4c85f24b57f9c6432a64bae4d3
--- /dev/null
+++ b/test/cases/compile_errors/async/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/async/invalid_suspend_in_exported_function.zig b/test/cases/compile_errors/async/invalid_suspend_in_exported_function.zig
new file mode 100644
index 0000000000000000000000000000000000000000..cfcbfba889dfd57b1260ee14df08d354f4973de4
--- /dev/null
+++ b/test/cases/compile_errors/async/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/async/non-async_function_pointer_eventually_is_inferred_to_become_async.zig b/test/cases/compile_errors/async/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/async/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/async/non_async_function_pointer_passed_to_asyncCall.zig b/test/cases/compile_errors/async/non_async_function_pointer_passed_to_asyncCall.zig
new file mode 100644
index 0000000000000000000000000000000000000000..d8ab4087e0a32dd2971c7bc51e3b662d30281bb0
--- /dev/null
+++ b/test/cases/compile_errors/async/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/async/prevent_bad_implicit_casting_of_anyframe_types.zig b/test/cases/compile_errors/async/prevent_bad_implicit_casting_of_anyframe_types.zig
new file mode 100644
index 0000000000000000000000000000000000000000..066bf1c1078762194d4d509fdf795a6362af8eff
--- /dev/null
+++ b/test/cases/compile_errors/async/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
+//
+// :3:28: error: expected type 'anyframe->i32', found 'anyframe'
+// :8:28: error: expected type 'anyframe->i32', found 'i32'
+// tmp.zig:13:29: error: expected type 'anyframe->i32', found '*@Frame(func)'
\ No newline at end of file
diff --git a/test/cases/compile_errors/async/returning_error_from_void_async_function.zig b/test/cases/compile_errors/async/returning_error_from_void_async_function.zig
new file mode 100644
index 0000000000000000000000000000000000000000..691c89a3478e21324685d27680ec26c13b0fc5f2
--- /dev/null
+++ b/test/cases/compile_errors/async/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/async/runtime-known_async_function_called.zig b/test/cases/compile_errors/async/runtime-known_async_function_called.zig
new file mode 100644
index 0000000000000000000000000000000000000000..90685ce566297391b6924ec1a56cddc2db28aa9a
--- /dev/null
+++ b/test/cases/compile_errors/async/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/async/runtime-known_function_called_with_async_keyword.zig b/test/cases/compile_errors/async/runtime-known_function_called_with_async_keyword.zig
new file mode 100644
index 0000000000000000000000000000000000000000..c66d0f9cbb557517b1e02bfd271871d2b229243e
--- /dev/null
+++ b/test/cases/compile_errors/async/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/async/wrong_frame_type_used_for_async_call.zig b/test/cases/compile_errors/async/wrong_frame_type_used_for_async_call.zig
new file mode 100644
index 0000000000000000000000000000000000000000..c02c20f495d8760272493a144f2054264cf474f6
--- /dev/null
+++ b/test/cases/compile_errors/async/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/async/wrong_type_for_argument_tuple_to_asyncCall.zig b/test/cases/compile_errors/async/wrong_type_for_argument_tuple_to_asyncCall.zig
new file mode 100644
index 0000000000000000000000000000000000000000..7a9be0a8cc6e9123a0beb597d4be2683aa7546ff
--- /dev/null
+++ b/test/cases/compile_errors/async/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/async/wrong_type_for_result_ptr_to_asyncCall.zig b/test/cases/compile_errors/async/wrong_type_for_result_ptr_to_asyncCall.zig
new file mode 100644
index 0000000000000000000000000000000000000000..b4193d4de11d50385900de8afa2b18c4ee2d3f74
--- /dev/null
+++ b/test/cases/compile_errors/async/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/bad_alignment_in_implicit_cast_from_array_pointer_to_slice.zig b/test/cases/compile_errors/bad_alignment_in_implicit_cast_from_array_pointer_to_slice.zig
new file mode 100644
index 0000000000000000000000000000000000000000..0641d8e3f9605a9a0a60efdfa8f33ad74dc732a5
--- /dev/null
+++ b/test/cases/compile_errors/bad_alignment_in_implicit_cast_from_array_pointer_to_slice.zig
@@ -0,0 +1,12 @@
+export fn a() void {
+    var x: [10]u8 = undefined;
+    var y: []align(16) u8 = &x;
+    _ = y;
+}
+
+// error
+// backend=stage2
+// target=native
+//
+// :3:29: error: expected type '[]align(16) u8', found '*[10]u8'
+// :3:29: note: pointer alignment '1' cannot cast into pointer alignment '16'
diff --git a/test/cases/compile_errors/bad_alignment_type.zig b/test/cases/compile_errors/bad_alignment_type.zig
new file mode 100644
index 0000000000000000000000000000000000000000..523ee2491ae0ca2ea388c2998b2673a1701d5302
--- /dev/null
+++ b/test/cases/compile_errors/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=stage2
+// target=native
+//
+// :2:20: error: expected type 'u32', found 'bool'
+// :6:19: error: fractional component prevents float value '12.34' from coercion to type 'u32'
diff --git a/test/cases/compile_errors/cImport_with_bogus_include.zig b/test/cases/compile_errors/cImport_with_bogus_include.zig
new file mode 100644
index 0000000000000000000000000000000000000000..e1283b11a8db98ccae3eb94bab2dc6d053017147
--- /dev/null
+++ b/test/cases/compile_errors/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=llvm
+// target=native
+//
+// :1:11: error: C import failed
+// :1:10: error: 'bogus.h' file not found
diff --git a/test/cases/compile_errors/compare_optional_to_non-optional_with_invalid_types.zig b/test/cases/compile_errors/compare_optional_to_non-optional_with_invalid_types.zig
new file mode 100644
index 0000000000000000000000000000000000000000..0339ac034e48b25ac65899dd935c7f204bd7ea31
--- /dev/null
+++ b/test/cases/compile_errors/compare_optional_to_non-optional_with_invalid_types.zig
@@ -0,0 +1,37 @@
+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 optionalVector2() void {
+    var x: ?@Vector(10, i32) = undefined;
+    var y: @Vector(11, i32) = undefined;
+    _ = (x == y);
+}
+export fn invalidChildType() void {
+    var x: ?[3]i32 = undefined;
+    var y: [3]i32 = undefined;
+    _ = (x == y);
+}
+
+// error
+// backend=llvm
+// target=native
+//
+// :4:12: error: incompatible types: '?i32' and 'comptime_int'
+// :4:10: note: type '?i32' here
+// :4:15: note: type 'comptime_int' here
+// :19:12: error: incompatible types: '?@Vector(10, i32)' and '@Vector(11, i32)'
+// :19:10: note: type '?@Vector(10, i32)' here
+// :19:15: note: type '@Vector(11, i32)' here
+// :24:12: error: operator == not allowed for type '?[3]i32'
diff --git a/test/cases/compile_errors/comptime_implicit_cast_f64_to_f32.zig b/test/cases/compile_errors/comptime_implicit_cast_f64_to_f32.zig
new file mode 100644
index 0000000000000000000000000000000000000000..3e880e5c14ba3ea9bd447a74b2119de18d632cb9
--- /dev/null
+++ b/test/cases/compile_errors/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=stage2
+// target=native
+//
+// :3:20: error: type 'f32' cannot represent float value '16777217'
diff --git a/test/cases/compile_errors/comptime_unreachable.zig b/test/cases/compile_errors/comptime_unreachable.zig
new file mode 100644
index 0000000000000000000000000000000000000000..74b35165854f2bfa0bb9552b67da998ef0251b39
--- /dev/null
+++ b/test/cases/compile_errors/comptime_unreachable.zig
@@ -0,0 +1,9 @@
+pub export fn entry() void {
+    comptime unreachable;
+}
+
+// error
+// target=native
+// backend=stage2
+//
+// :2:14: error: reached unreachable code
diff --git a/test/cases/compile_errors/constant_inside_comptime_function_has_compile_error.zig b/test/cases/compile_errors/constant_inside_comptime_function_has_compile_error.zig
new file mode 100644
index 0000000000000000000000000000000000000000..2b67390b05b2ec7e22608045d5e658810a4b596d
--- /dev/null
+++ b/test/cases/compile_errors/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/duplicate-unused_labels.zig b/test/cases/compile_errors/duplicate-unused_labels.zig
new file mode 100644
index 0000000000000000000000000000000000000000..4bfc6c596012082af8e971d5ab932f86a01c8c5c
--- /dev/null
+++ b/test/cases/compile_errors/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/embed_outside_package.zig b/test/cases/compile_errors/embed_outside_package.zig
new file mode 100644
index 0000000000000000000000000000000000000000..2003adb06199e8df8136ea6941d4ac346219f6bb
--- /dev/null
+++ b/test/cases/compile_errors/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/error_when_evaluating_return_type.zig b/test/cases/compile_errors/error_when_evaluating_return_type.zig
new file mode 100644
index 0000000000000000000000000000000000000000..647b51b475895df5652e34942dfcd26a477a34bd
--- /dev/null
+++ b/test/cases/compile_errors/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=stage2
+// target=native
+//
+// :2:19: error: expected type 'i32', found 'type'
diff --git a/test/cases/compile_errors/extern_function_pointer_mismatch.zig b/test/cases/compile_errors/extern_function_pointer_mismatch.zig
new file mode 100644
index 0000000000000000000000000000000000000000..f10a3dbdb3b9ed6e320ed776435005b5cb049fec
--- /dev/null
+++ b/test/cases/compile_errors/extern_function_pointer_mismatch.zig
@@ -0,0 +1,13 @@
+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=stage2
+// target=native
+//
+// :1:37: error: expected type 'fn(i32) i32', found 'fn(i32) callconv(.C) i32'
+// :1:37: note: calling convention 'C' cannot cast into calling convention 'Unspecified'
diff --git a/test/cases/compile_errors/floatToInt_comptime_safety.zig b/test/cases/compile_errors/floatToInt_comptime_safety.zig
new file mode 100644
index 0000000000000000000000000000000000000000..068d8e2d89385d1405af659febd7b5f5f12eb961
--- /dev/null
+++ b/test/cases/compile_errors/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=stage2
+// target=native
+//
+// :2:25: error: float value '-129.10000610351562' cannot be stored in integer type 'i8'
+// :5:25: error: float value '-1.100000023841858' cannot be stored in integer type 'u8'
+// :8:25: error: float value '256.1000061035156' cannot be stored in integer type 'u8'
diff --git a/test/cases/compile_errors/implicit_casting_null_c_pointer_to_zig_pointer.zig b/test/cases/compile_errors/implicit_casting_null_c_pointer_to_zig_pointer.zig
new file mode 100644
index 0000000000000000000000000000000000000000..b51635ad30c0329b2275b538e53490dabb5b6ee4
--- /dev/null
+++ b/test/cases/compile_errors/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=stage2
+// target=native
+//
+// :3:24: error: null pointer casted to type '*u8'
diff --git a/test/cases/compile_errors/implicit_dependency_on_libc.zig b/test/cases/compile_errors/implicit_dependency_on_libc.zig
new file mode 100644
index 0000000000000000000000000000000000000000..3ccb57ccb539f91a7a06abe7beb0c1ba90d6b0e2
--- /dev/null
+++ b/test/cases/compile_errors/implicit_dependency_on_libc.zig
@@ -0,0 +1,10 @@
+extern "c" fn exit(u8) void;
+export fn entry() void {
+    exit(0);
+}
+
+// error
+// backend=stage2
+// target=native-linux
+//
+// :1:8: error: dependency on libc must be explicitly specified in the build command
diff --git a/test/cases/compile_errors/import_outside_package.zig b/test/cases/compile_errors/import_outside_package.zig
new file mode 100644
index 0000000000000000000000000000000000000000..59a75e2745a22d2f1b84d40d0555c4e7dc1ae881
--- /dev/null
+++ b/test/cases/compile_errors/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/indexing_a_undefined_slice_at_comptime.zig b/test/cases/compile_errors/indexing_a_undefined_slice_at_comptime.zig
new file mode 100644
index 0000000000000000000000000000000000000000..ff6f77c3e4e3f9bcbf65920b586c7269b2c7df3c
--- /dev/null
+++ b/test/cases/compile_errors/indexing_a_undefined_slice_at_comptime.zig
@@ -0,0 +1,10 @@
+comptime {
+    var slice: []u8 = undefined;
+    slice[0] = 2;
+}
+
+// error
+// backend=stage2
+// target=native
+//
+// :3:10: error: use of undefined value here causes undefined behavior
diff --git a/test/cases/compile_errors/integer_cast_truncates_bits.zig b/test/cases/compile_errors/integer_cast_truncates_bits.zig
new file mode 100644
index 0000000000000000000000000000000000000000..82eb6b61cf4ea368b284e9c9887f2942548c860c
--- /dev/null
+++ b/test/cases/compile_errors/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=stage2
+// target=native
+//
+// :3:31: error: type 'u8' cannot represent integer value '300'
+// :8:22: error: type 'u8' cannot represent integer value '300'
+// :13:20: error: expected type 'u8', found 'u16'
+// :13:20: note: unsigned 8-bit int cannot represent all possible unsigned 16-bit values
+// :18:25: error: expected type 'u64', found 'i8'
+// :18:25: note: unsigned 64-bit int cannot represent all possible signed 8-bit values
diff --git a/test/cases/compile_errors/issue_4207_coerce_from_non-terminated-slice_to_terminated-pointer.zig b/test/cases/compile_errors/issue_4207_coerce_from_non-terminated-slice_to_terminated-pointer.zig
new file mode 100644
index 0000000000000000000000000000000000000000..dc5a709553d6e37a0dcf4a44761596fc7bfaeae9
--- /dev/null
+++ b/test/cases/compile_errors/issue_4207_coerce_from_non-terminated-slice_to_terminated-pointer.zig
@@ -0,0 +1,12 @@
+export fn foo() [*:0]const u8 {
+    var buffer: [64]u8 = undefined;
+    return buffer[0..];
+}
+
+// error
+// backend=stage2
+// target=native
+//
+// :3:18: error: expected type '[*:0]const u8', found '*[64]u8'
+// :3:18: note: destination pointer requires '0' sentinel
+// :1:18: note: function return type declared here
diff --git a/test/cases/compile_errors/issue_7810-comptime_slice-len_increment_beyond_bounds.zig b/test/cases/compile_errors/issue_7810-comptime_slice-len_increment_beyond_bounds.zig
new file mode 100644
index 0000000000000000000000000000000000000000..8c014ec19137e2a295979fc62334ffe3604ead5e
--- /dev/null
+++ b/test/cases/compile_errors/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: []u8 = buf_storage[0..];
+        buf.len += 1;
+        buf[8] = 42;
+    }
+}
+
+// error
+// backend=stage2
+// target=native
+//
+// :6:16: error: comptime store of index 8 out of bounds of array length 8
diff --git a/test/cases/compile_errors/lazy_pointer_with_undefined_element_type.zig b/test/cases/compile_errors/lazy_pointer_with_undefined_element_type.zig
new file mode 100644
index 0000000000000000000000000000000000000000..bffaa770ec38b619f12d820d77ab41639dc95ab7
--- /dev/null
+++ b/test/cases/compile_errors/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=stage2
+// target=native
+//
+// :3:28: error: use of undefined value here causes undefined behavior
diff --git a/test/cases/compile_errors/missing_main_fn_in_executable.zig b/test/cases/compile_errors/missing_main_fn_in_executable.zig
new file mode 100644
index 0000000000000000000000000000000000000000..2d608ad2b8be3ec5b7c45b74cc4841524f6aca77
--- /dev/null
+++ b/test/cases/compile_errors/missing_main_fn_in_executable.zig
@@ -0,0 +1,9 @@
+
+
+// error
+// backend=llvm
+// target=x86_64-linux
+// output_mode=Exe
+//
+// :?:?: error: root struct of file 'tmp' has no member named 'main'
+// :?:?: note: called from here
diff --git a/test/cases/compile_errors/missing_result_type_for_phi_node.zig b/test/cases/compile_errors/missing_result_type_for_phi_node.zig
new file mode 100644
index 0000000000000000000000000000000000000000..c4bd686b01be442a8a3676a402cb249ac5fd5905
--- /dev/null
+++ b/test/cases/compile_errors/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=stage2
+// target=native
+//
+// :5:11: error: incompatible types: 'void' and 'comptime_int'
diff --git a/test/cases/compile_errors/noalias_on_non_pointer_param.zig b/test/cases/compile_errors/noalias_on_non_pointer_param.zig
new file mode 100644
index 0000000000000000000000000000000000000000..f637013c93e41fe4c0c39ab220fc0fb01fc84966
--- /dev/null
+++ b/test/cases/compile_errors/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=stage2
+// target=native
+//
+// :1:6: error: non-pointer parameter declared noalias
diff --git a/test/cases/compile_errors/out_of_bounds_index.zig b/test/cases/compile_errors/out_of_bounds_index.zig
new file mode 100644
index 0000000000000000000000000000000000000000..3f5b71d530fdbe6f29ba8f2435a13a57f3e7b504
--- /dev/null
+++ b/test/cases/compile_errors/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:30: error: end index 6 out of bounds for slice of length 4 +1 (sentinel)
+// :9:26: error: end index 6 out of bounds for array of length 4 +1 (sentinel)
+// :14:26: error: end index 5 out of bounds for array of length 4
+// :19:23: error: start index 3 is larger than end index 2
diff --git a/test/cases/compile_errors/passing_an_under-aligned_function_pointer.zig b/test/cases/compile_errors/passing_an_under-aligned_function_pointer.zig
new file mode 100644
index 0000000000000000000000000000000000000000..3e3500e71fc7be83df960ac68438066c90fcecd3
--- /dev/null
+++ b/test/cases/compile_errors/passing_an_under-aligned_function_pointer.zig
@@ -0,0 +1,14 @@
+export fn entry() void {
+    testImplicitlyDecreaseFnAlign(alignedSmall, 1234);
+}
+fn testImplicitlyDecreaseFnAlign(ptr: *const fn () align(8) i32, answer: i32) void {
+    if (ptr() != answer) unreachable;
+}
+fn alignedSmall() align(4) i32 { return 1234; }
+
+// error
+// backend=stage2
+// target=x86_64-linux
+//
+// :2:35: error: expected type '*const fn() align(8) i32', found '*const fn() align(4) i32'
+// :2:35: note: pointer alignment '4' cannot cast into pointer alignment '8'
diff --git a/test/cases/compile_errors/private_main_fn.zig b/test/cases/compile_errors/private_main_fn.zig
new file mode 100644
index 0000000000000000000000000000000000000000..26ad3d22db880fc5003406fd86b33c203990ecd0
--- /dev/null
+++ b/test/cases/compile_errors/private_main_fn.zig
@@ -0,0 +1,10 @@
+fn main() void {}
+
+// error
+// backend=llvm
+// target=x86_64-linux
+// output_mode=Exe
+//
+// :?:?: error: 'main' is not marked 'pub'
+// :1:1: note: declared here
+// :?:?: note: called from here
diff --git a/test/cases/compile_errors/reified_enum_field_value_overflow.zig b/test/cases/compile_errors/reified_enum_field_value_overflow.zig
new file mode 100644
index 0000000000000000000000000000000000000000..ad8596ebccd724074f8222b4543984d4faf98929
--- /dev/null
+++ b/test/cases/compile_errors/reified_enum_field_value_overflow.zig
@@ -0,0 +1,20 @@
+comptime {
+    const E = @Type(.{ .Enum = .{
+        .layout = .Auto,
+        .tag_type = u1,
+        .fields = &.{
+            .{ .name = "f0", .value = 0 },
+            .{ .name = "f1", .value = 1 },
+            .{ .name = "f2", .value = 2 },
+        },
+        .decls = &.{},
+        .is_exhaustive = true,
+    } });
+    _ = E;
+}
+
+// error
+// target=native
+// backend=stage2
+//
+// :2:15: error: field 'f2' with enumeration value '2' is too large for backing int type 'u1'
diff --git a/test/cases/compile_errors/reify_type_for_union_with_opaque_field.zig b/test/cases/compile_errors/reify_type_for_union_with_opaque_field.zig
new file mode 100644
index 0000000000000000000000000000000000000000..aba11031a4b323fe3ac10ea08e012ed1ab1aeafa
--- /dev/null
+++ b/test/cases/compile_errors/reify_type_for_union_with_opaque_field.zig
@@ -0,0 +1,20 @@
+const Untagged = @Type(.{
+    .Union = .{
+        .layout = .Auto,
+        .tag_type = null,
+        .fields = &.{
+            .{ .name = "foo", .field_type = opaque {}, .alignment = 1 },
+        },
+        .decls = &.{},
+    },
+});
+export fn entry() usize {
+    return @sizeOf(Untagged);
+}
+
+// error
+// backend=stage2
+// target=native
+//
+// :1:18: error: opaque types have unknown size and therefore cannot be directly embedded in unions
+// :6:45: note: opaque declared here
diff --git a/test/cases/compile_errors/runtime_assignment_to_comptime_struct_type.zig b/test/cases/compile_errors/runtime_assignment_to_comptime_struct_type.zig
new file mode 100644
index 0000000000000000000000000000000000000000..5949031fb9266d12a054e2cecd05662365fdf930
--- /dev/null
+++ b/test/cases/compile_errors/runtime_assignment_to_comptime_struct_type.zig
@@ -0,0 +1,16 @@
+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=stage2
+// target=native
+//
+// :7:30: error: unable to resolve comptime value
+// :7:30: note: initializer of comptime only struct must be comptime-known
diff --git a/test/cases/compile_errors/runtime_assignment_to_comptime_union_type.zig b/test/cases/compile_errors/runtime_assignment_to_comptime_union_type.zig
new file mode 100644
index 0000000000000000000000000000000000000000..04e2a97e7aa095f50bf42c07ff0e03aa55274cf9
--- /dev/null
+++ b/test/cases/compile_errors/runtime_assignment_to_comptime_union_type.zig
@@ -0,0 +1,16 @@
+const Foo = union {
+    Bar: u8,
+    Baz: type,
+};
+export fn f() void {
+    var x: u8 = 0;
+    const foo = Foo { .Bar = x };
+    _ = foo;
+}
+
+// error
+// backend=stage2
+// target=native
+//
+// :7:30: error: unable to resolve comptime value
+// :7:30: note: initializer of comptime only union must be comptime-known
diff --git a/test/cases/compile_errors/saturating_shl_assign_does_not_allow_negative_rhs_at_comptime.zig b/test/cases/compile_errors/saturating_shl_assign_does_not_allow_negative_rhs_at_comptime.zig
new file mode 100644
index 0000000000000000000000000000000000000000..c8e95e3969e5b644d7ccc807c055759953d58e30
--- /dev/null
+++ b/test/cases/compile_errors/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=stage2
+// target=native
+//
+// :4:14: error: shift by negative amount '-2'
diff --git a/test/cases/compile_errors/saturating_shl_does_not_allow_negative_rhs_at_comptime.zig b/test/cases/compile_errors/saturating_shl_does_not_allow_negative_rhs_at_comptime.zig
new file mode 100644
index 0000000000000000000000000000000000000000..75fdff3a19cc66df8f147e716cf2800c54baa56d
--- /dev/null
+++ b/test/cases/compile_errors/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=stage2
+// target=native
+//
+// :2:25: error: shift by negative amount '-2'
diff --git a/test/cases/compile_errors/shift_amount_has_to_be_an_integer_type.zig b/test/cases/compile_errors/shift_amount_has_to_be_an_integer_type.zig
new file mode 100644
index 0000000000000000000000000000000000000000..ed6935315b51c39d422551ae4e58465973ee0ca2
--- /dev/null
+++ b/test/cases/compile_errors/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=stage2
+// target=native
+//
+// :2:20: error: expected type 'comptime_int', found '*const u8'
diff --git a/test/cases/compile_errors/shift_by_negative_comptime_integer.zig b/test/cases/compile_errors/shift_by_negative_comptime_integer.zig
new file mode 100644
index 0000000000000000000000000000000000000000..7d3a740e1671c7d5d6382d0e2f80f444410ecb51
--- /dev/null
+++ b/test/cases/compile_errors/shift_by_negative_comptime_integer.zig
@@ -0,0 +1,10 @@
+comptime {
+    var a = 1 >> -1;
+    _ = a;
+}
+
+// error
+// backend=stage2
+// target=native
+//
+// :2:18: error: shift by negative amount '-1'
diff --git a/test/cases/compile_errors/slice_of_null_pointer.zig b/test/cases/compile_errors/slice_of_null_pointer.zig
new file mode 100644
index 0000000000000000000000000000000000000000..7f2c74a8a62bfc65116889043afdcd75e1d04ddd
--- /dev/null
+++ b/test/cases/compile_errors/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/slice_sentinel_mismatch-1.zig b/test/cases/compile_errors/slice_sentinel_mismatch-1.zig
new file mode 100644
index 0000000000000000000000000000000000000000..60d8d9707a991ff7ee3fd3750176008edd870cc2
--- /dev/null
+++ b/test/cases/compile_errors/slice_sentinel_mismatch-1.zig
@@ -0,0 +1,11 @@
+export fn entry() void {
+    const y: [:1]const u8 = &[_:2]u8{ 1, 2 };
+    _ = y;
+}
+
+// error
+// backend=stage2
+// target=native
+//
+// :2:29: error: expected type '[:1]const u8', found '*const [2:2]u8'
+// :2:29: note: pointer sentinel '2' cannot cast into pointer sentinel '1'
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
deleted file mode 100644
index 65813abac32cf8541b18e12235a16a7cac85f6f0..0000000000000000000000000000000000000000
--- a/test/cases/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/cases/compile_errors/stage1/exe/private_main_fn.zig b/test/cases/compile_errors/stage1/exe/private_main_fn.zig
deleted file mode 100644
index 5a178389e8905d908a3b35a79fa872d9db20940e..0000000000000000000000000000000000000000
--- a/test/cases/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/cases/compile_errors/stage1/obj/Frame_of_generic_function.zig b/test/cases/compile_errors/stage1/obj/Frame_of_generic_function.zig
deleted file mode 100644
index d90e53eb4683dba5f55a8e99388d04f47aa91390..0000000000000000000000000000000000000000
--- a/test/cases/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/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
deleted file mode 100644
index 3d150693f556edec171b11cc9f0f851c57336fb2..0000000000000000000000000000000000000000
--- a/test/cases/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/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
deleted file mode 100644
index 4dde5860bafc4709d376e1703df95b14ce58420f..0000000000000000000000000000000000000000
--- a/test/cases/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/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
deleted file mode 100644
index 4dac0d4fa33fbc45db20184af0c0734552b9df81..0000000000000000000000000000000000000000
--- a/test/cases/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/cases/compile_errors/stage1/obj/bad_alignment_in_asynccall.zig b/test/cases/compile_errors/stage1/obj/bad_alignment_in_asynccall.zig
deleted file mode 100644
index 399914000994b76b44c91e8200b74dafcd7aa1be..0000000000000000000000000000000000000000
--- a/test/cases/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/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
deleted file mode 100644
index 12064bd9ab0b6b4e8c3f6789bf091d5f12721463..0000000000000000000000000000000000000000
--- a/test/cases/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/cases/compile_errors/stage1/obj/bad_alignment_type.zig b/test/cases/compile_errors/stage1/obj/bad_alignment_type.zig
deleted file mode 100644
index a4d8b7d68f6cceca709cb5b93d3b7677e4cb7d7d..0000000000000000000000000000000000000000
--- a/test/cases/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/cases/compile_errors/stage1/obj/cImport_with_bogus_include.zig b/test/cases/compile_errors/stage1/obj/cImport_with_bogus_include.zig
deleted file mode 100644
index 141f21cb9a7ef9a9534a15cd6d0955b6ddef4a5c..0000000000000000000000000000000000000000
--- a/test/cases/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/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
deleted file mode 100644
index 3081f0f1e184573eccf3625c0373233f8d4494b5..0000000000000000000000000000000000000000
--- a/test/cases/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/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
deleted file mode 100644
index 32e1fe9b246381a8b09016ac565d9ac36655b298..0000000000000000000000000000000000000000
--- a/test/cases/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/cases/compile_errors/stage1/obj/comptime_float_in_asm_input.zig b/test/cases/compile_errors/stage1/obj/comptime_float_in_asm_input.zig
deleted file mode 100644
index 92ffadc4f7b6431ae6985ae0e6ae45932c2be649..0000000000000000000000000000000000000000
--- a/test/cases/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/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
deleted file mode 100644
index af5d49c7cbf4a139206d2493864621b4dea3edd8..0000000000000000000000000000000000000000
--- a/test/cases/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/cases/compile_errors/stage1/obj/comptime_int_in_asm_input.zig b/test/cases/compile_errors/stage1/obj/comptime_int_in_asm_input.zig
deleted file mode 100644
index 3e3ccf8c2738073424d8e735b2f9ed14edc0a6dc..0000000000000000000000000000000000000000
--- a/test/cases/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/cases/compile_errors/stage1/obj/const_frame_cast_to_anyframe.zig b/test/cases/compile_errors/stage1/obj/const_frame_cast_to_anyframe.zig
deleted file mode 100644
index affdb953d72f317ea094a806b6c08aa05c135256..0000000000000000000000000000000000000000
--- a/test/cases/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/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
deleted file mode 100644
index c61ac400baf048c781f0bee5a4d779696d7583ec..0000000000000000000000000000000000000000
--- a/test/cases/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/cases/compile_errors/stage1/obj/error_when_evaluating_return_type.zig b/test/cases/compile_errors/stage1/obj/error_when_evaluating_return_type.zig
deleted file mode 100644
index 60731740b79dfaff5366a283ef4ac2b20d4d1f04..0000000000000000000000000000000000000000
--- a/test/cases/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/cases/compile_errors/stage1/obj/exported_async_function.zig b/test/cases/compile_errors/stage1/obj/exported_async_function.zig
deleted file mode 100644
index b9ac591227d95ea9cf01595a357c97d4e00950fb..0000000000000000000000000000000000000000
--- a/test/cases/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/cases/compile_errors/stage1/obj/extern_function_pointer_mismatch.zig b/test/cases/compile_errors/stage1/obj/extern_function_pointer_mismatch.zig
deleted file mode 100644
index 888b59a6265fa359aa0d97dd58c037f9d0798c75..0000000000000000000000000000000000000000
--- a/test/cases/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/cases/compile_errors/stage1/obj/floatToInt_comptime_safety.zig b/test/cases/compile_errors/stage1/obj/floatToInt_comptime_safety.zig
deleted file mode 100644
index 1e5fa746a14b4fff82df228d6d28ad5a5ff19169..0000000000000000000000000000000000000000
--- a/test/cases/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/cases/compile_errors/stage1/obj/float_literal_too_large_error.zig b/test/cases/compile_errors/stage1/obj/float_literal_too_large_error.zig
deleted file mode 100644
index c3865c31108cadfed1a77490a6a23ea861e6ee79..0000000000000000000000000000000000000000
--- a/test/cases/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/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
deleted file mode 100644
index 0b0bfee1de541f72fbbe2f9913449ca9dde3bb8b..0000000000000000000000000000000000000000
--- a/test/cases/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/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
deleted file mode 100644
index d14099815287f35321510c87104e0a5831a970a6..0000000000000000000000000000000000000000
--- a/test/cases/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/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
deleted file mode 100644
index f8493b08b2c9e3374ee9c5c8297601c397964dea..0000000000000000000000000000000000000000
--- a/test/cases/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/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
deleted file mode 100644
index 9fadb992b4c68407ab3c65c208d968b29123bf7a..0000000000000000000000000000000000000000
--- a/test/cases/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/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
deleted file mode 100644
index 0bd38d868b9bdf2c4f86bff0dec84d06b32b6ee3..0000000000000000000000000000000000000000
--- a/test/cases/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/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
deleted file mode 100644
index f142540ff6a13d2143962f9c8fa91249d3b17139..0000000000000000000000000000000000000000
--- a/test/cases/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/cases/compile_errors/stage1/obj/implicit_dependency_on_libc.zig b/test/cases/compile_errors/stage1/obj/implicit_dependency_on_libc.zig
deleted file mode 100644
index f069f785517177e26570acbf6665a8d46add25e5..0000000000000000000000000000000000000000
--- a/test/cases/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/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
deleted file mode 100644
index 70b0c68658578c3d677a82cabe80c492eac2453a..0000000000000000000000000000000000000000
--- a/test/cases/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/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
deleted file mode 100644
index d845dc7930a73e4c85f24b57f9c6432a64bae4d3..0000000000000000000000000000000000000000
--- a/test/cases/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/cases/compile_errors/stage1/obj/integer_cast_truncates_bits.zig b/test/cases/compile_errors/stage1/obj/integer_cast_truncates_bits.zig
deleted file mode 100644
index e8ef41862430fc667c6e63c74298519c4caa5a94..0000000000000000000000000000000000000000
--- a/test/cases/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/cases/compile_errors/stage1/obj/invalid_suspend_in_exported_function.zig b/test/cases/compile_errors/stage1/obj/invalid_suspend_in_exported_function.zig
deleted file mode 100644
index cfcbfba889dfd57b1260ee14df08d354f4973de4..0000000000000000000000000000000000000000
--- a/test/cases/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/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
deleted file mode 100644
index d53f7731a091272165cdd221ecc5e3be024764b3..0000000000000000000000000000000000000000
--- a/test/cases/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/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
deleted file mode 100644
index c8b2f0b09e9310836c7c7e0766c9f99f20f36e9e..0000000000000000000000000000000000000000
--- a/test/cases/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/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
deleted file mode 100644
index 733a3ca2dd89d1b97050473303a5d90cd7747c8e..0000000000000000000000000000000000000000
--- a/test/cases/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/cases/compile_errors/stage1/obj/libc_headers_note.zig b/test/cases/compile_errors/stage1/obj/libc_headers_note.zig
deleted file mode 100644
index c8d9a9cbf3aff757f4b5ce532beb1ef430f37c72..0000000000000000000000000000000000000000
--- a/test/cases/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/cases/compile_errors/stage1/obj/missing_function_call_param.zig b/test/cases/compile_errors/stage1/obj/missing_function_call_param.zig
deleted file mode 100644
index 9e08ed7140c6a50a6a19e79a42b1357a714958a4..0000000000000000000000000000000000000000
--- a/test/cases/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/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
deleted file mode 100644
index 33bc1d0d9c907934d0ba055d91b128e31bec9265..0000000000000000000000000000000000000000
--- a/test/cases/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/cases/compile_errors/stage1/obj/noalias_on_non_pointer_param.zig b/test/cases/compile_errors/stage1/obj/noalias_on_non_pointer_param.zig
deleted file mode 100644
index ca84aca73f65615812281bf10695672c6cd61207..0000000000000000000000000000000000000000
--- a/test/cases/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/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
deleted file mode 100644
index e18b4200289d80343d38cee2da9101f81916c0f5..0000000000000000000000000000000000000000
--- a/test/cases/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/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
deleted file mode 100644
index d8ab4087e0a32dd2971c7bc51e3b662d30281bb0..0000000000000000000000000000000000000000
--- a/test/cases/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/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
deleted file mode 100644
index d67bd42a72909fc074b84ed9de4f197ae388b93f..0000000000000000000000000000000000000000
--- a/test/cases/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/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
deleted file mode 100644
index 066bf1c1078762194d4d509fdf795a6362af8eff..0000000000000000000000000000000000000000
--- a/test/cases/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
-//
-// :3:28: error: expected type 'anyframe->i32', found 'anyframe'
-// :8:28: error: expected type 'anyframe->i32', found 'i32'
-// tmp.zig:13:29: error: expected type 'anyframe->i32', found '*@Frame(func)'
\ No newline at end of file
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
deleted file mode 100644
index 58cba3cd42bbd72941e1aa529842602044165906..0000000000000000000000000000000000000000
--- a/test/cases/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() usize {
-    return @sizeOf(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/returning_error_from_void_async_function.zig b/test/cases/compile_errors/stage1/obj/returning_error_from_void_async_function.zig
deleted file mode 100644
index 691c89a3478e21324685d27680ec26c13b0fc5f2..0000000000000000000000000000000000000000
--- a/test/cases/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/cases/compile_errors/stage1/obj/runtime-known_async_function_called.zig b/test/cases/compile_errors/stage1/obj/runtime-known_async_function_called.zig
deleted file mode 100644
index 90685ce566297391b6924ec1a56cddc2db28aa9a..0000000000000000000000000000000000000000
--- a/test/cases/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/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
deleted file mode 100644
index c66d0f9cbb557517b1e02bfd271871d2b229243e..0000000000000000000000000000000000000000
--- a/test/cases/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/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
deleted file mode 100644
index 62b09673eb9479c3fe9fe75f50543a25a3bdd220..0000000000000000000000000000000000000000
--- a/test/cases/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/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
deleted file mode 100644
index af13f8b8ce9068c97a8015a39fca9be4cf6b8569..0000000000000000000000000000000000000000
--- a/test/cases/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/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
deleted file mode 100644
index 7b94f8e832b9f9f53eaac1e2964c5c523a4bf003..0000000000000000000000000000000000000000
--- a/test/cases/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/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
deleted file mode 100644
index ac1ce7d3a0e14088a7a15a674a755ef1a15145e6..0000000000000000000000000000000000000000
--- a/test/cases/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/cases/compile_errors/stage1/obj/setFloatMode_twice_for_same_scope.zig b/test/cases/compile_errors/stage1/obj/setFloatMode_twice_for_same_scope.zig
deleted file mode 100644
index 41fe6d4d6c4e9d78c5fea3055843a76355d6b061..0000000000000000000000000000000000000000
--- a/test/cases/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/cases/compile_errors/stage1/obj/setRuntimeSafety_twice_for_same_scope.zig b/test/cases/compile_errors/stage1/obj/setRuntimeSafety_twice_for_same_scope.zig
deleted file mode 100644
index 03a93b68d55ffb08d1c185a5d5cbf33e5ecbdd50..0000000000000000000000000000000000000000
--- a/test/cases/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/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
deleted file mode 100644
index 53794dba1b80a07067305abb27fe5224d30a2710..0000000000000000000000000000000000000000
--- a/test/cases/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/cases/compile_errors/stage1/obj/shift_by_negative_comptime_integer.zig b/test/cases/compile_errors/stage1/obj/shift_by_negative_comptime_integer.zig
deleted file mode 100644
index 3425cf565ebe8e92485bef9f93d44dbd56d3110a..0000000000000000000000000000000000000000
--- a/test/cases/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/cases/compile_errors/stage1/obj/slice_sentinel_mismatch-1.zig b/test/cases/compile_errors/stage1/obj/slice_sentinel_mismatch-1.zig
deleted file mode 100644
index d0c47097da9b677bab22ff8cfe0f2f5c7d6de733..0000000000000000000000000000000000000000
--- a/test/cases/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/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
deleted file mode 100644
index 2d85209358de870aedd0cca812642ce672c1baa7..0000000000000000000000000000000000000000
--- a/test/cases/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/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
deleted file mode 100644
index e404c3bdd698fe4b4fa42774a841ebe7191c68c9..0000000000000000000000000000000000000000
--- a/test/cases/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/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
deleted file mode 100644
index eb7d83efff7c9049cc68118178b5dd3d29a78506..0000000000000000000000000000000000000000
--- a/test/cases/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/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
deleted file mode 100644
index 3b00f95ff953f51e464a35e0468fa40bdde282c7..0000000000000000000000000000000000000000
--- a/test/cases/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/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
deleted file mode 100644
index 38260091dc4a249657cdae7af6184db042b34177..0000000000000000000000000000000000000000
--- a/test/cases/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/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
deleted file mode 100644
index 97f4d48f6b84cc8dbf16ee1715a97a8c81b7ceab..0000000000000000000000000000000000000000
--- a/test/cases/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/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
deleted file mode 100644
index c1496ade86dc5e8bb1b8173dd6afe22602568c7c..0000000000000000000000000000000000000000
--- a/test/cases/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/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
deleted file mode 100644
index c02c20f495d8760272493a144f2054264cf474f6..0000000000000000000000000000000000000000
--- a/test/cases/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/cases/compile_errors/stage1/obj/wrong_function_type.zig b/test/cases/compile_errors/stage1/obj/wrong_function_type.zig
deleted file mode 100644
index 58f4477601d3fe33c7d688e8597adff387a5641c..0000000000000000000000000000000000000000
--- a/test/cases/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/cases/compile_errors/stage1/obj/wrong_panic_signature_generic_function.zig b/test/cases/compile_errors/stage1/obj/wrong_panic_signature_generic_function.zig
deleted file mode 100644
index 37af5e5fce81fbe1e5567cb07fa20eead57a5ab0..0000000000000000000000000000000000000000
--- a/test/cases/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, _: ?usize) 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, ?usize) noreturn', found 'fn([]const u8,anytype,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
deleted file mode 100644
index 3848a5bf0c0d262f26c3ee0723e62ec094724fbb..0000000000000000000000000000000000000000
--- a/test/cases/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, ?usize) noreturn', found 'fn() void'
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
deleted file mode 100644
index 218ef0b65d254c68884b6c9f8032874ccbddce9c..0000000000000000000000000000000000000000
--- a/test/cases/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/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
deleted file mode 100644
index 7a9be0a8cc6e9123a0beb597d4be2683aa7546ff..0000000000000000000000000000000000000000
--- a/test/cases/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/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
deleted file mode 100644
index b4193d4de11d50385900de8afa2b18c4ee2d3f74..0000000000000000000000000000000000000000
--- a/test/cases/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/cases/compile_errors/stage2/comptime_unreachable.zig b/test/cases/compile_errors/stage2/comptime_unreachable.zig
deleted file mode 100644
index 74b35165854f2bfa0bb9552b67da998ef0251b39..0000000000000000000000000000000000000000
--- a/test/cases/compile_errors/stage2/comptime_unreachable.zig
+++ /dev/null
@@ -1,9 +0,0 @@
-pub export fn entry() void {
-    comptime unreachable;
-}
-
-// error
-// target=native
-// backend=stage2
-//
-// :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
deleted file mode 100644
index 2b67390b05b2ec7e22608045d5e658810a4b596d..0000000000000000000000000000000000000000
--- a/test/cases/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/cases/compile_errors/stage2/duplicate-unused_labels.zig b/test/cases/compile_errors/stage2/duplicate-unused_labels.zig
deleted file mode 100644
index 4bfc6c596012082af8e971d5ab932f86a01c8c5c..0000000000000000000000000000000000000000
--- a/test/cases/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/cases/compile_errors/stage2/embed_outside_package.zig b/test/cases/compile_errors/stage2/embed_outside_package.zig
deleted file mode 100644
index 2003adb06199e8df8136ea6941d4ac346219f6bb..0000000000000000000000000000000000000000
--- a/test/cases/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/cases/compile_errors/stage2/import_outside_package.zig b/test/cases/compile_errors/stage2/import_outside_package.zig
deleted file mode 100644
index 59a75e2745a22d2f1b84d40d0555c4e7dc1ae881..0000000000000000000000000000000000000000
--- a/test/cases/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/cases/compile_errors/stage2/out_of_bounds_index.zig b/test/cases/compile_errors/stage2/out_of_bounds_index.zig
deleted file mode 100644
index 3f5b71d530fdbe6f29ba8f2435a13a57f3e7b504..0000000000000000000000000000000000000000
--- a/test/cases/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:30: error: end index 6 out of bounds for slice of length 4 +1 (sentinel)
-// :9:26: error: end index 6 out of bounds for array of length 4 +1 (sentinel)
-// :14:26: error: end index 5 out of bounds for array of length 4
-// :19:23: error: start index 3 is larger than end index 2
diff --git a/test/cases/compile_errors/stage2/reified_enum_field_value_overflow.zig b/test/cases/compile_errors/stage2/reified_enum_field_value_overflow.zig
deleted file mode 100644
index ad8596ebccd724074f8222b4543984d4faf98929..0000000000000000000000000000000000000000
--- a/test/cases/compile_errors/stage2/reified_enum_field_value_overflow.zig
+++ /dev/null
@@ -1,20 +0,0 @@
-comptime {
-    const E = @Type(.{ .Enum = .{
-        .layout = .Auto,
-        .tag_type = u1,
-        .fields = &.{
-            .{ .name = "f0", .value = 0 },
-            .{ .name = "f1", .value = 1 },
-            .{ .name = "f2", .value = 2 },
-        },
-        .decls = &.{},
-        .is_exhaustive = true,
-    } });
-    _ = E;
-}
-
-// error
-// target=native
-// backend=stage2
-//
-// :2:15: error: field 'f2' with enumeration value '2' is too large for backing int type 'u1'
diff --git a/test/cases/compile_errors/stage2/slice_of_null_pointer.zig b/test/cases/compile_errors/stage2/slice_of_null_pointer.zig
deleted file mode 100644
index 7f2c74a8a62bfc65116889043afdcd75e1d04ddd..0000000000000000000000000000000000000000
--- a/test/cases/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/cases/compile_errors/stage2/struct_duplicate_field_name.zig b/test/cases/compile_errors/stage2/struct_duplicate_field_name.zig
deleted file mode 100644
index 7e4434f1d92fa353d9fccff5f2c403fae90c9978..0000000000000000000000000000000000000000
--- a/test/cases/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/cases/compile_errors/stage2/tuple_ptr_to_mut_slice.zig b/test/cases/compile_errors/stage2/tuple_ptr_to_mut_slice.zig
deleted file mode 100644
index 24e4753563aa0d067c94c47fb5ea5260f5ff747c..0000000000000000000000000000000000000000
--- a/test/cases/compile_errors/stage2/tuple_ptr_to_mut_slice.zig
+++ /dev/null
@@ -1,32 +0,0 @@
-export fn entry1() void {
-    var a = .{ 1, 2, 3 };
-    _ = @as([]u8, &a);
-}
-export fn entry2() void {
-    var a = .{ @as(u8, 1), @as(u8, 2), @as(u8, 3) };
-    _ = @as([]u8, &a);
-}
-
-// runtime values
-var vals = [_]u7{ 4, 5, 6 };
-export fn entry3() void {
-    var a = .{ vals[0], vals[1], vals[2] };
-    _ = @as([]u8, &a);
-}
-export fn entry4() void {
-    var a = .{ @as(u8, vals[0]), @as(u8, vals[1]), @as(u8, vals[2]) };
-    _ = @as([]u8, &a);
-}
-
-// error
-// backend=stage2
-// target=native
-//
-// :3:19: error: cannot cast pointer to tuple to '[]u8'
-// :3:19: note: pointers to tuples can only coerce to constant pointers
-// :7:19: error: cannot cast pointer to tuple to '[]u8'
-// :7:19: note: pointers to tuples can only coerce to constant pointers
-// :14:19: error: cannot cast pointer to tuple to '[]u8'
-// :14:19: note: pointers to tuples can only coerce to constant pointers
-// :18:19: error: cannot cast pointer to tuple to '[]u8'
-// :18:19: note: pointers to tuples can only coerce to constant pointers
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
deleted file mode 100644
index 4f72914216fce157fc689d84d177add5ade64fcc..0000000000000000000000000000000000000000
--- a/test/cases/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/cases/compile_errors/stage2/union_duplicate_enum_field.zig b/test/cases/compile_errors/stage2/union_duplicate_enum_field.zig
deleted file mode 100644
index 44eb58e01449d22d53bf6382c8e61d0cc69b9cb9..0000000000000000000000000000000000000000
--- a/test/cases/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/cases/compile_errors/stage2/union_duplicate_field_definition.zig b/test/cases/compile_errors/stage2/union_duplicate_field_definition.zig
deleted file mode 100644
index 7993f27141f54f163bc29e32dfe0ed46054c67c4..0000000000000000000000000000000000000000
--- a/test/cases/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/cases/compile_errors/stage2/union_enum_field_missing.zig b/test/cases/compile_errors/stage2/union_enum_field_missing.zig
deleted file mode 100644
index 81bc83cf181d959f9519e9900650eb0110c49812..0000000000000000000000000000000000000000
--- a/test/cases/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:11: 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
deleted file mode 100644
index 6d1c644bc6888e64140a2ce870d2b68c8b076982..0000000000000000000000000000000000000000
--- a/test/cases/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
-//
-// :10:5: error: no field named 'd' in enum 'tmp.E'
-// :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
deleted file mode 100644
index 9020e9d5d7d202ef14c9c2660bee33df59508901..0000000000000000000000000000000000000000
--- a/test/cases/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/cases/compile_errors/struct_duplicate_field_name.zig b/test/cases/compile_errors/struct_duplicate_field_name.zig
new file mode 100644
index 0000000000000000000000000000000000000000..7e4434f1d92fa353d9fccff5f2c403fae90c9978
--- /dev/null
+++ b/test/cases/compile_errors/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/tuple_ptr_to_mut_slice.zig b/test/cases/compile_errors/tuple_ptr_to_mut_slice.zig
new file mode 100644
index 0000000000000000000000000000000000000000..24e4753563aa0d067c94c47fb5ea5260f5ff747c
--- /dev/null
+++ b/test/cases/compile_errors/tuple_ptr_to_mut_slice.zig
@@ -0,0 +1,32 @@
+export fn entry1() void {
+    var a = .{ 1, 2, 3 };
+    _ = @as([]u8, &a);
+}
+export fn entry2() void {
+    var a = .{ @as(u8, 1), @as(u8, 2), @as(u8, 3) };
+    _ = @as([]u8, &a);
+}
+
+// runtime values
+var vals = [_]u7{ 4, 5, 6 };
+export fn entry3() void {
+    var a = .{ vals[0], vals[1], vals[2] };
+    _ = @as([]u8, &a);
+}
+export fn entry4() void {
+    var a = .{ @as(u8, vals[0]), @as(u8, vals[1]), @as(u8, vals[2]) };
+    _ = @as([]u8, &a);
+}
+
+// error
+// backend=stage2
+// target=native
+//
+// :3:19: error: cannot cast pointer to tuple to '[]u8'
+// :3:19: note: pointers to tuples can only coerce to constant pointers
+// :7:19: error: cannot cast pointer to tuple to '[]u8'
+// :7:19: note: pointers to tuples can only coerce to constant pointers
+// :14:19: error: cannot cast pointer to tuple to '[]u8'
+// :14:19: note: pointers to tuples can only coerce to constant pointers
+// :18:19: error: cannot cast pointer to tuple to '[]u8'
+// :18:19: note: pointers to tuples can only coerce to constant pointers
diff --git a/test/cases/compile_errors/union_access_of_inactive_field.zig b/test/cases/compile_errors/union_access_of_inactive_field.zig
new file mode 100644
index 0000000000000000000000000000000000000000..4f72914216fce157fc689d84d177add5ade64fcc
--- /dev/null
+++ b/test/cases/compile_errors/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/union_auto-enum_value_already_taken.zig b/test/cases/compile_errors/union_auto-enum_value_already_taken.zig
new file mode 100644
index 0000000000000000000000000000000000000000..36b52c96b9bd5096dca75d436d5995d2280de822
--- /dev/null
+++ b/test/cases/compile_errors/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=stage2
+// target=native
+//
+// :6:5: error: enum tag value 60 already taken
+// :4:5: note: other occurrence here
diff --git a/test/cases/compile_errors/union_duplicate_enum_field.zig b/test/cases/compile_errors/union_duplicate_enum_field.zig
new file mode 100644
index 0000000000000000000000000000000000000000..44eb58e01449d22d53bf6382c8e61d0cc69b9cb9
--- /dev/null
+++ b/test/cases/compile_errors/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/union_duplicate_field_definition.zig b/test/cases/compile_errors/union_duplicate_field_definition.zig
new file mode 100644
index 0000000000000000000000000000000000000000..7993f27141f54f163bc29e32dfe0ed46054c67c4
--- /dev/null
+++ b/test/cases/compile_errors/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/union_enum_field_does_not_match_enum.zig b/test/cases/compile_errors/union_enum_field_does_not_match_enum.zig
new file mode 100644
index 0000000000000000000000000000000000000000..9370207c59f06d12fd2fb8ca380b6a2fe9020fca
--- /dev/null
+++ b/test/cases/compile_errors/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=stage2
+// target=native
+//
+// :10:5: error: no field named 'D' in enum 'tmp.Letter'
+// :1:16: note: enum declared here
diff --git a/test/cases/compile_errors/union_enum_field_missing.zig b/test/cases/compile_errors/union_enum_field_missing.zig
new file mode 100644
index 0000000000000000000000000000000000000000..81bc83cf181d959f9519e9900650eb0110c49812
--- /dev/null
+++ b/test/cases/compile_errors/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:11: 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/union_extra_field.zig b/test/cases/compile_errors/union_extra_field.zig
new file mode 100644
index 0000000000000000000000000000000000000000..6d1c644bc6888e64140a2ce870d2b68c8b076982
--- /dev/null
+++ b/test/cases/compile_errors/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
+//
+// :10:5: error: no field named 'd' in enum 'tmp.E'
+// :1:11: note: enum declared here
diff --git a/test/cases/compile_errors/union_runtime_coercion_from_enum.zig b/test/cases/compile_errors/union_runtime_coercion_from_enum.zig
new file mode 100644
index 0000000000000000000000000000000000000000..9020e9d5d7d202ef14c9c2660bee33df59508901
--- /dev/null
+++ b/test/cases/compile_errors/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_errors/union_with_too_small_explicit_signed_tag_type.zig b/test/cases/compile_errors/union_with_too_small_explicit_signed_tag_type.zig
new file mode 100644
index 0000000000000000000000000000000000000000..2de72e2725791e12932ba2eec8341f4ee2a1af49
--- /dev/null
+++ b/test/cases/compile_errors/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=stage2
+// target=native
+//
+// :1:22: error: specified integer tag type cannot represent every field
+// :1:22: note: type 'i2' cannot fit values in range 0...3
diff --git a/test/cases/compile_errors/union_with_too_small_explicit_unsigned_tag_type.zig b/test/cases/compile_errors/union_with_too_small_explicit_unsigned_tag_type.zig
new file mode 100644
index 0000000000000000000000000000000000000000..de2139b60735dbde56a51e222a9dc11295cacd0d
--- /dev/null
+++ b/test/cases/compile_errors/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=stage2
+// target=native
+//
+// :1:22: error: specified integer tag type cannot represent every field
+// :1:22: note: type 'u2' cannot fit values in range 0...4
diff --git a/test/cases/compile_errors/wrong_function_type.zig b/test/cases/compile_errors/wrong_function_type.zig
new file mode 100644
index 0000000000000000000000000000000000000000..867bdccc1a6e2054113f6e8971747b4804ec3684
--- /dev/null
+++ b/test/cases/compile_errors/wrong_function_type.zig
@@ -0,0 +1,12 @@
+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=stage2
+// target=native
+//
+// :1:28: error: expected type 'fn() void', found 'fn() i32'
+// :1:28: note: return type 'i32' cannot cast into return type 'void'