Sema: allow empty unions

Author: Vexu

src/AstGen.zig

@@ -4557,8 +4557,8 @@ fn unionDeclInner(
             wip_members.appendToField(@enumToInt(tag_value));
         }
     }
-    if (field_count == 0) {
-        return astgen.failNode(node, "union declarations must have at least one tag", .{});
+    if (field_count == 0 and (auto_enum_tok != null or arg_node != 0)) {
+        return astgen.failNode(node, "tagged union declarations must have at least one tag", .{});
     }
 
     if (!block_scope.isEmpty()) {

src/Sema.zig

@@ -16891,8 +16891,8 @@ fn zirReify(sema: *Sema, block: *Block, extended: Zir.Inst.Extended.InstData, in
                         .abi_align = @intCast(u32, alignment_val.toUnsignedInt(target)),
                     };
                 }
-            } else {
-                return sema.fail(block, src, "unions must have at least one field", .{});
+            } else if (!tag_type_val.isNull()) {
+                return sema.fail(block, src, "tagged unions must have at least one field", .{});
             }
 
             if (tag_ty_field_names) |names| {
@@ -28722,7 +28722,9 @@ pub fn typeHasOnePossibleValue(
             const union_obj = resolved_ty.cast(Type.Payload.Union).?.data;
             const tag_val = (try sema.typeHasOnePossibleValue(block, src, union_obj.tag_ty)) orelse
                 return null;
-            const only_field = union_obj.fields.values()[0];
+            const fields = union_obj.fields.values();
+            if (fields.len == 0) return Value.initTag(.empty_struct_value);
+            const only_field = fields[0];
             if (only_field.ty.eql(resolved_ty, sema.mod)) {
                 const msg = try Module.ErrorMsg.create(
                     sema.gpa,
@@ -29462,7 +29464,7 @@ fn unionFieldAlignment(
     field: Module.Union.Field,
 ) !u32 {
     if (field.ty.zigTypeTag() == .NoReturn) {
-        return 0;
+        return @as(u32, 0);
     } else if (field.abi_align == 0) {
         return sema.typeAbiAlignment(block, src, field.ty);
     } else {

src/print_zir.zig

@@ -1443,7 +1443,7 @@ const Writer = struct {
         try self.writeFlag(stream, "autoenum, ", small.auto_enum_tag);
 
         if (decls_len == 0) {
-            try stream.writeAll("{}, ");
+            try stream.writeAll("{}");
         } else {
             const prev_parent_decl_node = self.parent_decl_node;
             if (src_node) |off| self.parent_decl_node = self.relativeToNodeIndex(off);
@@ -1454,15 +1454,20 @@ const Writer = struct {
             extra_index = try self.writeDecls(stream, decls_len, extra_index);
             self.indent -= 2;
             try stream.writeByteNTimes(' ', self.indent);
-            try stream.writeAll("}, ");
+            try stream.writeAll("}");
         }
 
-        assert(fields_len != 0);
-
         if (tag_type_ref != .none) {
-            try self.writeInstRef(stream, tag_type_ref);
             try stream.writeAll(", ");
+            try self.writeInstRef(stream, tag_type_ref);
+        }
+
+        if (fields_len == 0) {
+            try stream.writeAll("})");
+            try self.writeSrcNode(stream, src_node);
+            return;
         }
+        try stream.writeAll(", ");
 
         const body = self.code.extra[extra_index..][0..body_len];
         extra_index += body.len;

src/type.zig

@@ -3096,6 +3096,9 @@ pub const Type = extern union {
         union_obj: *Module.Union,
         have_tag: bool,
     ) Module.CompileError!AbiAlignmentAdvanced {
+        if (union_obj.fields.count() == 0) {
+            return AbiAlignmentAdvanced{ .scalar = @boolToInt(union_obj.layout == .Extern) };
+        }
         const sema_kit = switch (strat) {
             .sema_kit => |sk| sk,
             else => null,

test/behavior/union.zig

@@ -1301,3 +1301,19 @@ test "noreturn field in union" {
     }
     try expect(count == 5);
 }
+
+test "empty union" {
+    if (builtin.zig_backend == .stage1) return error.SkipZigTest;
+
+    const U = union {};
+    try expect(@sizeOf(U) == 0);
+    try expect(@alignOf(U) == 0);
+}
+
+test "empty extern union" {
+    if (builtin.zig_backend == .stage1) return error.SkipZigTest;
+
+    const U = extern union {};
+    try expect(@sizeOf(U) == 0);
+    try expect(@alignOf(U) == 1);
+}

test/cases/compile_errors/reify_type_for_union_with_zero_fields.zig

@@ -1,7 +1,7 @@
 const Untagged = @Type(.{
     .Union = .{
         .layout = .Auto,
-        .tag_type = null,
+        .tag_type = enum { a, b },
         .fields = &.{},
         .decls = &.{},
     },
@@ -14,4 +14,4 @@ export fn entry() void {
 // backend=stage2
 // target=native
 //
-// :1:18: error: unions must have at least one field
+// :1:18: error: tagged unions must have at least one field

test/cases/compile_errors/union_fields_with_value_assignments.zig

@@ -1,7 +1,7 @@
-const Foo = union {};
+const Foo = union(enum) {};
 
 // error
 // backend=stage2
 // target=native
 //
-// :1:13: error: union declarations must have at least one tag
+// :1:13: error: tagged union declarations must have at least one tag