Commit e47706f34454c46dd00fe10fdf9252657117a00d | zig

author	Veikka Tuominen <git@vexu.eu> 2022-07-28 21:03:10+03:00
committer	Veikka Tuominen <git@vexu.eu> 2022-08-01 23:59:40+03:00
log	e47706f34454c46dd00fe10fdf9252657117a00d
tree	ef7ab64fbe9d3123004b3fe94781bfcabc8325fa
parent	f1768b40b2468d63355c8cf83d3614ae23a54317

Sema: validate packed struct field types

6 files changed, 217 insertions(+), 133 deletions(-)

src
- Sema.zig
test
- behavior
- cases
  - compile_errors
    packed_struct_with_fields_of_not_allowed_types.zig
    stage1
    test
    packed_struct_with_fields_of_not_allowed_types.zig

src/Sema.zig+127-29

 @@ -5049,13 +5049,13 @@ pub fn analyzeExport(
     try mod.ensureDeclAnalyzed(exported_decl_index);
     const exported_decl = mod.declPtr(exported_decl_index);
-    if (!(try sema.validateExternType(exported_decl.ty, .other))) {
+    if (!sema.validateExternType(exported_decl.ty, .other)) {
         const msg = msg: {
             const msg = try sema.errMsg(block, src, "unable to export type '{}'", .{exported_decl.ty.fmt(sema.mod)});
             errdefer msg.destroy(sema.gpa);
             const src_decl = sema.mod.declPtr(block.src_decl);
-            try sema.explainWhyTypeIsNotExtern(block, src, msg, src.toSrcLoc(src_decl), exported_decl.ty, .other);
+            try sema.explainWhyTypeIsNotExtern(msg, src.toSrcLoc(src_decl), exported_decl.ty, .other);
             try sema.addDeclaredHereNote(msg, exported_decl.ty);
             break :msg msg;
 @@ -7634,7 +7634,7 @@ fn funcCommon(
             };
             return sema.failWithOwnedErrorMsg(block, msg);
         }
-        if (!Type.fnCallingConventionAllowsZigTypes(cc_workaround) and !(try sema.validateExternType(return_type, .ret_ty))) {
+        if (!Type.fnCallingConventionAllowsZigTypes(cc_workaround) and !sema.validateExternType(return_type, .ret_ty)) {
             const msg = msg: {
                 const msg = try sema.errMsg(block, ret_ty_src, "return type '{}' not allowed in function with calling convention '{s}'", .{
                     return_type.fmt(sema.mod), @tagName(cc_workaround),
 @@ -7642,7 +7642,7 @@ fn funcCommon(
                 errdefer msg.destroy(sema.gpa);
                 const src_decl = sema.mod.declPtr(block.src_decl);
-                try sema.explainWhyTypeIsNotExtern(block, ret_ty_src, msg, ret_ty_src.toSrcLoc(src_decl), return_type, .ret_ty);
+                try sema.explainWhyTypeIsNotExtern(msg, ret_ty_src.toSrcLoc(src_decl), return_type, .ret_ty);
                 try sema.addDeclaredHereNote(msg, return_type);
                 break :msg msg;
 @@ -7830,7 +7830,7 @@ fn analyzeParameter(
         };
         return sema.failWithOwnedErrorMsg(block, msg);
     }
-    if (!Type.fnCallingConventionAllowsZigTypes(cc) and !(try sema.validateExternType(param.ty, .param_ty))) {
+    if (!Type.fnCallingConventionAllowsZigTypes(cc) and !sema.validateExternType(param.ty, .param_ty)) {
         const msg = msg: {
             const msg = try sema.errMsg(block, param_src, "parameter of type '{}' not allowed in function with calling convention '{s}'", .{
                 param.ty.fmt(sema.mod), @tagName(cc),
 @@ -7838,7 +7838,7 @@ fn analyzeParameter(
             errdefer msg.destroy(sema.gpa);
             const src_decl = sema.mod.declPtr(block.src_decl);
-            try sema.explainWhyTypeIsNotExtern(block, param_src, msg, param_src.toSrcLoc(src_decl), param.ty, .param_ty);
+            try sema.explainWhyTypeIsNotExtern(msg, param_src.toSrcLoc(src_decl), param.ty, .param_ty);
             try sema.addDeclaredHereNote(msg, param.ty);
             break :msg msg;
 @@ -14866,13 +14866,13 @@ fn zirPtrType(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air
     } else if (inst_data.size == .Many and elem_ty.zigTypeTag() == .Opaque) {
         return sema.fail(block, elem_ty_src, "unknown-length pointer to opaque not allowed", .{});
     } else if (inst_data.size == .C) {
-        if (!(try sema.validateExternType(elem_ty, .other))) {
+        if (!sema.validateExternType(elem_ty, .other)) {
             const msg = msg: {
                 const msg = try sema.errMsg(block, elem_ty_src, "C pointers cannot point to non-C-ABI-compatible type '{}'", .{elem_ty.fmt(sema.mod)});
                 errdefer msg.destroy(sema.gpa);
                 const src_decl = sema.mod.declPtr(block.src_decl);
-                try sema.explainWhyTypeIsNotExtern(block, elem_ty_src, msg, elem_ty_src.toSrcLoc(src_decl), elem_ty, .other);
+                try sema.explainWhyTypeIsNotExtern(msg, elem_ty_src.toSrcLoc(src_decl), elem_ty, .other);
                 try sema.addDeclaredHereNote(msg, elem_ty);
                 break :msg msg;
 @@ -15950,13 +15950,13 @@ fn zirReify(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.I
             } else if (ptr_size == .Many and elem_ty.zigTypeTag() == .Opaque) {
                 return sema.fail(block, src, "unknown-length pointer to opaque not allowed", .{});
             } else if (ptr_size == .C) {
-                if (!(try sema.validateExternType(elem_ty, .other))) {
+                if (!sema.validateExternType(elem_ty, .other)) {
                     const msg = msg: {
                         const msg = try sema.errMsg(block, src, "C pointers cannot point to non-C-ABI-compatible type '{}'", .{elem_ty.fmt(sema.mod)});
                         errdefer msg.destroy(sema.gpa);
                         const src_decl = sema.mod.declPtr(block.src_decl);
-                        try sema.explainWhyTypeIsNotExtern(block, src, msg, src.toSrcLoc(src_decl), elem_ty, .other);
+                        try sema.explainWhyTypeIsNotExtern(msg, src.toSrcLoc(src_decl), elem_ty, .other);
                         try sema.addDeclaredHereNote(msg, elem_ty);
                         break :msg msg;
 @@ -19736,7 +19736,7 @@ const ExternPosition = enum {
 /// Returns true if `ty` is allowed in extern types.
 /// Does *NOT* require `ty` to be resolved in any way.
-fn validateExternType(sema: *Sema, ty: Type, position: ExternPosition) CompileError!bool {
+fn validateExternType(sema: *Sema, ty: Type, position: ExternPosition) bool {
     switch (ty.zigTypeTag()) {
         .Type,
         .ComptimeFloat,
 @@ -19781,8 +19781,6 @@ fn validateExternType(sema: *Sema, ty: Type, position: ExternPosition) CompileEr
 fn explainWhyTypeIsNotExtern(
     sema: *Sema,
-    block: *Block,
-    src: LazySrcLoc,
     msg: *Module.ErrorMsg,
     src_loc: Module.SrcLoc,
     ty: Type,
 @@ -19826,7 +19824,7 @@ fn explainWhyTypeIsNotExtern(
             var buf: Type.Payload.Bits = undefined;
             const tag_ty = ty.intTagType(&buf);
             try mod.errNoteNonLazy(src_loc, msg, "enum tag type '{}' is not extern compatible", .{tag_ty.fmt(sema.mod)});
-            try sema.explainWhyTypeIsNotExtern(block, src, msg, src_loc, tag_ty, position);
+            try sema.explainWhyTypeIsNotExtern(msg, src_loc, tag_ty, position);
         },
         .Struct => try mod.errNoteNonLazy(src_loc, msg, "only structs with packed or extern layout are extern compatible", .{}),
         .Union => try mod.errNoteNonLazy(src_loc, msg, "only unions with packed or extern layout are extern compatible", .{}),
 @@ -19836,13 +19834,87 @@ fn explainWhyTypeIsNotExtern(
             } else if (position == .param_ty) {
                 return mod.errNoteNonLazy(src_loc, msg, "arrays are not allowed as a parameter type", .{});
             }
-            try sema.explainWhyTypeIsNotExtern(block, src, msg, src_loc, ty.elemType2(), position);
+            try sema.explainWhyTypeIsNotExtern(msg, src_loc, ty.elemType2(), position);
         },
-        .Vector => try sema.explainWhyTypeIsNotExtern(block, src, msg, src_loc, ty.elemType2(), position),
+        .Vector => try sema.explainWhyTypeIsNotExtern(msg, src_loc, ty.elemType2(), position),
         .Optional => try mod.errNoteNonLazy(src_loc, msg, "only pointer like optionals are extern compatible", .{}),
     }
 }
+/// Returns true if `ty` is allowed in packed types.
+/// Does *NOT* require `ty` to be resolved in any way.
+fn validatePackedType(ty: Type) bool {
+    switch (ty.zigTypeTag()) {
+        .Type,
+        .ComptimeFloat,
+        .ComptimeInt,
+        .EnumLiteral,
+        .Undefined,
+        .Null,
+        .ErrorUnion,
+        .ErrorSet,
+        .BoundFn,
+        .Frame,
+        .NoReturn,
+        .Opaque,
+        .AnyFrame,
+        .Fn,
+        .Array,
+        .Optional,
+        => return false,
+        .Void,
+        .Bool,
+        .Float,
+        .Pointer,
+        .Int,
+        .Vector,
+        .Enum,
+        => return true,
+        .Struct, .Union => return ty.containerLayout() == .Packed,
+    }
+}
+fn explainWhyTypeIsNotPacked(
+    sema: *Sema,
+    msg: *Module.ErrorMsg,
+    src_loc: Module.SrcLoc,
+    ty: Type,
+) CompileError!void {
+    const mod = sema.mod;
+    switch (ty.zigTypeTag()) {
+        .Void,
+        .Bool,
+        .Float,
+        .Pointer,
+        .Int,
+        .Vector,
+        .Enum,
+        => return,
+        .Type,
+        .ComptimeFloat,
+        .ComptimeInt,
+        .EnumLiteral,
+        .Undefined,
+        .Null,
+        .BoundFn,
+        .Frame,
+        .NoReturn,
+        .Opaque,
+        .ErrorUnion,
+        .ErrorSet,
+        .AnyFrame,
+        .Optional,
+        .Array,
+        => try mod.errNoteNonLazy(src_loc, msg, "type has no guaranteed in-memory representation", .{}),
+        .Fn => {
+            try mod.errNoteNonLazy(src_loc, msg, "type has no guaranteed in-memory representation", .{});
+            try mod.errNoteNonLazy(src_loc, msg, "use '*const ' to make a function pointer type", .{});
+        },
+        .Struct => try mod.errNoteNonLazy(src_loc, msg, "only packed structs layout are allowed in packed types", .{}),
+        .Union => try mod.errNoteNonLazy(src_loc, msg, "only packed unions layout are allowed in packed types", .{}),
+    }
+}
 pub const PanicId = enum {
     unreach,
     unwrap_null,
 @@ -26919,28 +26991,41 @@ fn semaStructFields(mod: *Module, struct_obj: *Module.Struct) CompileError!void
         const field = &struct_obj.fields.values()[i];
         field.ty = try field_ty.copy(decl_arena_allocator);
-        if (struct_obj.layout == .Extern and !(try sema.validateExternType(field.ty, .other))) {
+        if (field_ty.zigTypeTag() == .Opaque) {
+            const msg = msg: {
+                const tree = try sema.getAstTree(&block_scope);
+                const field_src = enumFieldSrcLoc(decl, tree.*, struct_obj.node_offset, i);
+                const msg = try sema.errMsg(&block_scope, field_src, "opaque types have unknown size and therefore cannot be directly embedded in structs", .{});
+                errdefer msg.destroy(sema.gpa);
+                try sema.addDeclaredHereNote(msg, field_ty);
+                break :msg msg;
+            };
+            return sema.failWithOwnedErrorMsg(&block_scope, msg);
+        }
+        if (struct_obj.layout == .Extern and !sema.validateExternType(field.ty, .other)) {
             const msg = msg: {
                 const tree = try sema.getAstTree(&block_scope);
                 const fields_src = enumFieldSrcLoc(decl, tree.*, struct_obj.node_offset, i);
                 const msg = try sema.errMsg(&block_scope, fields_src, "extern structs cannot contain fields of type '{}'", .{field.ty.fmt(sema.mod)});
                 errdefer msg.destroy(sema.gpa);
-                try sema.explainWhyTypeIsNotExtern(&block_scope, fields_src, msg, fields_src.toSrcLoc(decl), field.ty, .other);
+                try sema.explainWhyTypeIsNotExtern(msg, fields_src.toSrcLoc(decl), field.ty, .other);
                 try sema.addDeclaredHereNote(msg, field.ty);
                 break :msg msg;
             };
             return sema.failWithOwnedErrorMsg(&block_scope, msg);
-        }
+        } else if (struct_obj.layout == .Packed and !(validatePackedType(field.ty))) {
-        if (field_ty.zigTypeTag() == .Opaque) {
             const msg = msg: {
                 const tree = try sema.getAstTree(&block_scope);
-                const field_src = enumFieldSrcLoc(decl, tree.*, struct_obj.node_offset, i);
+                const fields_src = enumFieldSrcLoc(decl, tree.*, struct_obj.node_offset, i);
-                const msg = try sema.errMsg(&block_scope, field_src, "opaque types have unknown size and therefore cannot be directly embedded in structs", .{});
+                const msg = try sema.errMsg(&block_scope, fields_src, "packed structs cannot contain fields of type '{}'", .{field.ty.fmt(sema.mod)});
                 errdefer msg.destroy(sema.gpa);
-                try sema.addDeclaredHereNote(msg, field_ty);
+                try sema.explainWhyTypeIsNotPacked(msg, fields_src.toSrcLoc(decl), field.ty);
+                try sema.addDeclaredHereNote(msg, field.ty);
                 break :msg msg;
             };
             return sema.failWithOwnedErrorMsg(&block_scope, msg);
 @@ -27243,27 +27328,40 @@ fn semaUnionFields(mod: *Module, union_obj: *Module.Union) CompileError!void {
             }
         }
-        if (union_obj.layout == .Extern and !(try sema.validateExternType(field_ty, .union_field))) {
+        if (field_ty.zigTypeTag() == .Opaque) {
             const msg = msg: {
                 const tree = try sema.getAstTree(&block_scope);
                 const field_src = enumFieldSrcLoc(decl, tree.*, union_obj.node_offset, field_i);
-                const msg = try sema.errMsg(&block_scope, field_src, "extern unions cannot contain fields of type '{}'", .{field_ty.fmt(sema.mod)});
+                const msg = try sema.errMsg(&block_scope, field_src, "opaque types have unknown size and therefore cannot be directly embedded in unions", .{});
                 errdefer msg.destroy(sema.gpa);
-                try sema.explainWhyTypeIsNotExtern(&block_scope, field_src, msg, field_src.toSrcLoc(decl), field_ty, .union_field);
                 try sema.addDeclaredHereNote(msg, field_ty);
                 break :msg msg;
             };
             return sema.failWithOwnedErrorMsg(&block_scope, msg);
         }
-        if (field_ty.zigTypeTag() == .Opaque) {
+        if (union_obj.layout == .Extern and !sema.validateExternType(field_ty, .union_field)) {
             const msg = msg: {
                 const tree = try sema.getAstTree(&block_scope);
                 const field_src = enumFieldSrcLoc(decl, tree.*, union_obj.node_offset, field_i);
-                const msg = try sema.errMsg(&block_scope, field_src, "opaque types have unknown size and therefore cannot be directly embedded in unions", .{});
+                const msg = try sema.errMsg(&block_scope, field_src, "extern unions cannot contain fields of type '{}'", .{field_ty.fmt(sema.mod)});
                 errdefer msg.destroy(sema.gpa);
+                try sema.explainWhyTypeIsNotExtern(msg, field_src.toSrcLoc(decl), field_ty, .union_field);
+                try sema.addDeclaredHereNote(msg, field_ty);
+                break :msg msg;
+            };
+            return sema.failWithOwnedErrorMsg(&block_scope, msg);
+        } else if (union_obj.layout == .Packed and !(validatePackedType(field_ty))) {
+            const msg = msg: {
+                const tree = try sema.getAstTree(&block_scope);
+                const fields_src = enumFieldSrcLoc(decl, tree.*, union_obj.node_offset, field_i);
+                const msg = try sema.errMsg(&block_scope, fields_src, "packed unions cannot contain fields of type '{}'", .{field_ty.fmt(sema.mod)});
+                errdefer msg.destroy(sema.gpa);
+                try sema.explainWhyTypeIsNotPacked(msg, fields_src.toSrcLoc(decl), field_ty);
                 try sema.addDeclaredHereNote(msg, field_ty);
                 break :msg msg;
             };

test/behavior/packed-struct.zig+2-26

 @@ -6,6 +6,8 @@ const expectEqual = std.testing.expectEqual;
 const native_endian = builtin.cpu.arch.endian();
 test "correct size of packed structs" {
+    // Stage2 has different packed struct semantics.
+    if (builtin.zig_backend != .stage1) return error.SkipZigTest;
     const T1 = packed struct { one: u8, three: [3]u8 };
     try expectEqual(4, @sizeOf(T1));
 @@ -118,18 +120,6 @@ test "flags in packed structs" {
     try expectEqual(32, @bitSizeOf(Flags3));
 }
-test "arrays in packed structs" {
-    if (builtin.zig_backend == .stage1) return error.SkipZigTest;
-    const T1 = packed struct { array: [3][3]u8 };
-    const T2 = packed struct { array: [9]u8 };
-    try expectEqual(@sizeOf(u72), @sizeOf(T1));
-    try expectEqual(72, @bitSizeOf(T1));
-    try expectEqual(@sizeOf(u72), @sizeOf(T2));
-    try expectEqual(72, @bitSizeOf(T2));
-}
 test "consistent size of packed structs" {
     if (builtin.zig_backend == .stage1) return error.SkipZigTest;
 @@ -145,23 +135,15 @@ test "consistent size of packed structs" {
     try expectEqual(register_size_bits, @bitSizeOf(TxData2));
     try expectEqual(register_size_bytes, @sizeOf(TxData2));
-    const TxData3 = packed struct { a: u32, b: [3]u8 };
     const TxData4 = packed struct { a: u32, b: u24 };
-    const TxData5 = packed struct { a: [3]u8, b: u32 };
     const TxData6 = packed struct { a: u24, b: u32 };
     const expectedBitSize = 56;
     const expectedByteSize = @sizeOf(u56);
-    try expectEqual(expectedBitSize, @bitSizeOf(TxData3));
-    try expectEqual(expectedByteSize, @sizeOf(TxData3));
     try expectEqual(expectedBitSize, @bitSizeOf(TxData4));
     try expectEqual(expectedByteSize, @sizeOf(TxData4));
-    try expectEqual(expectedBitSize, @bitSizeOf(TxData5));
-    try expectEqual(expectedByteSize, @sizeOf(TxData5));
     try expectEqual(expectedBitSize, @bitSizeOf(TxData6));
     try expectEqual(expectedByteSize, @sizeOf(TxData6));
 }
 @@ -234,12 +216,6 @@ test "correct sizeOf and offsets in packed structs" {
         try expectEqual(@as(u7, 0b1111010), s2.y);
         try expectEqual(@as(u24, 0xd5c71f), s2.z);
     }
-    const S = packed struct { a: u32, pad: [3]u32, b: u32 };
-    try expectEqual(16, @offsetOf(S, "b"));
-    try expectEqual(128, @bitOffsetOf(S, "b"));
-    try expectEqual(@sizeOf(u160), @sizeOf(S));
 }
 test "nested packed structs" {

test/behavior/sizeof_and_typeof.zig+2

...	@@ -105,6 +105,8 @@ test "@offsetOf" {	...	@@ -105,6 +105,8 @@ test "@offsetOf" {
105	}	105	}
106		106
107	test "@offsetOf packed struct, array length not power of 2 or multiple of native pointer width in bytes" {	107	test "@offsetOf packed struct, array length not power of 2 or multiple of native pointer width in bytes" {
		108	// Stage2 has different packed struct semantics.
		109	if (builtin.zig_backend != .stage1) return error.SkipZigTest;
108	const p3a_len = 3;	110	const p3a_len = 3;
109	const P3 = packed struct {	111	const P3 = packed struct {
110	a: [p3a_len]u8,	112	a: [p3a_len]u8,

test/behavior/struct.zig+2-4

 @@ -704,10 +704,8 @@ const FooArray24Bits = packed struct {
 };
 test "aligned array of packed struct" {
-    if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
+    // Stage2 has different packed struct semantics.
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend != .stage1) return error.SkipZigTest;
-    if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
-    if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
     comptime {
         try expect(@sizeOf(FooStructAligned) == 2);

test/cases/compile_errors/packed_struct_with_fields_of_not_allowed_types.zig created+84

...	@@ -0,0 +1,84 @@
1	export fn entry1() void {
2	_ = @sizeOf(packed struct {
3	x: anyerror,
4	});
5	}
6	export fn entry2() void {
7	_ = @sizeOf(packed struct {
8	x: [2]u24,
9	});
10	}
11	export fn entry3() void {
12	_ = @sizeOf(packed struct {
13	x: anyerror!u32,
14	});
15	}
16	export fn entry4() void {
17	_ = @sizeOf(packed struct {
18	x: S,
19	});
20	}
21	export fn entry5() void {
22	_ = @sizeOf(packed struct {
23	x: U,
24	});
25	}
26	export fn entry6() void {
27	_ = @sizeOf(packed struct {
28	x: ?anyerror,
29	});
30	}
31	export fn entry7() void {
32	_ = @sizeOf(packed struct {
33	x: enum { A, B },
34	});
35	}
36	export fn entry8() void {
37	_ = @sizeOf(packed struct {
38	x: fn () void,
39	});
40	}
41	export fn entry9() void {
42	_ = @sizeOf(packed struct {
43	x: *const fn () void,
44	});
45	}
46	export fn entry10() void {
47	_ = @sizeOf(packed struct {
48	x: packed struct { x: i32 },
49	});
50	}
51	export fn entry11() void {
52	_ = @sizeOf(packed struct {
53	x: packed union { A: i32, B: u32 },
54	});
55	}
56	const S = struct {
57	x: i32,
58	};
59	const U = extern union {
60	A: i32,
61	B: u32,
62	};
63
64	// error
65	// backend=llvm
66	// target=native
67	//
68	// :3:9: error: packed structs cannot contain fields of type 'anyerror'
69	// :3:9: note: type has no guaranteed in-memory representation
70	// :8:9: error: packed structs cannot contain fields of type '[2]u24'
71	// :8:9: note: type has no guaranteed in-memory representation
72	// :13:9: error: packed structs cannot contain fields of type 'anyerror!u32'
73	// :13:9: note: type has no guaranteed in-memory representation
74	// :18:9: error: packed structs cannot contain fields of type 'tmp.S'
75	// :18:9: note: only packed structs layout are allowed in packed types
76	// :56:11: note: struct declared here
77	// :23:9: error: packed structs cannot contain fields of type 'tmp.U'
78	// :23:9: note: only packed unions layout are allowed in packed types
79	// :59:18: note: union declared here
80	// :28:9: error: packed structs cannot contain fields of type '?anyerror'
81	// :28:9: note: type has no guaranteed in-memory representation
82	// :38:9: error: packed structs cannot contain fields of type 'fn() void'
83	// :38:9: note: type has no guaranteed in-memory representation
84	// :38:9: note: use '*const ' to make a function pointer type

test/cases/compile_errors/stage1/test/packed_struct_with_fields_of_not_allowed_types.zig deleted-74

...	@@ -1,74 +0,0 @@
1	const A = packed struct {
2	x: anyerror,
3	};
4	const B = packed struct {
5	x: [2]u24,
6	};
7	const C = packed struct {
8	x: [1]anyerror,
9	};
10	const D = packed struct {
11	x: [1]S,
12	};
13	const E = packed struct {
14	x: [1]U,
15	};
16	const F = packed struct {
17	x: ?anyerror,
18	};
19	const G = packed struct {
20	x: Enum,
21	};
22	export fn entry1() void {
23	var a: A = undefined;
24	_ = a;
25	}
26	export fn entry2() void {
27	var b: B = undefined;
28	_ = b;
29	}
30	export fn entry3() void {
31	var r: C = undefined;
32	_ = r;
33	}
34	export fn entry4() void {
35	var d: D = undefined;
36	_ = d;
37	}
38	export fn entry5() void {
39	var e: E = undefined;
40	_ = e;
41	}
42	export fn entry6() void {
43	var f: F = undefined;
44	_ = f;
45	}
46	export fn entry7() void {
47	var g: G = undefined;
48	_ = g;
49	}
50	const S = struct {
51	x: i32,
52	};
53	const U = struct {
54	A: i32,
55	B: u32,
56	};
57	const Enum = enum {
58	A,
59	B,
60	};
61
62	// error
63	// backend=stage1
64	// target=native
65	// is_test=1
66	//
67	// tmp.zig:2:5: error: type 'anyerror' not allowed in packed struct; no guaranteed in-memory representation
68	// tmp.zig:5:5: error: array of 'u24' not allowed in packed struct due to padding bits (must be padded from 48 to 64 bits)
69	// tmp.zig:8:5: error: type 'anyerror' not allowed in packed struct; no guaranteed in-memory representation
70	// tmp.zig:11:5: error: non-packed, non-extern struct 'S' not allowed in packed struct; no guaranteed in-memory representation
71	// tmp.zig:14:5: error: non-packed, non-extern struct 'U' not allowed in packed struct; no guaranteed in-memory representation
72	// tmp.zig:17:5: error: type '?anyerror' not allowed in packed struct; no guaranteed in-memory representation
73	// tmp.zig:20:5: error: type 'Enum' not allowed in packed struct; no guaranteed in-memory representation
74	// tmp.zig:57:14: note: enum declaration does not specify an integer tag type