diff --git a/lib/c.zig b/lib/c.zig
index 30c6e0cd76e6b30c553d37a90cb8eb26451b8722..9df1b3fb01044bab1fcbf417ed406f75f47dd3b4 100644
--- a/lib/c.zig
+++ b/lib/c.zig
@@ -82,7 +82,7 @@ fn memset(dest: ?[*]u8, c: u8, len: usize) callconv(.C) ?[*]u8 {
         var d = dest.?;
         var n = len;
         while (true) {
-            d.* = c;
+            d[0] = c;
             n -= 1;
             if (n == 0) break;
             d += 1;
diff --git a/lib/std/os.zig b/lib/std/os.zig
index 578a8ddcbc8340d3ae13dbb130bae1fcc3e7f490..02ed710dd310de0fc91e5cec224c748dba646bf1 100644
--- a/lib/std/os.zig
+++ b/lib/std/os.zig
@@ -1868,7 +1868,7 @@ pub fn getenv(key: []const u8) ?[]const u8 {
         }
         // Search the entire `environ` because we don't have a null terminated pointer.
         var ptr = std.c.environ;
-        while (ptr.*) |line| : (ptr += 1) {
+        while (ptr[0]) |line| : (ptr += 1) {
             var line_i: usize = 0;
             while (line[line_i] != 0 and line[line_i] != '=') : (line_i += 1) {}
             const this_key = line[0..line_i];
diff --git a/lib/std/process.zig b/lib/std/process.zig
index 0b64b5910d8664d3b125b22f99e89d1277b279ba..dffd6b1701a262207edb4baa5298bda29fc6bd2e 100644
--- a/lib/std/process.zig
+++ b/lib/std/process.zig
@@ -313,7 +313,7 @@ pub fn getEnvMap(allocator: Allocator) !EnvMap {
         return result;
     } else if (builtin.link_libc) {
         var ptr = std.c.environ;
-        while (ptr.*) |line| : (ptr += 1) {
+        while (ptr[0]) |line| : (ptr += 1) {
             var line_i: usize = 0;
             while (line[line_i] != 0 and line[line_i] != '=') : (line_i += 1) {}
             const key = line[0..line_i];
diff --git a/src/AstGen.zig b/src/AstGen.zig
index c9abb1859ba9f5f2f6b25501bddd580848a9c6f8..a0ff7a0e6ebc9db5d4c92c2cf896dfe4c8564dfc 100644
--- a/src/AstGen.zig
+++ b/src/AstGen.zig
@@ -812,6 +812,7 @@ fn expr(gz: *GenZir, scope: *Scope, rl: ResultLoc, node: Ast.Node.Index) InnerEr
 
         .deref => {
             const lhs = try expr(gz, scope, .none, node_datas[node].lhs);
+            _ = try gz.addUnTok(.validate_deref, lhs, main_tokens[node]);
             switch (rl) {
                 .ref => return lhs,
                 else => {
@@ -2500,6 +2501,7 @@ fn unusedResultExpr(gz: *GenZir, scope: *Scope, statement: Ast.Node.Index) Inner
             .memset,
             .validate_array_init_ty,
             .validate_struct_init_ty,
+            .validate_deref,
             => break :b true,
         }
     } else switch (maybe_unused_result) {
@@ -5152,16 +5154,14 @@ fn arrayAccess(
     const tree = astgen.tree;
     const node_datas = tree.nodes.items(.data);
     switch (rl) {
-        .ref => return gz.addBin(
-            .elem_ptr,
-            try expr(gz, scope, .ref, node_datas[node].lhs),
-            try expr(gz, scope, .{ .ty = .usize_type }, node_datas[node].rhs),
-        ),
-        else => return rvalue(gz, rl, try gz.addBin(
-            .elem_val,
-            try expr(gz, scope, .none, node_datas[node].lhs),
-            try expr(gz, scope, .{ .coerced_ty = .usize_type }, node_datas[node].rhs),
-        ), node),
+        .ref => return gz.addPlNode(.elem_ptr_node, node, Zir.Inst.Bin{
+            .lhs = try expr(gz, scope, .ref, node_datas[node].lhs),
+            .rhs = try expr(gz, scope, .{ .ty = .usize_type }, node_datas[node].rhs),
+        }),
+        else => return rvalue(gz, rl, try gz.addPlNode(.elem_val_node, node, Zir.Inst.Bin{
+            .lhs = try expr(gz, scope, .none, node_datas[node].lhs),
+            .rhs = try expr(gz, scope, .{ .ty = .usize_type }, node_datas[node].rhs),
+        }), node),
     }
 }
 
@@ -5683,7 +5683,7 @@ fn whileExpr(
         try then_scope.addDbgVar(.dbg_var_val, some, dbg_var_inst);
     }
     if (while_full.ast.cont_expr != 0) {
-        _ = try expr(&loop_scope, then_sub_scope, .{ .ty = .void_type }, while_full.ast.cont_expr);
+        _ = try unusedResultExpr(&loop_scope, then_sub_scope, while_full.ast.cont_expr);
     }
     try then_scope.addDbgBlockEnd();
     const repeat_tag: Zir.Inst.Tag = if (is_inline) .repeat_inline else .repeat;
@@ -5888,7 +5888,10 @@ fn forExpr(
         if (!mem.eql(u8, value_name, "_")) {
             const name_str_index = try astgen.identAsString(ident);
             const tag: Zir.Inst.Tag = if (is_ptr) .elem_ptr else .elem_val;
-            const payload_inst = try then_scope.addBin(tag, array_ptr, index);
+            const payload_inst = try then_scope.addPlNode(tag, for_full.ast.cond_expr, Zir.Inst.Bin{
+                .lhs = array_ptr,
+                .rhs = index,
+            });
             try astgen.detectLocalShadowing(&then_scope.base, name_str_index, ident, value_name);
             payload_val_scope = .{
                 .parent = &then_scope.base,
diff --git a/src/Sema.zig b/src/Sema.zig
index 862d5cbf482a83dad024796c87508e06cc327418..b946e29057f6f11ab8d3772456ebcfa0e1638c70 100644
--- a/src/Sema.zig
+++ b/src/Sema.zig
@@ -1080,6 +1080,11 @@ fn analyzeBodyInner(
                 i += 1;
                 continue;
             },
+            .validate_deref => {
+                try sema.zirValidateDeref(block, inst);
+                i += 1;
+                continue;
+            },
             .@"export" => {
                 try sema.zirExport(block, inst);
                 i += 1;
@@ -2434,9 +2439,9 @@ fn zirEnumDecl(
             const field_src = enumFieldSrcLoc(sema.mod.declPtr(block.src_decl), tree.*, src.node_offset.x, field_i);
             const other_tag_src = enumFieldSrcLoc(sema.mod.declPtr(block.src_decl), tree.*, src.node_offset.x, gop.index);
             const msg = msg: {
-                const msg = try sema.errMsg(block, field_src, "duplicate enum tag", .{});
+                const msg = try sema.errMsg(block, field_src, "duplicate enum field '{s}'", .{field_name});
                 errdefer msg.destroy(gpa);
-                try sema.errNote(block, other_tag_src, msg, "other tag here", .{});
+                try sema.errNote(block, other_tag_src, msg, "other field here", .{});
                 break :msg msg;
             };
             return sema.failWithOwnedErrorMsg(block, msg);
@@ -2733,6 +2738,7 @@ fn ensureResultUsed(
     const operand_ty = sema.typeOf(operand);
     switch (operand_ty.zigTypeTag()) {
         .Void, .NoReturn => return,
+        .ErrorSet, .ErrorUnion => return sema.fail(block, src, "error is ignored. consider using `try`, `catch`, or `if`", .{}),
         else => return sema.fail(block, src, "expression value is ignored", .{}),
     }
 }
@@ -2746,7 +2752,7 @@ fn zirEnsureResultNonError(sema: *Sema, block: *Block, inst: Zir.Inst.Index) Com
     const src = inst_data.src();
     const operand_ty = sema.typeOf(operand);
     switch (operand_ty.zigTypeTag()) {
-        .ErrorSet, .ErrorUnion => return sema.fail(block, src, "error is discarded", .{}),
+        .ErrorSet, .ErrorUnion => return sema.fail(block, src, "error is discarded. consider using `try`, `catch`, or `if`", .{}),
         else => return,
     }
 }
@@ -3849,6 +3855,28 @@ fn zirValidateArrayInit(
     }
 }
 
+fn zirValidateDeref(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!void {
+    const inst_data = sema.code.instructions.items(.data)[inst].un_tok;
+    const src = inst_data.src();
+    const operand_src: LazySrcLoc = .{ .token_offset = inst_data.src_tok + 1 };
+    const operand = try sema.resolveInst(inst_data.operand);
+    const operand_ty = sema.typeOf(operand);
+
+    if (operand_ty.zigTypeTag() != .Pointer) {
+        return sema.fail(block, src, "cannot dereference non-pointer type '{}'", .{operand_ty.fmt(sema.mod)});
+    } else switch (operand_ty.ptrSize()) {
+        .One, .C => {},
+        .Many => return sema.fail(block, src, "index syntax required for unknown-length pointer type '{}'", .{operand_ty.fmt(sema.mod)}),
+        .Slice => return sema.fail(block, src, "index syntax required for slice type '{}'", .{operand_ty.fmt(sema.mod)}),
+    }
+
+    if (try sema.resolveMaybeUndefVal(block, operand_src, operand)) |val| {
+        if (val.isUndef()) {
+            return sema.fail(block, src, "cannot dereference undefined value", .{});
+        }
+    }
+}
+
 fn failWithBadMemberAccess(
     sema: *Sema,
     block: *Block,
@@ -4272,7 +4300,8 @@ fn zirCompileLog(
     }
     try writer.print("\n", .{});
 
-    const gop = try sema.mod.compile_log_decls.getOrPut(sema.gpa, sema.owner_decl_index);
+    const decl_index = if (sema.func) |some| some.owner_decl else sema.owner_decl_index;
+    const gop = try sema.mod.compile_log_decls.getOrPut(sema.gpa, decl_index);
     if (!gop.found_existing) {
         gop.value_ptr.* = src_node;
     }
@@ -6416,6 +6445,7 @@ fn zirIntToEnum(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!A
     if (dest_ty.zigTypeTag() != .Enum) {
         return sema.fail(block, dest_ty_src, "expected enum, found '{}'", .{dest_ty.fmt(sema.mod)});
     }
+    _ = try sema.checkIntType(block, operand_src, sema.typeOf(operand));
 
     if (try sema.resolveMaybeUndefVal(block, operand_src, operand)) |int_val| {
         if (dest_ty.isNonexhaustiveEnum()) {
@@ -7007,6 +7037,7 @@ fn funcCommon(
     noalias_bits: u32,
 ) CompileError!Air.Inst.Ref {
     const ret_ty_src: LazySrcLoc = .{ .node_offset_fn_type_ret_ty = src_node_offset };
+    const cc_src: LazySrcLoc = .{ .node_offset_fn_type_cc = src_node_offset };
 
     var is_generic = bare_return_type.tag() == .generic_poison or
         alignment == null or
@@ -7062,7 +7093,7 @@ 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 param_src = LazySrcLoc.nodeOffset(src_node_offset); // TODO better src
+            const param_src = LazySrcLoc.nodeOffset(src_node_offset); // TODO better soruce location
             param_types[i] = param.ty;
             comptime_params[i] = param.is_comptime or
                 try sema.typeRequiresComptime(block, param_src, param.ty);
@@ -7109,6 +7140,45 @@ fn funcCommon(
         const cc_workaround = cc orelse .Unspecified;
         const align_workaround = alignment orelse 0;
 
+        const arch = sema.mod.getTarget().cpu.arch;
+        if (switch (cc_workaround) {
+            .Unspecified, .C, .Naked, .Async, .Inline => null,
+            .Interrupt => switch (arch) {
+                .i386, .x86_64, .avr, .msp430 => null,
+                else => @as([]const u8, "i386, x86_64, AVR, and MSP430"),
+            },
+            .Signal => switch (arch) {
+                .avr => null,
+                else => @as([]const u8, "AVR"),
+            },
+            .Stdcall, .Fastcall, .Thiscall => switch (arch) {
+                .i386 => null,
+                else => @as([]const u8, "i386"),
+            },
+            .Vectorcall => switch (arch) {
+                .i386, .aarch64, .aarch64_be, .aarch64_32 => null,
+                else => @as([]const u8, "i386 and AArch64"),
+            },
+            .APCS, .AAPCS, .AAPCSVFP => switch (arch) {
+                .arm, .armeb, .aarch64, .aarch64_be, .aarch64_32 => null,
+                else => @as([]const u8, "ARM"),
+            },
+            .SysV, .Win64 => switch (arch) {
+                .x86_64 => null,
+                else => @as([]const u8, "x86_64"),
+            },
+            .PtxKernel => switch (arch) {
+                .nvptx, .nvptx64 => null,
+                else => @as([]const u8, "nvptx and nvptx64"),
+            },
+        }) |allowed_platform| {
+            return sema.fail(block, cc_src, "callconv '{s}' is only available on {s}, not {s}", .{
+                @tagName(cc_workaround),
+                allowed_platform,
+                @tagName(arch),
+            });
+        }
+
         break :fn_ty try Type.Tag.function.create(sema.arena, .{
             .param_types = param_types,
             .comptime_params = comptime_params.ptr,
@@ -7617,11 +7687,11 @@ fn zirBitcast(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air
     const extra = sema.code.extraData(Zir.Inst.Bin, inst_data.payload_index).data;
 
     const dest_ty = try sema.resolveType(block, dest_ty_src, extra.lhs);
+    const operand = try sema.resolveInst(extra.rhs);
     switch (dest_ty.zigTypeTag()) {
         .AnyFrame,
         .ComptimeFloat,
         .ComptimeInt,
-        .Enum,
         .EnumLiteral,
         .ErrorSet,
         .ErrorUnion,
@@ -7634,7 +7704,21 @@ fn zirBitcast(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air
         .Type,
         .Undefined,
         .Void,
-        => return sema.fail(block, dest_ty_src, "invalid type '{}' for @bitCast", .{dest_ty.fmt(sema.mod)}),
+        => return sema.fail(block, dest_ty_src, "cannot @bitCast to '{}'", .{dest_ty.fmt(sema.mod)}),
+
+        .Enum => {
+            const msg = msg: {
+                const msg = try sema.errMsg(block, dest_ty_src, "cannot @bitCast to '{}'", .{dest_ty.fmt(sema.mod)});
+                errdefer msg.destroy(sema.gpa);
+                switch (sema.typeOf(operand).zigTypeTag()) {
+                    .Int, .ComptimeInt => try sema.errNote(block, dest_ty_src, msg, "use @intToEnum for type coercion", .{}),
+                    else => {},
+                }
+
+                break :msg msg;
+            };
+            return sema.failWithOwnedErrorMsg(block, msg);
+        },
 
         .Pointer => return sema.fail(block, dest_ty_src, "cannot @bitCast to '{}', use @ptrCast to cast to a pointer", .{
             dest_ty.fmt(sema.mod),
@@ -7658,8 +7742,6 @@ fn zirBitcast(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air
         .Vector,
         => {},
     }
-
-    const operand = try sema.resolveInst(extra.rhs);
     return sema.bitCast(block, dest_ty, operand, operand_src);
 }
 
@@ -7717,12 +7799,12 @@ fn zirElemVal(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air
     const tracy = trace(@src());
     defer tracy.end();
 
-    const bin_inst = sema.code.instructions.items(.data)[inst].bin;
-    const src = sema.src; // TODO better source location
-    const elem_index_src = sema.src; // TODO better source location
-    const array = try sema.resolveInst(bin_inst.lhs);
-    const elem_index = try sema.resolveInst(bin_inst.rhs);
-    return sema.elemVal(block, src, array, elem_index, elem_index_src);
+    const inst_data = sema.code.instructions.items(.data)[inst].pl_node;
+    const src = inst_data.src();
+    const extra = sema.code.extraData(Zir.Inst.Bin, inst_data.payload_index).data;
+    const array = try sema.resolveInst(extra.lhs);
+    const elem_index = try sema.resolveInst(extra.rhs);
+    return sema.elemVal(block, src, array, elem_index, src);
 }
 
 fn zirElemValNode(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.Inst.Ref {
@@ -7742,10 +7824,12 @@ fn zirElemPtr(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air
     const tracy = trace(@src());
     defer tracy.end();
 
-    const bin_inst = sema.code.instructions.items(.data)[inst].bin;
-    const array_ptr = try sema.resolveInst(bin_inst.lhs);
-    const elem_index = try sema.resolveInst(bin_inst.rhs);
-    return sema.elemPtr(block, sema.src, array_ptr, elem_index, sema.src, false);
+    const inst_data = sema.code.instructions.items(.data)[inst].pl_node;
+    const src = inst_data.src();
+    const extra = sema.code.extraData(Zir.Inst.Bin, inst_data.payload_index).data;
+    const array_ptr = try sema.resolveInst(extra.lhs);
+    const elem_index = try sema.resolveInst(extra.rhs);
+    return sema.elemPtr(block, src, array_ptr, elem_index, src, false);
 }
 
 fn zirElemPtrNode(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.Inst.Ref {
@@ -8297,19 +8381,15 @@ fn zirSwitchBlock(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError
                             block,
                             src,
                             msg,
-                            "unhandled error value: error.{s}",
+                            "unhandled error value: 'error.{s}'",
                             .{error_name},
                         );
                     }
                 }
 
                 if (maybe_msg) |msg| {
-                    try sema.mod.errNoteNonLazy(
-                        operand_ty.declSrcLoc(sema.mod),
-                        msg,
-                        "error set '{}' declared here",
-                        .{operand_ty.fmt(sema.mod)},
-                    );
+                    maybe_msg = null;
+                    try sema.addDeclaredHereNote(msg, operand_ty);
                     return sema.failWithOwnedErrorMsg(block, msg);
                 }
 
@@ -17062,9 +17142,7 @@ fn zirFieldParentPtr(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileEr
     const field_index = struct_obj.fields.getIndex(field_name) orelse
         return sema.failWithBadStructFieldAccess(block, struct_obj, name_src, field_name);
 
-    if (field_ptr_ty.zigTypeTag() != .Pointer) {
-        return sema.fail(block, ty_src, "expected pointer type, found '{}'", .{field_ptr_ty.fmt(sema.mod)});
-    }
+    try sema.checkPtrOperand(block, ptr_src, field_ptr_ty);
     const field = struct_obj.fields.values()[field_index];
     const field_ptr_ty_info = field_ptr_ty.ptrInfo().data;
 
@@ -17087,8 +17165,29 @@ fn zirFieldParentPtr(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileEr
     const result_ptr = try Type.ptr(sema.arena, sema.mod, ptr_ty_data);
 
     if (try sema.resolveDefinedValue(block, src, casted_field_ptr)) |field_ptr_val| {
-        const payload = field_ptr_val.castTag(.field_ptr).?.data;
-        return sema.addConstant(result_ptr, payload.container_ptr);
+        const payload = field_ptr_val.castTag(.field_ptr) orelse {
+            return sema.fail(block, ptr_src, "pointer value not based on parent struct", .{});
+        };
+        if (payload.data.field_index != field_index) {
+            const msg = msg: {
+                const msg = try sema.errMsg(
+                    block,
+                    src,
+                    "field '{s}' has index '{d}' but pointer value is index '{d}' of struct '{}'",
+                    .{
+                        field_name,
+                        field_index,
+                        payload.data.field_index,
+                        struct_ty.fmt(sema.mod),
+                    },
+                );
+                errdefer msg.destroy(sema.gpa);
+                try sema.addDeclaredHereNote(msg, struct_ty);
+                break :msg msg;
+            };
+            return sema.failWithOwnedErrorMsg(block, msg);
+        }
+        return sema.addConstant(result_ptr, payload.data.container_ptr);
     }
 
     try sema.requireRuntimeBlock(block, src);
@@ -18434,7 +18533,16 @@ fn fieldVal(
                         kw_name, child_type.fmt(sema.mod), field_name,
                     });
                 },
-                else => return sema.fail(block, src, "type '{}' has no members", .{child_type.fmt(sema.mod)}),
+                else => {
+                    const msg = msg: {
+                        const msg = try sema.errMsg(block, src, "type '{}' has no members", .{child_type.fmt(sema.mod)});
+                        errdefer msg.destroy(sema.gpa);
+                        if (child_type.isSlice()) try sema.errNote(block, src, msg, "slice values have 'len' and 'ptr' members", .{});
+                        if (child_type.zigTypeTag() == .Array) try sema.errNote(block, src, msg, "array values have 'len' member", .{});
+                        break :msg msg;
+                    };
+                    return sema.failWithOwnedErrorMsg(block, msg);
+                },
             }
         },
         .Struct => if (is_pointer_to) {
@@ -18658,7 +18766,7 @@ fn fieldPtr(
         },
         else => {},
     }
-    return sema.fail(block, src, "type '{}' does not support field access (fieldPtr, {}.{s})", .{ object_ty.fmt(sema.mod), object_ptr_ty.fmt(sema.mod), field_name });
+    return sema.fail(block, src, "type '{}' does not support field access", .{object_ty.fmt(sema.mod)});
 }
 
 fn fieldCallBind(
@@ -19349,7 +19457,7 @@ fn tupleFieldPtr(
     const tuple_fields = tuple_ty.tupleFields();
 
     if (tuple_fields.types.len == 0) {
-        return sema.fail(block, field_index_src, "indexing into empty tuple", .{});
+        return sema.fail(block, tuple_ptr_src, "indexing into empty tuple is not allowed", .{});
     }
 
     if (field_index >= tuple_fields.types.len) {
@@ -19392,7 +19500,7 @@ fn tupleField(
     const tuple_fields = tuple_ty.tupleFields();
 
     if (tuple_fields.types.len == 0) {
-        return sema.fail(block, field_index_src, "indexing into empty tuple", .{});
+        return sema.fail(block, tuple_src, "indexing into empty tuple is not allowed", .{});
     }
 
     if (field_index >= tuple_fields.types.len) {
@@ -19433,7 +19541,7 @@ fn elemValArray(
     const elem_ty = array_ty.childType();
 
     if (array_len_s == 0) {
-        return sema.fail(block, elem_index_src, "indexing into empty array", .{});
+        return sema.fail(block, array_src, "indexing into empty array is not allowed", .{});
     }
 
     const maybe_undef_array_val = try sema.resolveMaybeUndefVal(block, array_src, array);
@@ -19513,7 +19621,7 @@ fn elemPtrArray(
     const array_len_s = array_len + @boolToInt(array_sent);
 
     if (array_len_s == 0) {
-        return sema.fail(block, elem_index_src, "indexing into empty array", .{});
+        return sema.fail(block, array_ptr_src, "indexing into empty array is not allowed", .{});
     }
 
     const maybe_undef_array_ptr_val = try sema.resolveMaybeUndefVal(block, array_ptr_src, array_ptr);
@@ -19595,7 +19703,7 @@ fn elemValSlice(
         const slice_len = slice_val.sliceLen(sema.mod);
         const slice_len_s = slice_len + @boolToInt(slice_sent);
         if (slice_len_s == 0) {
-            return sema.fail(block, elem_index_src, "indexing into empty slice", .{});
+            return sema.fail(block, slice_src, "indexing into empty slice is not allowed", .{});
         }
         if (maybe_index_val) |index_val| {
             const index = @intCast(usize, index_val.toUnsignedInt(target));
@@ -19652,7 +19760,7 @@ fn elemPtrSlice(
         const slice_len = slice_val.sliceLen(sema.mod);
         const slice_len_s = slice_len + @boolToInt(slice_sent);
         if (slice_len_s == 0) {
-            return sema.fail(block, elem_index_src, "indexing into empty slice", .{});
+            return sema.fail(block, slice_src, "indexing into empty slice is not allowed", .{});
         }
         if (offset) |index| {
             if (index >= slice_len_s) {
diff --git a/src/Zir.zig b/src/Zir.zig
index e6acfe8ed2aac7135fb630650decbac52226a4fe..98cdd490b86fd39cbea60cd27f98a642cf25979d 100644
--- a/src/Zir.zig
+++ b/src/Zir.zig
@@ -370,24 +370,23 @@ pub const Inst = struct {
         /// Uses the `pl_node` union field. Payload is `Bin`.
         div,
         /// Given a pointer to an array, slice, or pointer, returns a pointer to the element at
-        /// the provided index. Uses the `bin` union field. Source location is implied
-        /// to be the same as the previous instruction.
-        elem_ptr,
-        /// Same as `elem_ptr` except also stores a source location node.
+        /// the provided index.
         /// Uses the `pl_node` union field. AST node is a[b] syntax. Payload is `Bin`.
         elem_ptr_node,
+        /// Same as `elem_ptr_node` but used only for for loop.
+        /// Uses the `pl_node` union field. AST node is the condition of a for loop. Payload is `Bin`.
+        elem_ptr,
         /// Same as `elem_ptr_node` except the index is stored immediately rather than
         /// as a reference to another ZIR instruction.
         /// Uses the `pl_node` union field. AST node is an element inside array initialization
         /// syntax. Payload is `ElemPtrImm`.
         elem_ptr_imm,
         /// Given an array, slice, or pointer, returns the element at the provided index.
-        /// Uses the `bin` union field. Source location is implied to be the same
-        /// as the previous instruction.
-        elem_val,
-        /// Same as `elem_val` except also stores a source location node.
         /// Uses the `pl_node` union field. AST node is a[b] syntax. Payload is `Bin`.
         elem_val_node,
+        /// Same as `elem_val_node` but used only for for loop.
+        /// Uses the `pl_node` union field. AST node is the condition of a for loop. Payload is `Bin`.
+        elem_val,
         /// Emits a compile error if the operand is not `void`.
         /// Uses the `un_node` field.
         ensure_result_used,
@@ -729,6 +728,9 @@ pub const Inst = struct {
         /// Same as `validate_array_init` but additionally communicates that the
         /// resulting array initialization value is within a comptime scope.
         validate_array_init_comptime,
+        /// Check that operand type supports the dereference operand (.*).
+        /// Uses the `un_tok` field.
+        validate_deref,
         /// A struct literal with a specified type, with no fields.
         /// Uses the `un_node` field.
         struct_init_empty,
@@ -1156,6 +1158,7 @@ pub const Inst = struct {
                 .validate_struct_init_comptime,
                 .validate_array_init,
                 .validate_array_init_comptime,
+                .validate_deref,
                 .struct_init_empty,
                 .struct_init,
                 .struct_init_ref,
@@ -1309,6 +1312,7 @@ pub const Inst = struct {
                 .validate_struct_init_comptime,
                 .validate_array_init,
                 .validate_array_init_comptime,
+                .validate_deref,
                 .@"export",
                 .export_value,
                 .set_cold,
@@ -1622,10 +1626,10 @@ pub const Inst = struct {
                 .decl_val = .str_tok,
                 .load = .un_node,
                 .div = .pl_node,
-                .elem_ptr = .bin,
+                .elem_ptr = .pl_node,
                 .elem_ptr_node = .pl_node,
                 .elem_ptr_imm = .pl_node,
-                .elem_val = .bin,
+                .elem_val = .pl_node,
                 .elem_val_node = .pl_node,
                 .ensure_result_used = .un_node,
                 .ensure_result_non_error = .un_node,
@@ -1709,6 +1713,7 @@ pub const Inst = struct {
                 .validate_struct_init_comptime = .pl_node,
                 .validate_array_init = .pl_node,
                 .validate_array_init_comptime = .pl_node,
+                .validate_deref = .un_tok,
                 .struct_init_empty = .un_node,
                 .field_type = .pl_node,
                 .field_type_ref = .pl_node,
diff --git a/src/print_zir.zig b/src/print_zir.zig
index 480a3e2a4fa19f02a2c492983480e684beb42b53..b19076a7f08992c3a221fb86013f0e73aec376b8 100644
--- a/src/print_zir.zig
+++ b/src/print_zir.zig
@@ -144,8 +144,6 @@ const Writer = struct {
         switch (tag) {
             .array_type,
             .as,
-            .elem_ptr,
-            .elem_val,
             .store,
             .store_to_block_ptr,
             .store_to_inferred_ptr,
@@ -242,6 +240,7 @@ const Writer = struct {
             .ret_tok,
             .ensure_err_payload_void,
             .closure_capture,
+            .validate_deref,
             => try self.writeUnTok(stream, inst),
 
             .bool_br_and,
@@ -354,6 +353,8 @@ const Writer = struct {
             .minimum,
             .elem_ptr_node,
             .elem_val_node,
+            .elem_ptr,
+            .elem_val,
             .coerce_result_ptr,
             => try self.writePlNodeBin(stream, inst),
 
diff --git a/src/type.zig b/src/type.zig
index 0ca7ba83c5f416a82eece9c3d92daf1e0017f4c2..50302dca6c5091cca40a10587e3a96bb4710b740 100644
--- a/src/type.zig
+++ b/src/type.zig
@@ -189,7 +189,7 @@ pub const Type = extern union {
             .Frame,
             => false,
 
-            .Pointer => is_equality_cmp or ty.isCPtr(),
+            .Pointer => !ty.isSlice() and (is_equality_cmp or ty.isCPtr()),
             .Optional => {
                 if (!is_equality_cmp) return false;
                 var buf: Payload.ElemType = undefined;
diff --git a/test/cases/compile_errors/assign_to_invalid_dereference.zig b/test/cases/compile_errors/assign_to_invalid_dereference.zig
new file mode 100644
index 0000000000000000000000000000000000000000..cb35004034d7dbc2f9145782758cb157937bea47
--- /dev/null
+++ b/test/cases/compile_errors/assign_to_invalid_dereference.zig
@@ -0,0 +1,9 @@
+export fn entry() void {
+    'a'.* = 1;
+}
+
+// error
+// backend=stage2
+// target=native
+//
+// :2:8: error: cannot dereference non-pointer type 'comptime_int'
diff --git a/test/cases/compile_errors/bitCast_to_enum_type.zig b/test/cases/compile_errors/bitCast_to_enum_type.zig
new file mode 100644
index 0000000000000000000000000000000000000000..add531627f75e79f67edb385b5df137273e467c3
--- /dev/null
+++ b/test/cases/compile_errors/bitCast_to_enum_type.zig
@@ -0,0 +1,12 @@
+export fn entry() void {
+    const E = enum(u32) { a, b };
+    const y = @bitCast(E, @as(u32, 3));
+    _ = y;
+}
+
+// error
+// backend=stage2
+// target=native
+//
+// :3:24: error: cannot @bitCast to 'tmp.entry.E'
+// :3:24: note: use @intToEnum for type coercion
diff --git a/test/cases/compile_errors/bogus_compile_var.zig b/test/cases/compile_errors/bogus_compile_var.zig
new file mode 100644
index 0000000000000000000000000000000000000000..28d8b1dba5ecf00bbfa302f582af1a83f8631280
--- /dev/null
+++ b/test/cases/compile_errors/bogus_compile_var.zig
@@ -0,0 +1,8 @@
+const x = @import("builtin").bogus;
+export fn entry() usize { return @sizeOf(@TypeOf(x)); }
+
+// error
+// backend=stage2
+// target=native
+//
+// :1:29: error: struct 'builtin.builtin' has no member named 'bogus'
diff --git a/test/cases/compile_errors/callconv_apcs_aapcs_aapcsvfp_on_unsupported_platform.zig b/test/cases/compile_errors/callconv_apcs_aapcs_aapcsvfp_on_unsupported_platform.zig
new file mode 100644
index 0000000000000000000000000000000000000000..cc6fc59a1ae5937245ef0b84e9b7097fa465c7fc
--- /dev/null
+++ b/test/cases/compile_errors/callconv_apcs_aapcs_aapcsvfp_on_unsupported_platform.zig
@@ -0,0 +1,11 @@
+export fn entry1() callconv(.APCS) void {}
+export fn entry2() callconv(.AAPCS) void {}
+export fn entry3() callconv(.AAPCSVFP) void {}
+
+// error
+// backend=stage2
+// target=x86_64-linux-none
+//
+// :1:30: error: callconv 'APCS' is only available on ARM, not x86_64
+// :2:30: error: callconv 'AAPCS' is only available on ARM, not x86_64
+// :3:30: error: callconv 'AAPCSVFP' is only available on ARM, not x86_64
diff --git a/test/cases/compile_errors/callconv_interrupt_on_unsupported_platform.zig b/test/cases/compile_errors/callconv_interrupt_on_unsupported_platform.zig
new file mode 100644
index 0000000000000000000000000000000000000000..5f11fdcfa83dd79cf0aed0fa731e5f4eb2ee5367
--- /dev/null
+++ b/test/cases/compile_errors/callconv_interrupt_on_unsupported_platform.zig
@@ -0,0 +1,7 @@
+export fn entry() callconv(.Interrupt) void {}
+
+// error
+// backend=stage2
+// target=aarch64-linux-none
+//
+// :1:29: error: callconv 'Interrupt' is only available on i386, x86_64, AVR, and MSP430, not aarch64
diff --git a/test/cases/compile_errors/callconv_signal_on_unsupported_platform.zig b/test/cases/compile_errors/callconv_signal_on_unsupported_platform.zig
new file mode 100644
index 0000000000000000000000000000000000000000..9233655e3563e34b0e31d051aa9dd3bd4fc087a0
--- /dev/null
+++ b/test/cases/compile_errors/callconv_signal_on_unsupported_platform.zig
@@ -0,0 +1,7 @@
+export fn entry() callconv(.Signal) void {}
+
+// error
+// backend=stage2
+// target=x86_64-linux-none
+//
+// :1:29: error: callconv 'Signal' is only available on AVR, not x86_64
diff --git a/test/cases/compile_errors/callconv_stdcall_fastcall_thiscall_on_unsupported_platform.zig b/test/cases/compile_errors/callconv_stdcall_fastcall_thiscall_on_unsupported_platform.zig
new file mode 100644
index 0000000000000000000000000000000000000000..d22fd13e8a473ae49e18572f9fbd2a3aa8b863c8
--- /dev/null
+++ b/test/cases/compile_errors/callconv_stdcall_fastcall_thiscall_on_unsupported_platform.zig
@@ -0,0 +1,23 @@
+const F1 = fn () callconv(.Stdcall) void;
+const F2 = fn () callconv(.Fastcall) void;
+const F3 = fn () callconv(.Thiscall) void;
+export fn entry1() void {
+    var a: F1 = undefined;
+    _ = a;
+}
+export fn entry2() void {
+    var a: F2 = undefined;
+    _ = a;
+}
+export fn entry3() void {
+    var a: F3 = undefined;
+    _ = a;
+}
+
+// error
+// backend=stage2
+// target=x86_64-linux-none
+//
+// :1:28: error: callconv 'Stdcall' is only available on i386, not x86_64
+// :2:28: error: callconv 'Fastcall' is only available on i386, not x86_64
+// :3:28: error: callconv 'Thiscall' is only available on i386, not x86_64
diff --git a/test/cases/compile_errors/callconv_vectorcall_on_unsupported_platform.zig b/test/cases/compile_errors/callconv_vectorcall_on_unsupported_platform.zig
new file mode 100644
index 0000000000000000000000000000000000000000..9c231a6ea80db2640d3650ae592dfefa421749de
--- /dev/null
+++ b/test/cases/compile_errors/callconv_vectorcall_on_unsupported_platform.zig
@@ -0,0 +1,7 @@
+export fn entry() callconv(.Vectorcall) void {}
+
+// error
+// backend=stage2
+// target=x86_64-linux-none
+//
+// :1:29: error: callconv 'Vectorcall' is only available on i386 and AArch64, not x86_64
diff --git a/test/cases/compile_errors/compile-time_division_by_zero.zig b/test/cases/compile_errors/compile-time_division_by_zero.zig
new file mode 100644
index 0000000000000000000000000000000000000000..969598e50052a53fca49ab77e1172879252fcd3c
--- /dev/null
+++ b/test/cases/compile_errors/compile-time_division_by_zero.zig
@@ -0,0 +1,12 @@
+comptime {
+    const a: i32 = 1;
+    const b: i32 = 0;
+    const c = a / b;
+    _ = c;
+}
+
+// error
+// backend=stage2
+// target=native
+//
+// :4:19: error: division by zero here causes undefined behavior
diff --git a/test/cases/compile_errors/compile-time_remainder_division_by_zero.zig b/test/cases/compile_errors/compile-time_remainder_division_by_zero.zig
new file mode 100644
index 0000000000000000000000000000000000000000..301fad6a68e686906f237e87fd13f720e3525c86
--- /dev/null
+++ b/test/cases/compile_errors/compile-time_remainder_division_by_zero.zig
@@ -0,0 +1,12 @@
+comptime {
+    const a: i32 = 1;
+    const b: i32 = 0;
+    const c = a % b;
+    _ = c;
+}
+
+// error
+// backend=stage2
+// target=native
+//
+// :4:19: error: division by zero here causes undefined behavior
diff --git a/test/cases/compile_errors/compileLog_of_tagged_enum_doesnt_crash_the_compiler.zig b/test/cases/compile_errors/compileLog_of_tagged_enum_doesnt_crash_the_compiler.zig
new file mode 100644
index 0000000000000000000000000000000000000000..9189eeb48d4817cff282977b1c20c8596bb0a7f2
--- /dev/null
+++ b/test/cases/compile_errors/compileLog_of_tagged_enum_doesnt_crash_the_compiler.zig
@@ -0,0 +1,17 @@
+const Bar = union(enum(u32)) {
+    X: i32 = 1
+};
+
+fn testCompileLog(x: Bar) void {
+    @compileLog(x);
+}
+
+pub export fn entry() void {
+    comptime testCompileLog(Bar{.X = 123});
+}
+
+// error
+// backend=stage2
+// target=native
+//
+// :6:5: error: found compile log statement
diff --git a/test/cases/compile_errors/compile_log.zig b/test/cases/compile_errors/compile_log.zig
new file mode 100644
index 0000000000000000000000000000000000000000..281f8747d23fbba125e5236f8499673b40cdaa34
--- /dev/null
+++ b/test/cases/compile_errors/compile_log.zig
@@ -0,0 +1,14 @@
+export fn foo() void {
+    comptime bar(12, "hi",);
+}
+fn bar(a: i32, b: []const u8) void {
+    @compileLog("begin",);
+    @compileLog("a", a, "b", b);
+    @compileLog("end",);
+}
+
+// error
+// backend=llvm
+// target=native
+//
+// :5:5: error: found compile log statement
diff --git a/test/cases/compile_errors/compile_log_statement_inside_function_which_must_be_comptime_evaluated.zig b/test/cases/compile_errors/compile_log_statement_inside_function_which_must_be_comptime_evaluated.zig
new file mode 100644
index 0000000000000000000000000000000000000000..0bc45eae0a753f995216e05fa8d2d89bd6aef8ac
--- /dev/null
+++ b/test/cases/compile_errors/compile_log_statement_inside_function_which_must_be_comptime_evaluated.zig
@@ -0,0 +1,14 @@
+fn Foo(comptime T: type) type {
+    @compileLog(@typeName(T));
+    return T;
+}
+export fn entry() void {
+    _ = Foo(i32);
+    _ = @typeName(Foo(i32));
+}
+
+// error
+// backend=stage2
+// target=native
+//
+// :2:5: error: found compile log statement
diff --git a/test/cases/compile_errors/compile_time_division_by_zero.zig b/test/cases/compile_errors/compile_time_division_by_zero.zig
new file mode 100644
index 0000000000000000000000000000000000000000..281ccf28a1d4b74a21b42376a7f04e4cb11d97e1
--- /dev/null
+++ b/test/cases/compile_errors/compile_time_division_by_zero.zig
@@ -0,0 +1,13 @@
+const y = foo(0);
+fn foo(x: u32) u32 {
+    return 1 / x;
+}
+
+export fn entry() usize { return @sizeOf(@TypeOf(y)); }
+
+// error
+// backend=llvm
+// target=native
+//
+// :3:16: error: division by zero here causes undefined behavior
+// :1:14: note: called from here
diff --git a/test/cases/compile_errors/deref_on_undefined_value.zig b/test/cases/compile_errors/deref_on_undefined_value.zig
new file mode 100644
index 0000000000000000000000000000000000000000..fa12e2824cad3e1794a6d1bad893d4d8f8198af6
--- /dev/null
+++ b/test/cases/compile_errors/deref_on_undefined_value.zig
@@ -0,0 +1,10 @@
+comptime {
+    var a: *u8 = undefined;
+    _ = a.*;
+}
+
+// error
+// backend=stage2
+// target=native
+//
+// :3:10: error: cannot dereference undefined value
diff --git a/test/cases/compile_errors/deref_slice_and_get_len_field.zig b/test/cases/compile_errors/deref_slice_and_get_len_field.zig
new file mode 100644
index 0000000000000000000000000000000000000000..1ba03c6d50cf90ad0c647ec3552f24fb0d5bcc5e
--- /dev/null
+++ b/test/cases/compile_errors/deref_slice_and_get_len_field.zig
@@ -0,0 +1,10 @@
+export fn entry() void {
+    var a: []u8 = undefined;
+    _ = a.*.len;
+}
+
+// error
+// backend=stage2
+// target=native
+//
+// :3:10: error: index syntax required for slice type '[]u8'
diff --git a/test/cases/compile_errors/dereference_an_array.zig b/test/cases/compile_errors/dereference_an_array.zig
new file mode 100644
index 0000000000000000000000000000000000000000..f5aabf081c5a6c6d59668ff2d65362244f179d10
--- /dev/null
+++ b/test/cases/compile_errors/dereference_an_array.zig
@@ -0,0 +1,14 @@
+var s_buffer: [10]u8 = undefined;
+pub fn pass(in: []u8) []u8 {
+    var out = &s_buffer;
+    out.*.* = in[0];
+    return out.*[0..1];
+}
+
+export fn entry() usize { return @sizeOf(@TypeOf(&pass)); }
+
+// error
+// backend=stage2
+// target=native
+//
+// :4:10: error: cannot dereference non-pointer type '[10]u8'
diff --git a/test/cases/compile_errors/dereference_slice.zig b/test/cases/compile_errors/dereference_slice.zig
new file mode 100644
index 0000000000000000000000000000000000000000..7dba3b55d82272bfddc925ca0dbfa586f1952f1e
--- /dev/null
+++ b/test/cases/compile_errors/dereference_slice.zig
@@ -0,0 +1,12 @@
+fn entry(x: []i32) i32 {
+    return x.*;
+}
+comptime {
+    _ = entry;
+}
+
+// error
+// backend=stage2
+// target=native
+//
+// :2:13: error: index syntax required for slice type '[]i32'
diff --git a/test/cases/compile_errors/dereference_unknown_length_pointer.zig b/test/cases/compile_errors/dereference_unknown_length_pointer.zig
new file mode 100644
index 0000000000000000000000000000000000000000..353f94b8d9cb682a55e3b7d2ac72da2201737928
--- /dev/null
+++ b/test/cases/compile_errors/dereference_unknown_length_pointer.zig
@@ -0,0 +1,9 @@
+export fn entry(x: [*]i32) i32 {
+    return x.*;
+}
+
+// error
+// backend=stage2
+// target=native
+//
+// :2:13: error: index syntax required for unknown-length pointer type '[*]i32'
diff --git a/test/cases/compile_errors/discarding_error_value.zig b/test/cases/compile_errors/discarding_error_value.zig
new file mode 100644
index 0000000000000000000000000000000000000000..f74fc4ea29fd1ff963621fac092975dae40f1264
--- /dev/null
+++ b/test/cases/compile_errors/discarding_error_value.zig
@@ -0,0 +1,12 @@
+export fn entry() void {
+    _ = foo();
+}
+fn foo() !void {
+    return error.OutOfMemory;
+}
+
+// error
+// backend=stage2
+// target=native
+//
+// :2:12: error: error is discarded. consider using `try`, `catch`, or `if`
diff --git a/test/cases/compile_errors/division_by_zero.zig b/test/cases/compile_errors/division_by_zero.zig
new file mode 100644
index 0000000000000000000000000000000000000000..2e2f7e2be2a70d4efde71ce4c66ded5d75e6560b
--- /dev/null
+++ b/test/cases/compile_errors/division_by_zero.zig
@@ -0,0 +1,17 @@
+const lit_int_x = 1 / 0;
+const lit_float_x = 1.0 / 0.0;
+const int_x = @as(u32, 1) / @as(u32, 0);
+const float_x = @as(f32, 1.0) / @as(f32, 0.0);
+
+export fn entry1() usize { return @sizeOf(@TypeOf(lit_int_x)); }
+export fn entry2() usize { return @sizeOf(@TypeOf(lit_float_x)); }
+export fn entry3() usize { return @sizeOf(@TypeOf(int_x)); }
+export fn entry4() usize { return @sizeOf(@TypeOf(float_x)); } // no error on purpose
+
+// error
+// backend=stage2
+// target=native
+//
+// :1:23: error: division by zero here causes undefined behavior
+// :2:27: error: division by zero here causes undefined behavior
+// :3:29: error: division by zero here causes undefined behavior
diff --git a/test/cases/compile_errors/duplicate_enum_field.zig b/test/cases/compile_errors/duplicate_enum_field.zig
new file mode 100644
index 0000000000000000000000000000000000000000..ebf01f99a70f89d7fb41ce0cbd66586960a2f917
--- /dev/null
+++ b/test/cases/compile_errors/duplicate_enum_field.zig
@@ -0,0 +1,16 @@
+const Foo = enum {
+    Bar,
+    Bar,
+};
+
+export fn entry() void {
+    const a: Foo = undefined;
+    _ = a;
+}
+
+// error
+// backend=stage2
+// target=native
+//
+// :3:5: error: duplicate enum field 'Bar'
+// :2:5: note: other field here
diff --git a/test/cases/compile_errors/duplicate_error_in_switch.zig b/test/cases/compile_errors/duplicate_error_in_switch.zig
new file mode 100644
index 0000000000000000000000000000000000000000..6e9b1e90996b2b67f8f588647f2e14dd4af11359
--- /dev/null
+++ b/test/cases/compile_errors/duplicate_error_in_switch.zig
@@ -0,0 +1,22 @@
+export fn entry() void {
+    foo(452) catch |err| switch (err) {
+        error.Foo => {},
+        error.Bar => {},
+        error.Foo => {},
+        else => {},
+    };
+}
+fn foo(x: i32) !void {
+    switch (x) {
+        0 ... 10 => return error.Foo,
+        11 ... 20 => return error.Bar,
+        else => {},
+    }
+}
+
+// error
+// backend=llvm
+// target=native
+//
+// :5:9: error: duplicate switch value
+// :3:9: note: other value here
diff --git a/test/cases/compile_errors/error_not_handled_in_switch.zig b/test/cases/compile_errors/error_not_handled_in_switch.zig
new file mode 100644
index 0000000000000000000000000000000000000000..8f0d26a4a92bd745a012c79742b7802bdd971e6b
--- /dev/null
+++ b/test/cases/compile_errors/error_not_handled_in_switch.zig
@@ -0,0 +1,21 @@
+export fn entry() void {
+    foo(452) catch |err| switch (err) {
+        error.Foo => {},
+    };
+}
+fn foo(x: i32) !void {
+    switch (x) {
+        0 ... 10 => return error.Foo,
+        11 ... 20 => return error.Bar,
+        21 ... 30 => return error.Baz,
+        else => {},
+    }
+}
+
+// error
+// backend=llvm
+// target=native
+//
+// :2:26: error: switch must handle all possibilities
+// :2:26: note: unhandled error value: 'error.Bar'
+// :2:26: note: unhandled error value: 'error.Baz'
diff --git a/test/cases/compile_errors/explicitly_casting_non_tag_type_to_enum.zig b/test/cases/compile_errors/explicitly_casting_non_tag_type_to_enum.zig
new file mode 100644
index 0000000000000000000000000000000000000000..aac876e61476258910cef5cf44558302f1d1392c
--- /dev/null
+++ b/test/cases/compile_errors/explicitly_casting_non_tag_type_to_enum.zig
@@ -0,0 +1,18 @@
+const Small = enum(u2) {
+    One,
+    Two,
+    Three,
+    Four,
+};
+
+export fn entry() void {
+    var y = @as(f32, 3);
+    var x = @intToEnum(Small, y);
+    _ = x;
+}
+
+// error
+// backend=stage2
+// target=native
+//
+// :10:31: error: expected integer type, found 'f32'
diff --git a/test/cases/compile_errors/fieldParentPtr-comptime_field_ptr_not_based_on_struct.zig b/test/cases/compile_errors/fieldParentPtr-comptime_field_ptr_not_based_on_struct.zig
new file mode 100644
index 0000000000000000000000000000000000000000..7f57268f0645ad067a928eed8155f402db10d9f0
--- /dev/null
+++ b/test/cases/compile_errors/fieldParentPtr-comptime_field_ptr_not_based_on_struct.zig
@@ -0,0 +1,17 @@
+const Foo = struct {
+    a: i32,
+    b: i32,
+};
+const foo = Foo { .a = 1, .b = 2, };
+
+comptime {
+    const field_ptr = @intToPtr(*i32, 0x1234);
+    const another_foo_ptr = @fieldParentPtr(Foo, "b", field_ptr);
+    _ = another_foo_ptr;
+}
+
+// error
+// backend=stage2
+// target=native
+//
+// :9:55: error: pointer value not based on parent struct
diff --git a/test/cases/compile_errors/fieldParentPtr-comptime_wrong_field_index.zig b/test/cases/compile_errors/fieldParentPtr-comptime_wrong_field_index.zig
new file mode 100644
index 0000000000000000000000000000000000000000..a73409aea3368300a6a397f0dffc2db57f913c7a
--- /dev/null
+++ b/test/cases/compile_errors/fieldParentPtr-comptime_wrong_field_index.zig
@@ -0,0 +1,17 @@
+const Foo = struct {
+    a: i32,
+    b: i32,
+};
+const foo = Foo { .a = 1, .b = 2, };
+
+comptime {
+    const another_foo_ptr = @fieldParentPtr(Foo, "b", &foo.a);
+    _ = another_foo_ptr;
+}
+
+// error
+// backend=stage2
+// target=native
+//
+// :8:29: error: field 'b' has index '1' but pointer value is index '0' of struct 'tmp.Foo'
+// :1:13: note: struct declared here
diff --git a/test/cases/compile_errors/fieldParentPtr-field_pointer_is_not_pointer.zig b/test/cases/compile_errors/fieldParentPtr-field_pointer_is_not_pointer.zig
new file mode 100644
index 0000000000000000000000000000000000000000..8a57d08c3ba166886fa0936c8af7e7419668a680
--- /dev/null
+++ b/test/cases/compile_errors/fieldParentPtr-field_pointer_is_not_pointer.zig
@@ -0,0 +1,12 @@
+const Foo = extern struct {
+    a: i32,
+};
+export fn foo(a: i32) *Foo {
+    return @fieldParentPtr(Foo, "a", a);
+}
+
+// error
+// backend=stage2
+// target=native
+//
+// :5:38: error: expected pointer type, found 'i32'
diff --git a/test/cases/compile_errors/field_access_of_opaque_type.zig b/test/cases/compile_errors/field_access_of_opaque_type.zig
new file mode 100644
index 0000000000000000000000000000000000000000..f9ec483305cfa3a0abb06d8467d14bccbd6d1b10
--- /dev/null
+++ b/test/cases/compile_errors/field_access_of_opaque_type.zig
@@ -0,0 +1,16 @@
+const MyType = opaque {};
+
+export fn entry() bool {
+    var x: i32 = 1;
+    return bar(@ptrCast(*MyType, &x));
+}
+
+fn bar(x: *MyType) bool {
+    return x.blah;
+}
+
+// error
+// backend=stage2
+// target=native
+//
+// :9:13: error: type '*tmp.MyType' does not support field access
diff --git a/test/cases/compile_errors/field_access_of_slices.zig b/test/cases/compile_errors/field_access_of_slices.zig
new file mode 100644
index 0000000000000000000000000000000000000000..1fbfda9646916ac61a61afe496065ca012a3dbeb
--- /dev/null
+++ b/test/cases/compile_errors/field_access_of_slices.zig
@@ -0,0 +1,12 @@
+export fn entry() void {
+    var slice: []i32 = undefined;
+    const info = @TypeOf(slice).unknown;
+    _ = info;
+}
+
+// error
+// backend=stage2
+// target=native
+//
+// :3:32: error: type '[]i32' has no members
+// :3:32: note: slice values have 'len' and 'ptr' members
diff --git a/test/cases/compile_errors/field_access_of_unknown_length_pointer.zig b/test/cases/compile_errors/field_access_of_unknown_length_pointer.zig
new file mode 100644
index 0000000000000000000000000000000000000000..2f526277fe152d0f3fd558fd066cc4fe05c79b07
--- /dev/null
+++ b/test/cases/compile_errors/field_access_of_unknown_length_pointer.zig
@@ -0,0 +1,13 @@
+const Foo = extern struct {
+    a: i32,
+};
+
+export fn entry(foo: [*]Foo) void {
+    foo.a += 1;
+}
+
+// error
+// backend=stage2
+// target=native
+//
+// :6:8: error: type '[*]tmp.Foo' does not support field access
diff --git a/test/cases/compile_errors/ignored_deferred_function_call.zig b/test/cases/compile_errors/ignored_deferred_function_call.zig
new file mode 100644
index 0000000000000000000000000000000000000000..69df8b04981fb3c7e5ef9a6fff550c5b37293d39
--- /dev/null
+++ b/test/cases/compile_errors/ignored_deferred_function_call.zig
@@ -0,0 +1,10 @@
+export fn foo() void {
+    defer bar();
+}
+fn bar() anyerror!i32 { return 0; }
+
+// error
+// backend=stage2
+// target=native
+//
+// :2:14: error: error is ignored. consider using `try`, `catch`, or `if`
diff --git a/test/cases/compile_errors/ignored_expression_in_while_continuation.zig b/test/cases/compile_errors/ignored_expression_in_while_continuation.zig
new file mode 100644
index 0000000000000000000000000000000000000000..d295d476ab000c075b6cc2bdb4172f08acd6d95a
--- /dev/null
+++ b/test/cases/compile_errors/ignored_expression_in_while_continuation.zig
@@ -0,0 +1,22 @@
+export fn a() void {
+    while (true) : (bad()) {}
+}
+export fn b() void {
+    var x: anyerror!i32 = 1234;
+    while (x) |_| : (bad()) {} else |_| {}
+}
+export fn c() void {
+    var x: ?i32 = 1234;
+    while (x) |_| : (bad()) {}
+}
+fn bad() anyerror!void {
+    return error.Bad;
+}
+
+// error
+// backend=stage2
+// target=native
+//
+// :2:24: error: error is ignored. consider using `try`, `catch`, or `if`
+// :6:25: error: error is ignored. consider using `try`, `catch`, or `if`
+// :10:25: error: error is ignored. consider using `try`, `catch`, or `if`
diff --git a/test/cases/compile_errors/illegal_comparison_of_types.zig b/test/cases/compile_errors/illegal_comparison_of_types.zig
new file mode 100644
index 0000000000000000000000000000000000000000..69d7a28fa44f33681f6d1bd96ea4d5daaf67b209
--- /dev/null
+++ b/test/cases/compile_errors/illegal_comparison_of_types.zig
@@ -0,0 +1,20 @@
+fn bad_eql_1(a: []u8, b: []u8) bool {
+    return a == b;
+}
+const EnumWithData = union(enum) {
+    One: void,
+    Two: i32,
+};
+fn bad_eql_2(a: *const EnumWithData, b: *const EnumWithData) bool {
+    return a.* == b.*;
+}
+
+export fn entry1() usize { return @sizeOf(@TypeOf(&bad_eql_1)); }
+export fn entry2() usize { return @sizeOf(@TypeOf(&bad_eql_2)); }
+
+// error
+// backend=stage2
+// target=native
+//
+// :2:14: error: operator == not allowed for type '[]u8'
+// :9:16: error: operator == not allowed for type 'tmp.EnumWithData'
diff --git a/test/cases/compile_errors/implicitly_casting_enum_to_tag_type.zig b/test/cases/compile_errors/implicitly_casting_enum_to_tag_type.zig
new file mode 100644
index 0000000000000000000000000000000000000000..b1930cb54800cb780b5110a03a7a8cede44d5943
--- /dev/null
+++ b/test/cases/compile_errors/implicitly_casting_enum_to_tag_type.zig
@@ -0,0 +1,17 @@
+const Small = enum(u2) {
+    One,
+    Two,
+    Three,
+    Four,
+};
+
+export fn entry() void {
+    var x: u2 = Small.Two;
+    _ = x;
+}
+
+// error
+// backend=stage2
+// target=native
+//
+// :9:22: error: expected type 'u2', found 'tmp.Small'
diff --git a/test/cases/compile_errors/incorrect_return_type.zig b/test/cases/compile_errors/incorrect_return_type.zig
new file mode 100644
index 0000000000000000000000000000000000000000..b37cbebc7fbf4c3d6ca23d23644f57282f1fae0b
--- /dev/null
+++ b/test/cases/compile_errors/incorrect_return_type.zig
@@ -0,0 +1,21 @@
+ pub export fn entry() void{
+     _ = foo();
+ }
+ const A = struct {
+     a: u32,
+ };
+ fn foo() A {
+     return bar();
+ }
+ const B = struct {
+     a: u32,
+ };
+ fn bar() B {
+     unreachable;
+ }
+
+// error
+// backend=stage2
+// target=native
+//
+// :8:16: error: expected type 'tmp.A', found 'tmp.B'
diff --git a/test/cases/compile_errors/indexing_an_array_of_size_zero.zig b/test/cases/compile_errors/indexing_an_array_of_size_zero.zig
new file mode 100644
index 0000000000000000000000000000000000000000..d2a54046de2faa36537d9d80abadbb75e8ead95e
--- /dev/null
+++ b/test/cases/compile_errors/indexing_an_array_of_size_zero.zig
@@ -0,0 +1,11 @@
+const array = [_]u8{};
+export fn foo() void {
+    const pointer = &array[0];
+    _ = pointer;
+}
+
+// error
+// backend=stage2
+// target=native
+//
+// :3:27: error: indexing into empty array is not allowed
diff --git a/test/cases/compile_errors/indexing_an_array_of_size_zero_with_runtime_index.zig b/test/cases/compile_errors/indexing_an_array_of_size_zero_with_runtime_index.zig
new file mode 100644
index 0000000000000000000000000000000000000000..eceb5db50e18423a4b9480e887b6d49b12af4e82
--- /dev/null
+++ b/test/cases/compile_errors/indexing_an_array_of_size_zero_with_runtime_index.zig
@@ -0,0 +1,12 @@
+const array = [_]u8{};
+export fn foo() void {
+    var index: usize = 0;
+    const pointer = &array[index];
+    _ = pointer;
+}
+
+// error
+// backend=stage2
+// target=native
+//
+// :4:27: error: indexing into empty array is not allowed
diff --git a/test/cases/compile_errors/indexing_single-item_pointer.zig b/test/cases/compile_errors/indexing_single-item_pointer.zig
new file mode 100644
index 0000000000000000000000000000000000000000..efd063817cadb3191642b422352ff1c709e0914e
--- /dev/null
+++ b/test/cases/compile_errors/indexing_single-item_pointer.zig
@@ -0,0 +1,9 @@
+export fn entry(ptr: *i32) i32 {
+    return ptr[1];
+}
+
+// error
+// backend=stage2
+// target=native
+//
+// :2:15: error: element access of non-indexable type '*i32'
diff --git a/test/cases/compile_errors/invalid_cast_from_integral_type_to_enum.zig b/test/cases/compile_errors/invalid_cast_from_integral_type_to_enum.zig
new file mode 100644
index 0000000000000000000000000000000000000000..ce2f64169b5c0f6ca587e246c3d6e81b5015ba54
--- /dev/null
+++ b/test/cases/compile_errors/invalid_cast_from_integral_type_to_enum.zig
@@ -0,0 +1,17 @@
+const E = enum(usize) { One, Two };
+
+export fn entry() void {
+    foo(1);
+}
+
+fn foo(x: usize) void {
+    switch (x) {
+        E.One => {},
+    }
+}
+
+// error
+// backend=stage2
+// target=native
+//
+// :9:10: error: expected type 'usize', found 'tmp.E'
diff --git a/test/cases/compile_errors/invalid_deref_on_switch_target.zig b/test/cases/compile_errors/invalid_deref_on_switch_target.zig
new file mode 100644
index 0000000000000000000000000000000000000000..a880b16fca8579d4cf982582834aa3c349a31857
--- /dev/null
+++ b/test/cases/compile_errors/invalid_deref_on_switch_target.zig
@@ -0,0 +1,17 @@
+comptime {
+    var tile = Tile.Empty;
+    switch (tile.*) {
+        Tile.Empty => {},
+        Tile.Filled => {},
+    }
+}
+const Tile = enum {
+    Empty,
+    Filled,
+};
+
+// error
+// backend=stage2
+// target=native
+//
+// :3:17: error: cannot dereference non-pointer type 'tmp.Tile'
diff --git a/test/cases/compile_errors/invalid_multiple_dereferences.zig b/test/cases/compile_errors/invalid_multiple_dereferences.zig
new file mode 100644
index 0000000000000000000000000000000000000000..3edebf7b1f79383e73e669bae0f1f82ccc13a00c
--- /dev/null
+++ b/test/cases/compile_errors/invalid_multiple_dereferences.zig
@@ -0,0 +1,19 @@
+export fn a() void {
+    var box = Box{ .field = 0 };
+    box.*.field = 1;
+}
+export fn b() void {
+    var box = Box{ .field = 0 };
+    var boxPtr = &box;
+    boxPtr.*.*.field = 1;
+}
+pub const Box = struct {
+    field: i32,
+};
+
+// error
+// backend=stage2
+// target=native
+//
+// :3:8: error: cannot dereference non-pointer type 'tmp.Box'
+// :8:13: error: cannot dereference non-pointer type 'tmp.Box'
diff --git a/test/cases/compile_errors/runtime_indexing_comptime_array.zig b/test/cases/compile_errors/runtime_indexing_comptime_array.zig
index 16f7305f631ddce876c8896b4493fa4e817dad0b..b83e977b3f9bbca6fff24986e37338fe3163a4fc 100644
--- a/test/cases/compile_errors/runtime_indexing_comptime_array.zig
+++ b/test/cases/compile_errors/runtime_indexing_comptime_array.zig
@@ -24,9 +24,9 @@ pub export fn entry3() void {
 // target=native
 // backend=stage2
 //
-// :6:5: error: values of type '[2]fn() void' must be comptime known, but index value is runtime known
-// :6:5: note: use '*const fn() void' for a function pointer type
-// :13:5: error: values of type '[2]fn() void' must be comptime known, but index value is runtime known
-// :13:5: note: use '*const fn() void' for a function pointer type
-// :19:5: error: values of type '[2]fn() void' must be comptime known, but index value is runtime known
-// :19:5: note: use '*const fn() void' for a function pointer type
+// :7:10: error: values of type '[2]fn() void' must be comptime known, but index value is runtime known
+// :7:10: note: use '*const fn() void' for a function pointer type
+// :15:18: error: values of type '[2]fn() void' must be comptime known, but index value is runtime known
+// :15:17: note: use '*const fn() void' for a function pointer type
+// :21:19: error: values of type '[2]fn() void' must be comptime known, but index value is runtime known
+// :21:18: note: use '*const fn() void' for a function pointer type
diff --git a/test/cases/compile_errors/stage1/comptime_ptrcast_of_zero-sized_type.zig b/test/cases/compile_errors/stage1/comptime_ptrcast_of_zero-sized_type.zig
new file mode 100644
index 0000000000000000000000000000000000000000..231e735cfa4d58e356123505bb6c8f7134146963
--- /dev/null
+++ b/test/cases/compile_errors/stage1/comptime_ptrcast_of_zero-sized_type.zig
@@ -0,0 +1,12 @@
+fn foo() void {
+    const node: struct {} = undefined;
+    const vla_ptr = @ptrCast([*]const u8, &node);
+    _ = vla_ptr;
+}
+comptime { foo(); }
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:3:21: error: '*const struct:2:17' and '[*]const u8' do not have the same in-memory representation
diff --git a/test/cases/compile_errors/stage1/deref_on_undefined_value.zig b/test/cases/compile_errors/stage1/deref_on_undefined_value.zig
deleted file mode 100644
index f64d567a26c242685a23f91fb3752134f97b4940..0000000000000000000000000000000000000000
--- a/test/cases/compile_errors/stage1/deref_on_undefined_value.zig
+++ /dev/null
@@ -1,10 +0,0 @@
-comptime {
-    var a: *u8 = undefined;
-    _ = a.*;
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:3:9: error: attempt to dereference undefined value
diff --git a/test/cases/compile_errors/stage1/error_equality_but_sets_have_no_common_members.zig b/test/cases/compile_errors/stage1/error_equality_but_sets_have_no_common_members.zig
new file mode 100644
index 0000000000000000000000000000000000000000..d42169b5036f40ba0725358de24a370d58b85bc9
--- /dev/null
+++ b/test/cases/compile_errors/stage1/error_equality_but_sets_have_no_common_members.zig
@@ -0,0 +1,16 @@
+const Set1 = error{A, C};
+const Set2 = error{B, D};
+export fn entry() void {
+    foo(Set1.A);
+}
+fn foo(x: Set1) void {
+    if (x == Set2.B) {
+
+    }
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:7:11: error: error sets 'Set1' and 'Set2' have no common errors
diff --git a/test/cases/compile_errors/stage1/implicit_cast_from_f64_to_f32.zig b/test/cases/compile_errors/stage1/implicit_cast_from_f64_to_f32.zig
new file mode 100644
index 0000000000000000000000000000000000000000..f18a46b7f51c2be13c0792ee3ff5dda84700da0f
--- /dev/null
+++ b/test/cases/compile_errors/stage1/implicit_cast_from_f64_to_f32.zig
@@ -0,0 +1,10 @@
+var x: f64 = 1.0;
+var y: f32 = x;
+
+export fn entry() usize { return @sizeOf(@TypeOf(y)); }
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:2:14: error: expected type 'f32', found 'f64'
diff --git a/test/cases/compile_errors/stage1/int_to_ptr_of_0_bits.zig b/test/cases/compile_errors/stage1/int_to_ptr_of_0_bits.zig
new file mode 100644
index 0000000000000000000000000000000000000000..7b65cdf836eb711121f72c81f20697d8d4dc413c
--- /dev/null
+++ b/test/cases/compile_errors/stage1/int_to_ptr_of_0_bits.zig
@@ -0,0 +1,11 @@
+export fn foo() void {
+    var x: usize = 0x1000;
+    var y: *void = @intToPtr(*void, x);
+    _ = y;
+}
+
+// error
+// backend=stage1
+// target=native
+//
+// tmp.zig:3:30: error: type '*void' has 0 bits and cannot store information
diff --git a/test/cases/compile_errors/stage1/obj/assign_to_invalid_dereference.zig b/test/cases/compile_errors/stage1/obj/assign_to_invalid_dereference.zig
deleted file mode 100644
index 7fef5db83c33e930d40686158e122b081a9c9121..0000000000000000000000000000000000000000
--- a/test/cases/compile_errors/stage1/obj/assign_to_invalid_dereference.zig
+++ /dev/null
@@ -1,9 +0,0 @@
-export fn entry() void {
-    'a'.* = 1;
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:2:8: error: attempt to dereference non-pointer type 'comptime_int'
diff --git a/test/cases/compile_errors/stage1/obj/bitCast_to_enum_type.zig b/test/cases/compile_errors/stage1/obj/bitCast_to_enum_type.zig
deleted file mode 100644
index 4d63ab9e019a540760e3d3196e66dbd3b999bc2f..0000000000000000000000000000000000000000
--- a/test/cases/compile_errors/stage1/obj/bitCast_to_enum_type.zig
+++ /dev/null
@@ -1,10 +0,0 @@
-export fn entry() void {
-    const y = @bitCast(enum(u32) { a, b }, @as(u32, 3));
-    _ = y;
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:2:24: error: cannot cast a value of type 'y'
diff --git a/test/cases/compile_errors/stage1/obj/bogus_compile_var.zig b/test/cases/compile_errors/stage1/obj/bogus_compile_var.zig
deleted file mode 100644
index 845d943c7ddc973769b2db96407f611f6c2bb43e..0000000000000000000000000000000000000000
--- a/test/cases/compile_errors/stage1/obj/bogus_compile_var.zig
+++ /dev/null
@@ -1,8 +0,0 @@
-const x = @import("builtin").bogus;
-export fn entry() usize { return @sizeOf(@TypeOf(x)); }
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:1:29: error: container 'builtin' has no member called 'bogus'
diff --git a/test/cases/compile_errors/stage1/obj/callconv_apcs_aapcs_aapcsvfp_on_unsupported_platform.zig b/test/cases/compile_errors/stage1/obj/callconv_apcs_aapcs_aapcsvfp_on_unsupported_platform.zig
deleted file mode 100644
index fa062878036cc6a321068c9b1489a809367fde59..0000000000000000000000000000000000000000
--- a/test/cases/compile_errors/stage1/obj/callconv_apcs_aapcs_aapcsvfp_on_unsupported_platform.zig
+++ /dev/null
@@ -1,11 +0,0 @@
-export fn entry1() callconv(.APCS) void {}
-export fn entry2() callconv(.AAPCS) void {}
-export fn entry3() callconv(.AAPCSVFP) void {}
-
-// error
-// backend=stage1
-// target=x86_64-linux-none
-//
-// tmp.zig:1:29: error: callconv 'APCS' is only available on ARM, not x86_64
-// tmp.zig:2:29: error: callconv 'AAPCS' is only available on ARM, not x86_64
-// tmp.zig:3:29: error: callconv 'AAPCSVFP' is only available on ARM, not x86_64
diff --git a/test/cases/compile_errors/stage1/obj/callconv_interrupt_on_unsupported_platform.zig b/test/cases/compile_errors/stage1/obj/callconv_interrupt_on_unsupported_platform.zig
deleted file mode 100644
index 8304fb90c1edc167edec2f9ca142bd6675c3116d..0000000000000000000000000000000000000000
--- a/test/cases/compile_errors/stage1/obj/callconv_interrupt_on_unsupported_platform.zig
+++ /dev/null
@@ -1,7 +0,0 @@
-export fn entry() callconv(.Interrupt) void {}
-
-// error
-// backend=stage1
-// target=aarch64-linux-none
-//
-// tmp.zig:1:28: error: callconv 'Interrupt' is only available on x86, x86_64, AVR, and MSP430, not aarch64
diff --git a/test/cases/compile_errors/stage1/obj/callconv_signal_on_unsupported_platform.zig b/test/cases/compile_errors/stage1/obj/callconv_signal_on_unsupported_platform.zig
deleted file mode 100644
index 4b19b188fdd8c8b6d03c54886f97e5e75614e83c..0000000000000000000000000000000000000000
--- a/test/cases/compile_errors/stage1/obj/callconv_signal_on_unsupported_platform.zig
+++ /dev/null
@@ -1,7 +0,0 @@
-export fn entry() callconv(.Signal) void {}
-
-// error
-// backend=stage1
-// target=x86_64-linux-none
-//
-// tmp.zig:1:28: error: callconv 'Signal' is only available on AVR, not x86_64
diff --git a/test/cases/compile_errors/stage1/obj/callconv_stdcall_fastcall_thiscall_on_unsupported_platform-0.zig b/test/cases/compile_errors/stage1/obj/callconv_stdcall_fastcall_thiscall_on_unsupported_platform-0.zig
deleted file mode 100644
index f4994107cd13bae21514393ebcce71f88f36b785..0000000000000000000000000000000000000000
--- a/test/cases/compile_errors/stage1/obj/callconv_stdcall_fastcall_thiscall_on_unsupported_platform-0.zig
+++ /dev/null
@@ -1,23 +0,0 @@
-const F1 = fn () callconv(.Stdcall) void;
-const F2 = fn () callconv(.Fastcall) void;
-const F3 = fn () callconv(.Thiscall) void;
-export fn entry1() void {
-    var a: F1 = undefined;
-    _ = a;
-}
-export fn entry2() void {
-    var a: F2 = undefined;
-    _ = a;
-}
-export fn entry3() void {
-    var a: F3 = undefined;
-    _ = a;
-}
-
-// error
-// backend=stage1
-// target=x86_64-linux-none
-//
-// tmp.zig:1:27: error: callconv 'Stdcall' is only available on x86, not x86_64
-// tmp.zig:2:27: error: callconv 'Fastcall' is only available on x86, not x86_64
-// tmp.zig:3:27: error: callconv 'Thiscall' is only available on x86, not x86_64
diff --git a/test/cases/compile_errors/stage1/obj/callconv_stdcall_fastcall_thiscall_on_unsupported_platform-1.zig b/test/cases/compile_errors/stage1/obj/callconv_stdcall_fastcall_thiscall_on_unsupported_platform-1.zig
deleted file mode 100644
index aa23f9ae51714129903e57ab42655c3656eada31..0000000000000000000000000000000000000000
--- a/test/cases/compile_errors/stage1/obj/callconv_stdcall_fastcall_thiscall_on_unsupported_platform-1.zig
+++ /dev/null
@@ -1,11 +0,0 @@
-export fn entry1() callconv(.Stdcall) void {}
-export fn entry2() callconv(.Fastcall) void {}
-export fn entry3() callconv(.Thiscall) void {}
-
-// error
-// backend=stage1
-// target=x86_64-linux-none
-//
-// tmp.zig:1:29: error: callconv 'Stdcall' is only available on x86, not x86_64
-// tmp.zig:2:29: error: callconv 'Fastcall' is only available on x86, not x86_64
-// tmp.zig:3:29: error: callconv 'Thiscall' is only available on x86, not x86_64
diff --git a/test/cases/compile_errors/stage1/obj/callconv_vectorcall_on_unsupported_platform.zig b/test/cases/compile_errors/stage1/obj/callconv_vectorcall_on_unsupported_platform.zig
deleted file mode 100644
index e60e6ab42c0b9ab8bc756af0ec979502ad9a3dc8..0000000000000000000000000000000000000000
--- a/test/cases/compile_errors/stage1/obj/callconv_vectorcall_on_unsupported_platform.zig
+++ /dev/null
@@ -1,7 +0,0 @@
-export fn entry() callconv(.Vectorcall) void {}
-
-// error
-// backend=stage1
-// target=x86_64-linux-none
-//
-// tmp.zig:1:28: error: callconv 'Vectorcall' is only available on x86 and AArch64, not x86_64
diff --git a/test/cases/compile_errors/stage1/obj/compile-time_division_by_zero.zig b/test/cases/compile_errors/stage1/obj/compile-time_division_by_zero.zig
deleted file mode 100644
index e16f5f8cf40daa97aa8da6e62898055520129cc3..0000000000000000000000000000000000000000
--- a/test/cases/compile_errors/stage1/obj/compile-time_division_by_zero.zig
+++ /dev/null
@@ -1,12 +0,0 @@
-comptime {
-    const a: i32 = 1;
-    const b: i32 = 0;
-    const c = a / b;
-    _ = c;
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:4:17: error: division by zero
diff --git a/test/cases/compile_errors/stage1/obj/compile-time_remainder_division_by_zero.zig b/test/cases/compile_errors/stage1/obj/compile-time_remainder_division_by_zero.zig
deleted file mode 100644
index 63f0def52c1e50e85118461ba84a00e30559ce31..0000000000000000000000000000000000000000
--- a/test/cases/compile_errors/stage1/obj/compile-time_remainder_division_by_zero.zig
+++ /dev/null
@@ -1,12 +0,0 @@
-comptime {
-    const a: i32 = 1;
-    const b: i32 = 0;
-    const c = a % b;
-    _ = c;
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:4:17: error: division by zero
diff --git a/test/cases/compile_errors/stage1/obj/compileLog_of_tagged_enum_doesnt_crash_the_compiler.zig b/test/cases/compile_errors/stage1/obj/compileLog_of_tagged_enum_doesnt_crash_the_compiler.zig
deleted file mode 100644
index 36e1ee111850e05b7be54c3017c49bbc61d94205..0000000000000000000000000000000000000000
--- a/test/cases/compile_errors/stage1/obj/compileLog_of_tagged_enum_doesnt_crash_the_compiler.zig
+++ /dev/null
@@ -1,17 +0,0 @@
-const Bar = union(enum(u32)) {
-    X: i32 = 1
-};
-
-fn testCompileLog(x: Bar) void {
-    @compileLog(x);
-}
-
-pub fn main () void {
-    comptime testCompileLog(Bar{.X = 123});
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:6:5: error: found compile log statement
diff --git a/test/cases/compile_errors/stage1/obj/compile_log.zig b/test/cases/compile_errors/stage1/obj/compile_log.zig
deleted file mode 100644
index 7f5d52240769afe7e61eb9f70ed52ef8f9c6f6fb..0000000000000000000000000000000000000000
--- a/test/cases/compile_errors/stage1/obj/compile_log.zig
+++ /dev/null
@@ -1,16 +0,0 @@
-export fn foo() void {
-    comptime bar(12, "hi",);
-}
-fn bar(a: i32, b: []const u8) void {
-    @compileLog("begin",);
-    @compileLog("a", a, "b", b);
-    @compileLog("end",);
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:5:5: error: found compile log statement
-// tmp.zig:6:5: error: found compile log statement
-// tmp.zig:7:5: error: found compile log statement
diff --git a/test/cases/compile_errors/stage1/obj/compile_log_statement_inside_function_which_must_be_comptime_evaluated.zig b/test/cases/compile_errors/stage1/obj/compile_log_statement_inside_function_which_must_be_comptime_evaluated.zig
deleted file mode 100644
index 19b96048cb90dd9857a26f57ee8a77e8d757edf7..0000000000000000000000000000000000000000
--- a/test/cases/compile_errors/stage1/obj/compile_log_statement_inside_function_which_must_be_comptime_evaluated.zig
+++ /dev/null
@@ -1,14 +0,0 @@
-fn Foo(comptime T: type) type {
-    @compileLog(@typeName(T));
-    return T;
-}
-export fn entry() void {
-    _ = Foo(i32);
-    _ = @typeName(Foo(i32));
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:2:5: error: found compile log statement
diff --git a/test/cases/compile_errors/stage1/obj/compile_time_division_by_zero.zig b/test/cases/compile_errors/stage1/obj/compile_time_division_by_zero.zig
deleted file mode 100644
index 7f7e168f027cc4221584ed770602b8a86b937c7a..0000000000000000000000000000000000000000
--- a/test/cases/compile_errors/stage1/obj/compile_time_division_by_zero.zig
+++ /dev/null
@@ -1,12 +0,0 @@
-const y = foo(0);
-fn foo(x: u32) u32 {
-    return 1 / x;
-}
-
-export fn entry() usize { return @sizeOf(@TypeOf(y)); }
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:3:14: error: division by zero
diff --git a/test/cases/compile_errors/stage1/obj/comptime_ptrcast_of_zero-sized_type.zig b/test/cases/compile_errors/stage1/obj/comptime_ptrcast_of_zero-sized_type.zig
deleted file mode 100644
index 231e735cfa4d58e356123505bb6c8f7134146963..0000000000000000000000000000000000000000
--- a/test/cases/compile_errors/stage1/obj/comptime_ptrcast_of_zero-sized_type.zig
+++ /dev/null
@@ -1,12 +0,0 @@
-fn foo() void {
-    const node: struct {} = undefined;
-    const vla_ptr = @ptrCast([*]const u8, &node);
-    _ = vla_ptr;
-}
-comptime { foo(); }
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:3:21: error: '*const struct:2:17' and '[*]const u8' do not have the same in-memory representation
diff --git a/test/cases/compile_errors/stage1/obj/deref_slice_and_get_len_field.zig b/test/cases/compile_errors/stage1/obj/deref_slice_and_get_len_field.zig
deleted file mode 100644
index 98097597cc8f4db61359dd8b2751a63edd4c3dd0..0000000000000000000000000000000000000000
--- a/test/cases/compile_errors/stage1/obj/deref_slice_and_get_len_field.zig
+++ /dev/null
@@ -1,10 +0,0 @@
-export fn entry() void {
-    var a: []u8 = undefined;
-    _ = a.*.len;
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:3:10: error: attempt to dereference non-pointer type '[]u8'
diff --git a/test/cases/compile_errors/stage1/obj/dereference_an_array.zig b/test/cases/compile_errors/stage1/obj/dereference_an_array.zig
deleted file mode 100644
index 0dd91f70e53aa347ea69ddd58c570dc119e0aa65..0000000000000000000000000000000000000000
--- a/test/cases/compile_errors/stage1/obj/dereference_an_array.zig
+++ /dev/null
@@ -1,14 +0,0 @@
-var s_buffer: [10]u8 = undefined;
-pub fn pass(in: []u8) []u8 {
-    var out = &s_buffer;
-    out.*.* = in[0];
-    return out.*[0..1];
-}
-
-export fn entry() usize { return @sizeOf(@TypeOf(pass)); }
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:4:10: error: attempt to dereference non-pointer type '[10]u8'
diff --git a/test/cases/compile_errors/stage1/obj/dereference_unknown_length_pointer.zig b/test/cases/compile_errors/stage1/obj/dereference_unknown_length_pointer.zig
deleted file mode 100644
index c305e4bc98abcae6029bd64f708e8ecf2b022a5b..0000000000000000000000000000000000000000
--- a/test/cases/compile_errors/stage1/obj/dereference_unknown_length_pointer.zig
+++ /dev/null
@@ -1,9 +0,0 @@
-export fn entry(x: [*]i32) i32 {
-    return x.*;
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:2:13: error: index syntax required for unknown-length pointer type '[*]i32'
diff --git a/test/cases/compile_errors/stage1/obj/discarding_error_value.zig b/test/cases/compile_errors/stage1/obj/discarding_error_value.zig
deleted file mode 100644
index dcfa22e8cb3412e1b2741267973eca6d9e3c3884..0000000000000000000000000000000000000000
--- a/test/cases/compile_errors/stage1/obj/discarding_error_value.zig
+++ /dev/null
@@ -1,12 +0,0 @@
-export fn entry() void {
-    _ = foo();
-}
-fn foo() !void {
-    return error.OutOfMemory;
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:2:12: error: error is discarded. consider using `try`, `catch`, or `if`
diff --git a/test/cases/compile_errors/stage1/obj/division_by_zero.zig b/test/cases/compile_errors/stage1/obj/division_by_zero.zig
deleted file mode 100644
index 3023f0c6f3f729891880630b31d43754fc1957ed..0000000000000000000000000000000000000000
--- a/test/cases/compile_errors/stage1/obj/division_by_zero.zig
+++ /dev/null
@@ -1,18 +0,0 @@
-const lit_int_x = 1 / 0;
-const lit_float_x = 1.0 / 0.0;
-const int_x = @as(u32, 1) / @as(u32, 0);
-const float_x = @as(f32, 1.0) / @as(f32, 0.0);
-
-export fn entry1() usize { return @sizeOf(@TypeOf(lit_int_x)); }
-export fn entry2() usize { return @sizeOf(@TypeOf(lit_float_x)); }
-export fn entry3() usize { return @sizeOf(@TypeOf(int_x)); }
-export fn entry4() usize { return @sizeOf(@TypeOf(float_x)); }
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:1:21: error: division by zero
-// tmp.zig:2:25: error: division by zero
-// tmp.zig:3:27: error: division by zero
-// tmp.zig:4:31: error: division by zero
diff --git a/test/cases/compile_errors/stage1/obj/duplicate_enum_field.zig b/test/cases/compile_errors/stage1/obj/duplicate_enum_field.zig
deleted file mode 100644
index cd024270bd10f18aefd50c91527404b236c7a45f..0000000000000000000000000000000000000000
--- a/test/cases/compile_errors/stage1/obj/duplicate_enum_field.zig
+++ /dev/null
@@ -1,16 +0,0 @@
-const Foo = enum {
-    Bar,
-    Bar,
-};
-
-export fn entry() void {
-    const a: Foo = undefined;
-    _ = a;
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:3:5: error: duplicate enum field: 'Bar'
-// tmp.zig:2:5: note: other field here
diff --git a/test/cases/compile_errors/stage1/obj/duplicate_error_in_switch.zig b/test/cases/compile_errors/stage1/obj/duplicate_error_in_switch.zig
deleted file mode 100644
index 140a14ec81969d9d8eb5fb8d12cdce57c607fa09..0000000000000000000000000000000000000000
--- a/test/cases/compile_errors/stage1/obj/duplicate_error_in_switch.zig
+++ /dev/null
@@ -1,22 +0,0 @@
-export fn entry() void {
-    foo(452) catch |err| switch (err) {
-        error.Foo => {},
-        error.Bar => {},
-        error.Foo => {},
-        else => {},
-    };
-}
-fn foo(x: i32) !void {
-    switch (x) {
-        0 ... 10 => return error.Foo,
-        11 ... 20 => return error.Bar,
-        else => {},
-    }
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:5:14: error: duplicate switch value: '@typeInfo(@typeInfo(@TypeOf(foo)).Fn.return_type.?).ErrorUnion.error_set.Foo'
-// tmp.zig:3:14: note: other value here
diff --git a/test/cases/compile_errors/stage1/obj/error_equality_but_sets_have_no_common_members.zig b/test/cases/compile_errors/stage1/obj/error_equality_but_sets_have_no_common_members.zig
deleted file mode 100644
index d42169b5036f40ba0725358de24a370d58b85bc9..0000000000000000000000000000000000000000
--- a/test/cases/compile_errors/stage1/obj/error_equality_but_sets_have_no_common_members.zig
+++ /dev/null
@@ -1,16 +0,0 @@
-const Set1 = error{A, C};
-const Set2 = error{B, D};
-export fn entry() void {
-    foo(Set1.A);
-}
-fn foo(x: Set1) void {
-    if (x == Set2.B) {
-
-    }
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:7:11: error: error sets 'Set1' and 'Set2' have no common errors
diff --git a/test/cases/compile_errors/stage1/obj/error_not_handled_in_switch.zig b/test/cases/compile_errors/stage1/obj/error_not_handled_in_switch.zig
deleted file mode 100644
index 12ee35daef7d556a854562dc3afdec5bb17ab7d0..0000000000000000000000000000000000000000
--- a/test/cases/compile_errors/stage1/obj/error_not_handled_in_switch.zig
+++ /dev/null
@@ -1,20 +0,0 @@
-export fn entry() void {
-    foo(452) catch |err| switch (err) {
-        error.Foo => {},
-    };
-}
-fn foo(x: i32) !void {
-    switch (x) {
-        0 ... 10 => return error.Foo,
-        11 ... 20 => return error.Bar,
-        21 ... 30 => return error.Baz,
-        else => {},
-    }
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:2:26: error: error.Baz not handled in switch
-// tmp.zig:2:26: error: error.Bar not handled in switch
diff --git a/test/cases/compile_errors/stage1/obj/explicitly_casting_non_tag_type_to_enum.zig b/test/cases/compile_errors/stage1/obj/explicitly_casting_non_tag_type_to_enum.zig
deleted file mode 100644
index 1999fd70a7750f7fb0d51ae7b9476d6fe28d99c3..0000000000000000000000000000000000000000
--- a/test/cases/compile_errors/stage1/obj/explicitly_casting_non_tag_type_to_enum.zig
+++ /dev/null
@@ -1,18 +0,0 @@
-const Small = enum(u2) {
-    One,
-    Two,
-    Three,
-    Four,
-};
-
-export fn entry() void {
-    var y = @as(f32, 3);
-    var x = @intToEnum(Small, y);
-    _ = x;
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:10:31: error: expected integer type, found 'f32'
diff --git a/test/cases/compile_errors/stage1/obj/fieldParentPtr-comptime_field_ptr_not_based_on_struct.zig b/test/cases/compile_errors/stage1/obj/fieldParentPtr-comptime_field_ptr_not_based_on_struct.zig
deleted file mode 100644
index 9375f4639a020f37f1f1320d0978f131279303df..0000000000000000000000000000000000000000
--- a/test/cases/compile_errors/stage1/obj/fieldParentPtr-comptime_field_ptr_not_based_on_struct.zig
+++ /dev/null
@@ -1,17 +0,0 @@
-const Foo = struct {
-    a: i32,
-    b: i32,
-};
-const foo = Foo { .a = 1, .b = 2, };
-
-comptime {
-    const field_ptr = @intToPtr(*i32, 0x1234);
-    const another_foo_ptr = @fieldParentPtr(Foo, "b", field_ptr);
-    _ = another_foo_ptr;
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:9:55: error: pointer value not based on parent struct
diff --git a/test/cases/compile_errors/stage1/obj/fieldParentPtr-comptime_wrong_field_index.zig b/test/cases/compile_errors/stage1/obj/fieldParentPtr-comptime_wrong_field_index.zig
deleted file mode 100644
index c322543dc01886dc35b4f455ffce8fe92a8aed12..0000000000000000000000000000000000000000
--- a/test/cases/compile_errors/stage1/obj/fieldParentPtr-comptime_wrong_field_index.zig
+++ /dev/null
@@ -1,16 +0,0 @@
-const Foo = struct {
-    a: i32,
-    b: i32,
-};
-const foo = Foo { .a = 1, .b = 2, };
-
-comptime {
-    const another_foo_ptr = @fieldParentPtr(Foo, "b", &foo.a);
-    _ = another_foo_ptr;
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:8:29: error: field 'b' has index 1 but pointer value is index 0 of struct 'Foo'
diff --git a/test/cases/compile_errors/stage1/obj/fieldParentPtr-field_pointer_is_not_pointer.zig b/test/cases/compile_errors/stage1/obj/fieldParentPtr-field_pointer_is_not_pointer.zig
deleted file mode 100644
index 71360e56810662e40958a553e4f180c82248db8c..0000000000000000000000000000000000000000
--- a/test/cases/compile_errors/stage1/obj/fieldParentPtr-field_pointer_is_not_pointer.zig
+++ /dev/null
@@ -1,12 +0,0 @@
-const Foo = extern struct {
-    a: i32,
-};
-export fn foo(a: i32) *Foo {
-    return @fieldParentPtr(Foo, "a", a);
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:5:38: error: expected pointer, found 'i32'
diff --git a/test/cases/compile_errors/stage1/obj/field_access_of_opaque_type.zig b/test/cases/compile_errors/stage1/obj/field_access_of_opaque_type.zig
deleted file mode 100644
index 963c89dafe79b6ac6b7c0d63c11f30dd458725a2..0000000000000000000000000000000000000000
--- a/test/cases/compile_errors/stage1/obj/field_access_of_opaque_type.zig
+++ /dev/null
@@ -1,16 +0,0 @@
-const MyType = opaque {};
-
-export fn entry() bool {
-    var x: i32 = 1;
-    return bar(@ptrCast(*MyType, &x));
-}
-
-fn bar(x: *MyType) bool {
-    return x.blah;
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:9:13: error: no member named 'blah' in opaque type 'MyType'
diff --git a/test/cases/compile_errors/stage1/obj/field_access_of_slices.zig b/test/cases/compile_errors/stage1/obj/field_access_of_slices.zig
deleted file mode 100644
index 45ca7113674e923e0c53ea970f518ac96e8cd8ba..0000000000000000000000000000000000000000
--- a/test/cases/compile_errors/stage1/obj/field_access_of_slices.zig
+++ /dev/null
@@ -1,11 +0,0 @@
-export fn entry() void {
-    var slice: []i32 = undefined;
-    const info = @TypeOf(slice).unknown;
-    _ = info;
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:3:32: error: type 'type' does not support field access
diff --git a/test/cases/compile_errors/stage1/obj/field_access_of_unknown_length_pointer.zig b/test/cases/compile_errors/stage1/obj/field_access_of_unknown_length_pointer.zig
deleted file mode 100644
index f9a37cabccbe99a588faf9f1e1237eb46322dcd8..0000000000000000000000000000000000000000
--- a/test/cases/compile_errors/stage1/obj/field_access_of_unknown_length_pointer.zig
+++ /dev/null
@@ -1,13 +0,0 @@
-const Foo = extern struct {
-    a: i32,
-};
-
-export fn entry(foo: [*]Foo) void {
-    foo.a += 1;
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:6:8: error: type '[*]Foo' does not support field access
diff --git a/test/cases/compile_errors/stage1/obj/ignored_deferred_function_call.zig b/test/cases/compile_errors/stage1/obj/ignored_deferred_function_call.zig
deleted file mode 100644
index 41812bfda93ba61d3fbfb34415b96463ceba6d59..0000000000000000000000000000000000000000
--- a/test/cases/compile_errors/stage1/obj/ignored_deferred_function_call.zig
+++ /dev/null
@@ -1,10 +0,0 @@
-export fn foo() void {
-    defer bar();
-}
-fn bar() anyerror!i32 { return 0; }
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:2:14: error: error is ignored. consider using `try`, `catch`, or `if`
diff --git a/test/cases/compile_errors/stage1/obj/ignored_expression_in_while_continuation.zig b/test/cases/compile_errors/stage1/obj/ignored_expression_in_while_continuation.zig
deleted file mode 100644
index 43f3713fc670e731c73a6a7b89e923c59e757038..0000000000000000000000000000000000000000
--- a/test/cases/compile_errors/stage1/obj/ignored_expression_in_while_continuation.zig
+++ /dev/null
@@ -1,22 +0,0 @@
-export fn a() void {
-    while (true) : (bad()) {}
-}
-export fn b() void {
-    var x: anyerror!i32 = 1234;
-    while (x) |_| : (bad()) {} else |_| {}
-}
-export fn c() void {
-    var x: ?i32 = 1234;
-    while (x) |_| : (bad()) {}
-}
-fn bad() anyerror!void {
-    return error.Bad;
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:2:24: error: error is ignored. consider using `try`, `catch`, or `if`
-// tmp.zig:6:25: error: error is ignored. consider using `try`, `catch`, or `if`
-// tmp.zig:10:25: error: error is ignored. consider using `try`, `catch`, or `if`
diff --git a/test/cases/compile_errors/stage1/obj/illegal_comparison_of_types.zig b/test/cases/compile_errors/stage1/obj/illegal_comparison_of_types.zig
deleted file mode 100644
index d04eaec3b52c0f4c53864a3c80e63edc5c440579..0000000000000000000000000000000000000000
--- a/test/cases/compile_errors/stage1/obj/illegal_comparison_of_types.zig
+++ /dev/null
@@ -1,20 +0,0 @@
-fn bad_eql_1(a: []u8, b: []u8) bool {
-    return a == b;
-}
-const EnumWithData = union(enum) {
-    One: void,
-    Two: i32,
-};
-fn bad_eql_2(a: *const EnumWithData, b: *const EnumWithData) bool {
-    return a.* == b.*;
-}
-
-export fn entry1() usize { return @sizeOf(@TypeOf(bad_eql_1)); }
-export fn entry2() usize { return @sizeOf(@TypeOf(bad_eql_2)); }
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:2:14: error: operator not allowed for type '[]u8'
-// tmp.zig:9:16: error: operator not allowed for type 'EnumWithData'
diff --git a/test/cases/compile_errors/stage1/obj/implicit_cast_from_f64_to_f32.zig b/test/cases/compile_errors/stage1/obj/implicit_cast_from_f64_to_f32.zig
deleted file mode 100644
index f18a46b7f51c2be13c0792ee3ff5dda84700da0f..0000000000000000000000000000000000000000
--- a/test/cases/compile_errors/stage1/obj/implicit_cast_from_f64_to_f32.zig
+++ /dev/null
@@ -1,10 +0,0 @@
-var x: f64 = 1.0;
-var y: f32 = x;
-
-export fn entry() usize { return @sizeOf(@TypeOf(y)); }
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:2:14: error: expected type 'f32', found 'f64'
diff --git a/test/cases/compile_errors/stage1/obj/implicitly_casting_enum_to_tag_type.zig b/test/cases/compile_errors/stage1/obj/implicitly_casting_enum_to_tag_type.zig
deleted file mode 100644
index a40615f99b09a5cd0a92372454c33244967c7e29..0000000000000000000000000000000000000000
--- a/test/cases/compile_errors/stage1/obj/implicitly_casting_enum_to_tag_type.zig
+++ /dev/null
@@ -1,17 +0,0 @@
-const Small = enum(u2) {
-    One,
-    Two,
-    Three,
-    Four,
-};
-
-export fn entry() void {
-    var x: u2 = Small.Two;
-    _ = x;
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:9:22: error: expected type 'u2', found 'Small'
diff --git a/test/cases/compile_errors/stage1/obj/incorrect_return_type.zig b/test/cases/compile_errors/stage1/obj/incorrect_return_type.zig
deleted file mode 100644
index b25e2a8ea46a8cfd0768cd782cd047f93d442c02..0000000000000000000000000000000000000000
--- a/test/cases/compile_errors/stage1/obj/incorrect_return_type.zig
+++ /dev/null
@@ -1,21 +0,0 @@
- pub export fn entry() void{
-     _ = foo();
- }
- const A = struct {
-     a: u32,
- };
- fn foo() A {
-     return bar();
- }
- const B = struct {
-     a: u32,
- };
- fn bar() B {
-     unreachable;
- }
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:8:16: error: expected type 'A', found 'B'
diff --git a/test/cases/compile_errors/stage1/obj/indexing_an_array_of_size_zero.zig b/test/cases/compile_errors/stage1/obj/indexing_an_array_of_size_zero.zig
deleted file mode 100644
index dfb2e7c1c314a1202f7f3348218b3b0064ed27d6..0000000000000000000000000000000000000000
--- a/test/cases/compile_errors/stage1/obj/indexing_an_array_of_size_zero.zig
+++ /dev/null
@@ -1,11 +0,0 @@
-const array = [_]u8{};
-export fn foo() void {
-    const pointer = &array[0];
-    _ = pointer;
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:3:27: error: accessing a zero length array is not allowed
diff --git a/test/cases/compile_errors/stage1/obj/indexing_an_array_of_size_zero_with_runtime_index.zig b/test/cases/compile_errors/stage1/obj/indexing_an_array_of_size_zero_with_runtime_index.zig
deleted file mode 100644
index f50931312e6e50e0f1dfe40463f2fe6b53c6bab1..0000000000000000000000000000000000000000
--- a/test/cases/compile_errors/stage1/obj/indexing_an_array_of_size_zero_with_runtime_index.zig
+++ /dev/null
@@ -1,12 +0,0 @@
-const array = [_]u8{};
-export fn foo() void {
-    var index: usize = 0;
-    const pointer = &array[index];
-    _ = pointer;
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:4:27: error: accessing a zero length array is not allowed
diff --git a/test/cases/compile_errors/stage1/obj/indexing_single-item_pointer.zig b/test/cases/compile_errors/stage1/obj/indexing_single-item_pointer.zig
deleted file mode 100644
index bc7951ec963c0076ca7fdb19816ce4c72ff28368..0000000000000000000000000000000000000000
--- a/test/cases/compile_errors/stage1/obj/indexing_single-item_pointer.zig
+++ /dev/null
@@ -1,9 +0,0 @@
-export fn entry(ptr: *i32) i32 {
-    return ptr[1];
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:2:15: error: index of single-item pointer
diff --git a/test/cases/compile_errors/stage1/obj/int_to_ptr_of_0_bits.zig b/test/cases/compile_errors/stage1/obj/int_to_ptr_of_0_bits.zig
deleted file mode 100644
index 7b65cdf836eb711121f72c81f20697d8d4dc413c..0000000000000000000000000000000000000000
--- a/test/cases/compile_errors/stage1/obj/int_to_ptr_of_0_bits.zig
+++ /dev/null
@@ -1,11 +0,0 @@
-export fn foo() void {
-    var x: usize = 0x1000;
-    var y: *void = @intToPtr(*void, x);
-    _ = y;
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:3:30: error: type '*void' has 0 bits and cannot store information
diff --git a/test/cases/compile_errors/stage1/obj/invalid_cast_from_integral_type_to_enum.zig b/test/cases/compile_errors/stage1/obj/invalid_cast_from_integral_type_to_enum.zig
deleted file mode 100644
index 81dbd88e3b1b24a2a4019cb4bf9b90a879f50916..0000000000000000000000000000000000000000
--- a/test/cases/compile_errors/stage1/obj/invalid_cast_from_integral_type_to_enum.zig
+++ /dev/null
@@ -1,17 +0,0 @@
-const E = enum(usize) { One, Two };
-
-export fn entry() void {
-    foo(1);
-}
-
-fn foo(x: usize) void {
-    switch (x) {
-        E.One => {},
-    }
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:9:10: error: expected type 'usize', found 'E'
diff --git a/test/cases/compile_errors/stage1/obj/invalid_deref_on_switch_target.zig b/test/cases/compile_errors/stage1/obj/invalid_deref_on_switch_target.zig
deleted file mode 100644
index 966a881543304a501d5a9f5b0db62d93e9caa65d..0000000000000000000000000000000000000000
--- a/test/cases/compile_errors/stage1/obj/invalid_deref_on_switch_target.zig
+++ /dev/null
@@ -1,17 +0,0 @@
-comptime {
-    var tile = Tile.Empty;
-    switch (tile.*) {
-        Tile.Empty => {},
-        Tile.Filled => {},
-    }
-}
-const Tile = enum {
-    Empty,
-    Filled,
-};
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:3:17: error: attempt to dereference non-pointer type 'Tile'
diff --git a/test/cases/compile_errors/stage1/obj/invalid_multiple_dereferences.zig b/test/cases/compile_errors/stage1/obj/invalid_multiple_dereferences.zig
deleted file mode 100644
index f8a0b8013f0ccbaa8e1519cf013932b0ce607a18..0000000000000000000000000000000000000000
--- a/test/cases/compile_errors/stage1/obj/invalid_multiple_dereferences.zig
+++ /dev/null
@@ -1,19 +0,0 @@
-export fn a() void {
-    var box = Box{ .field = 0 };
-    box.*.field = 1;
-}
-export fn b() void {
-    var box = Box{ .field = 0 };
-    var boxPtr = &box;
-    boxPtr.*.*.field = 1;
-}
-pub const Box = struct {
-    field: i32,
-};
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:3:8: error: attempt to dereference non-pointer type 'Box'
-// tmp.zig:8:13: error: attempt to dereference non-pointer type 'Box'
diff --git a/test/cases/compile_errors/stage1/obj/take_slice_of_invalid_dereference.zig b/test/cases/compile_errors/stage1/obj/take_slice_of_invalid_dereference.zig
deleted file mode 100644
index c039be373778354fee485a624a66d1e34aade8c6..0000000000000000000000000000000000000000
--- a/test/cases/compile_errors/stage1/obj/take_slice_of_invalid_dereference.zig
+++ /dev/null
@@ -1,10 +0,0 @@
-export fn entry() void {
-    const x = 'a'.*[0..];
-    _ = x;
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:2:18: error: attempt to dereference non-pointer type 'comptime_int'
diff --git a/test/cases/compile_errors/take_slice_of_invalid_dereference.zig b/test/cases/compile_errors/take_slice_of_invalid_dereference.zig
new file mode 100644
index 0000000000000000000000000000000000000000..35c1b2de0da4822b4ac2111251aab21cdf4bd256
--- /dev/null
+++ b/test/cases/compile_errors/take_slice_of_invalid_dereference.zig
@@ -0,0 +1,10 @@
+export fn entry() void {
+    const x = 'a'.*[0..];
+    _ = x;
+}
+
+// error
+// backend=stage2
+// target=native
+//
+// :2:18: error: cannot dereference non-pointer type 'comptime_int'
diff --git a/test/stage2/cbe.zig b/test/stage2/cbe.zig
index f602c498850b2b330152ca9279a66b7c6b5eadbf..4817f0502fa8b43aead06f8ff630a9e32bce7c74 100644
--- a/test/stage2/cbe.zig
+++ b/test/stage2/cbe.zig
@@ -729,8 +729,8 @@ pub fn addCases(ctx: *TestContext) !void {
             \\    _ = E1.a;
             \\}
         , &.{
-            ":1:28: error: duplicate enum tag",
-            ":1:22: note: other tag here",
+            ":1:28: error: duplicate enum field 'b'",
+            ":1:22: note: other field here",
         });
 
         case.addError(