Communicate the error name when a test fails

lib/compiler/test_runner.zig

@@ -135,16 +135,19 @@ fn mainServer() !void {
                 var fail = false;
                 var skip = false;
                 is_fuzz_test = false;
+                var err_name: ?[]const u8 = null;
                 test_fn.func() catch |err| switch (err) {
                     error.SkipZigTest => skip = true,
                     else => {
+                        err_name = @errorName(err);
                         fail = true;
                         if (@errorReturnTrace()) |trace| {
                             std.debug.dumpStackTrace(trace);
                         }
                     },
                 };
                 const leak = testing.allocator_instance.deinit() == .leak;
+                const err_name_slice = err_name orelse "";
                 try server.serveTestResults(.{
                     .index = index,
                     .flags = .{
@@ -156,8 +159,12 @@ fn mainServer() !void {
                             @FieldType(std.zig.Server.Message.TestResults.Flags, "log_err_count"),
                             log_err_count,
                         ),
+                        .err_name_len = std.math.lossyCast(
+                            @FieldType(std.zig.Server.Message.TestResults.Flags, "err_name_len"),
+                            err_name_slice.len,
+                        ),
                     },
-                });
+                }, err_name_slice);
             },
             .start_fuzzing => {
                 // This ensures that this code won't be analyzed and hence reference fuzzer symbols

lib/std/Build/Step/Run.zig

@@ -1768,18 +1768,26 @@ fn evalZigTest(
                     const stderr_contents = stderr.buffered();
                     stderr.toss(stderr_contents.len);
                     const msg = std.mem.trim(u8, stderr_contents, "\n");
-                    const label = if (tr_hdr.flags.fail)
-                        "failed"
-                    else if (tr_hdr.flags.leak)
-                        "leaked"
-                    else if (tr_hdr.flags.log_err_count > 0)
-                        "logged errors"
-                    else
-                        unreachable;
-                    if (msg.len > 0) {
-                        try run.step.addError("'{s}' {s}: {s}", .{ name, label, msg });
-                    } else {
-                        try run.step.addError("'{s}' {s}", .{ name, label });
+                    if (tr_hdr.flags.fail) {
+                        const err_name = body[@sizeOf(TrHdr)..][0..tr_hdr.flags.err_name_len];
+                        if (msg.len > 0) {
+                            try run.step.addError("'{s}' failed with error {s}: {s}", .{name, err_name, msg});
+                        } else {
+                            try run.step.addError("'{s}' failed with error {s}", .{name, err_name});
+                        }
+                    }
+                    else {
+                        const label = if (tr_hdr.flags.leak)
+                            "leaked"
+                        else if (tr_hdr.flags.log_err_count > 0)
+                            "logged errors"
+                        else
+                            unreachable;
+                        if (msg.len > 0) {
+                            try run.step.addError("'{s}' {s}: {s}", .{ name, label, msg });
+                        } else {
+                            try run.step.addError("'{s}' {s}", .{ name, label });
+                        }
                     }
                 }
 

lib/std/zig/Server.zig

@@ -97,7 +97,8 @@ pub const Message = struct {
             skip: bool,
             leak: bool,
             fuzz: bool,
-            log_err_count: u28 = 0,
+            log_err_count: u16 = 0,
+            err_name_len: u12 = 0,
         };
     };
 
@@ -205,12 +206,13 @@ pub fn serveEmitDigest(
     try s.out.flush();
 }
 
-pub fn serveTestResults(s: *Server, msg: OutMessage.TestResults) !void {
+pub fn serveTestResults(s: *Server, msg: OutMessage.TestResults, err_name: []const u8) !void {
     try s.serveMessageHeader(.{
         .tag = .test_results,
-        .bytes_len = @intCast(@sizeOf(OutMessage.TestResults)),
+        .bytes_len = @intCast(@sizeOf(OutMessage.TestResults) + err_name.len),
     });
     try s.out.writeStruct(msg, .little);
+    try s.out.writeAll(err_name);
     try s.out.flush();
 }