diff --git a/lib/std/zig/AstGen.zig b/lib/std/zig/AstGen.zig
index bb3cda94038be396c53bde1984d8449a7544ee38..5b32f23f278cdb5f6ecc4a30c390208db62497a4 100644
--- a/lib/std/zig/AstGen.zig
+++ b/lib/std/zig/AstGen.zig
@@ -4929,6 +4929,8 @@ fn structDeclInner(
 
     // Before any field bodies comes the backing int type, if specified.
     const backing_int_type_body_len: ?u32 = if (maybe_backing_int_node.unwrap()) |backing_int_node| len: {
+        block_scope.src_baseline = backing_int_node;
+        defer block_scope.src_baseline = node;
         if (layout != .@"packed") return astgen.failNode(
             backing_int_node,
             "non-packed struct does not support backing integer type",
@@ -5224,6 +5226,8 @@ fn unionDeclInner(
 
     // Before any field bodies comes the tag/backing type, if specified.
     const arg_type_body_len: ?u32 = if (opt_arg_node.unwrap()) |arg_node| len: {
+        block_scope.src_baseline = arg_node;
+        defer block_scope.src_baseline = node;
         astgen.src_hasher.update(astgen.tree.getNodeSource(arg_node));
         const type_ref = try typeExpr(&block_scope, &namespace.base, arg_node);
         if (!block_scope.endsWithNoReturn()) {
@@ -5444,6 +5448,8 @@ fn containerDecl(
 
             // Before any field bodies comes the tag type, if specified.
             const tag_type_body_len: ?u32 = if (container_decl.ast.arg.unwrap()) |tag_type_node| len: {
+                block_scope.src_baseline = tag_type_node;
+                defer block_scope.src_baseline = node;
                 astgen.src_hasher.update(astgen.tree.getNodeSource(tag_type_node));
                 const type_ref = try typeExpr(&block_scope, &namespace.base, tag_type_node);
                 if (!block_scope.endsWithNoReturn()) {
diff --git a/src/print_zir.zig b/src/print_zir.zig
index cc72fa62987cc150ff30ed73e0beaf695540eabf..427acc16ebbbbb30109b57ca7f2170330183ba97 100644
--- a/src/print_zir.zig
+++ b/src/print_zir.zig
@@ -1462,7 +1462,7 @@ const Writer = struct {
         if (struct_decl.backing_int_type_body) |backing_int_type_body| {
             assert(struct_decl.layout == .@"packed");
             try stream.writeAll("packed(");
-            try self.writeBracedDecl(stream, backing_int_type_body);
+            try self.writeBracedDeclWithBaseline(stream, backing_int_type_body, struct_decl.arg_baseline_src_node);
             try stream.writeAll("), ");
         } else {
             try stream.print("{s}, ", .{@tagName(struct_decl.layout)});
@@ -1487,15 +1487,15 @@ const Writer = struct {
                 try stream.print("{f}: ", .{std.zig.fmtIdP(field_name)});
 
                 self.indent += 2;
-                try self.writeBracedDecl(stream, field.type_body);
+                try self.writeBracedDeclWithBaseline(stream, field.type_body, struct_decl.fields_baseline_src_node);
                 if (field.align_body) |body| {
                     try stream.writeAll(" align(");
-                    try self.writeBracedDecl(stream, body);
+                    try self.writeBracedDeclWithBaseline(stream, body, struct_decl.fields_baseline_src_node);
                     try stream.writeByte(')');
                 }
                 if (field.default_body) |body| {
                     try stream.writeAll(" = ");
-                    try self.writeBracedDecl(stream, body);
+                    try self.writeBracedDeclWithBaseline(stream, body, struct_decl.fields_baseline_src_node);
                 }
                 self.indent -= 2;
 
@@ -1529,18 +1529,18 @@ const Writer = struct {
             .@"packed" => try stream.writeAll("packed, "),
             .packed_explicit => {
                 try stream.writeAll("packed(");
-                try self.writeBracedDecl(stream, union_decl.arg_type_body.?);
+                try self.writeBracedDeclWithBaseline(stream, union_decl.arg_type_body.?, union_decl.arg_baseline_src_node);
                 try stream.writeAll("), ");
             },
             .tagged_explicit => {
                 try stream.writeAll("tagged(");
-                try self.writeBracedDecl(stream, union_decl.arg_type_body.?);
+                try self.writeBracedDeclWithBaseline(stream, union_decl.arg_type_body.?, union_decl.arg_baseline_src_node);
                 try stream.writeAll("), ");
             },
             .tagged_enum => try stream.writeAll("tagged(enum), "),
             .tagged_enum_explicit => {
                 try stream.writeAll("tagged(enum(");
-                try self.writeBracedDecl(stream, union_decl.arg_type_body.?);
+                try self.writeBracedDeclWithBaseline(stream, union_decl.arg_type_body.?, union_decl.arg_baseline_src_node);
                 try stream.writeAll(")), ");
             },
         }
@@ -1565,16 +1565,16 @@ const Writer = struct {
                 self.indent += 2;
                 if (field.type_body) |body| {
                     try stream.writeAll(": ");
-                    try self.writeBracedDecl(stream, body);
+                    try self.writeBracedDeclWithBaseline(stream, body, union_decl.fields_baseline_src_node);
                 }
                 if (field.align_body) |body| {
                     try stream.writeAll(" align(");
-                    try self.writeBracedDecl(stream, body);
+                    try self.writeBracedDeclWithBaseline(stream, body, union_decl.fields_baseline_src_node);
                     try stream.writeByte(')');
                 }
                 if (field.value_body) |body| {
                     try stream.writeAll(" = ");
-                    try self.writeBracedDecl(stream, body);
+                    try self.writeBracedDeclWithBaseline(stream, body, union_decl.fields_baseline_src_node);
                 }
                 self.indent -= 2;
 
@@ -1603,7 +1603,7 @@ const Writer = struct {
         try self.writeFlag(stream, "nonexhaustive, ", enum_decl.nonexhaustive);
         if (enum_decl.tag_type_body) |tag_type_body| {
             try stream.writeAll("tag(");
-            try self.writeBracedDecl(stream, tag_type_body);
+            try self.writeBracedDeclWithBaseline(stream, tag_type_body, enum_decl.arg_baseline_src_node);
             try stream.writeAll("), ");
         }
 
@@ -1625,7 +1625,7 @@ const Writer = struct {
                 try stream.print("{f}", .{std.zig.fmtIdP(field_name)});
                 if (field.value_body) |body| {
                     try stream.writeAll(" = ");
-                    try self.writeBracedDecl(stream, body);
+                    try self.writeBracedDeclWithBaseline(stream, body, enum_decl.fields_baseline_src_node);
                 }
                 try stream.writeAll(",\n");
             }
@@ -2409,6 +2409,18 @@ const Writer = struct {
         try self.writeBracedBodyConditional(stream, body, self.recurse_decls);
     }
 
+    fn writeBracedDeclWithBaseline(
+        self: *Writer,
+        stream: *std.Io.Writer,
+        body: []const Zir.Inst.Index,
+        src_baseline: Ast.Node.Index,
+    ) !void {
+        const prev_parent_decl_node = self.parent_decl_node;
+        self.parent_decl_node = src_baseline;
+        defer self.parent_decl_node = prev_parent_decl_node;
+        try self.writeBracedDecl(stream, body);
+    }
+
     fn writeBracedBody(self: *Writer, stream: *std.Io.Writer, body: []const Zir.Inst.Index) !void {
         try self.writeBracedBodyConditional(stream, body, self.recurse_blocks);
     }
diff --git a/test/cases/compile_errors/compile_error_in_backing_tag.zig b/test/cases/compile_errors/compile_error_in_backing_tag.zig
new file mode 100644
index 0000000000000000000000000000000000000000..1ff9a2f0dbce5822382faa9b585dbdd444e83113
--- /dev/null
+++ b/test/cases/compile_errors/compile_error_in_backing_tag.zig
@@ -0,0 +1,29 @@
+const E = enum(@compileError("enum")) {
+    x = 0,
+};
+
+const U = union(enum(@compileError("union"))) {
+    x = 0,
+};
+
+const S = packed struct(@compileError("struct")) {
+    x: u8 = 0,
+};
+
+comptime {
+    _ = &E.x;
+}
+
+comptime {
+    _ = &U.x;
+}
+
+comptime {
+    _ = &S{};
+}
+
+// error
+//
+// :1:16: error: enum
+// :5:22: error: union
+// :9:25: error: struct