Commit 91619cdf57f54accbdbb3ff616856eaf79b537a3 | zig

author	Andrew Kelley <andrew@ziglang.org> 2021-12-28 20:48:21-07:00
committer	Andrew Kelley <andrew@ziglang.org> 2021-12-28 23:22:09-07:00
log	91619cdf57f54accbdbb3ff616856eaf79b537a3
tree	9da2362e728f068103a1ab83a89411f825a5c10b
parent	2dd725571302a2e6e4101565554e88b4a10b0994

Sema: implement calling a fn ptr via a union field

Also, ignore `packed` on unions because that will be removed from the
language.

4 files changed, 48 insertions(+), 57 deletions(-)

src
- Module.zig
- Sema.zig
test
- behavior
  - union.zig
  - union_stage1.zig

src/Module.zig-3

 @@ -1104,9 +1104,6 @@ pub const Union = struct {
     pub fn getLayout(u: Union, target: Target, have_tag: bool) Layout {
         assert(u.status == .have_layout);
-        const is_packed = u.layout == .Packed;
-        if (is_packed) @panic("TODO packed unions");
         var most_aligned_field: usize = undefined;
         var most_aligned_field_size: u64 = undefined;
         var biggest_field: usize = undefined;

src/Sema.zig+36-22

 @@ -12152,34 +12152,16 @@ fn fieldCallBind(
                 const field_index = @intCast(u32, field_index_usize);
                 const field = struct_obj.fields.values()[field_index];
-                const ptr_field_ty = try Type.ptr(arena, .{
+                return finishFieldCallBind(sema, block, src, ptr_ty, field.ty, field_index, object_ptr);
-                    .pointee_type = field.ty,
-                    .mutable = ptr_ty.ptrIsMutable(),
-                    .@"addrspace" = ptr_ty.ptrAddressSpace(),
-                });
-                if (try sema.resolveDefinedValue(block, src, object_ptr)) |struct_ptr_val| {
-                    const pointer = try sema.addConstant(
-                        ptr_field_ty,
-                        try Value.Tag.field_ptr.create(arena, .{
-                            .container_ptr = struct_ptr_val,
-                            .field_index = field_index,
-                        }),
-                    );
-                    return sema.analyzeLoad(block, src, pointer, src);
-                }
-                try sema.requireRuntimeBlock(block, src);
-                const ptr_inst = try block.addStructFieldPtr(object_ptr, field_index, ptr_field_ty);
-                return sema.analyzeLoad(block, src, ptr_inst, src);
             },
             .Union => {
                 const union_ty = try sema.resolveTypeFields(block, src, concrete_ty);
                 const fields = union_ty.unionFields();
                 const field_index_usize = fields.getIndex(field_name) orelse break :find_field;
+                const field_index = @intCast(u32, field_index_usize);
+                const field = fields.values()[field_index];
-                _ = field_index_usize;
+                return finishFieldCallBind(sema, block, src, ptr_ty, field.ty, field_index, object_ptr);
-                return sema.fail(block, src, "TODO implement field calls on unions", .{});
             },
             .Type => {
                 const namespace = try sema.analyzeLoad(block, src, object_ptr, src);
 @@ -12236,6 +12218,38 @@ fn fieldCallBind(
     return sema.fail(block, src, "type '{}' has no field or member function named '{s}'", .{ concrete_ty, field_name });
 }
+fn finishFieldCallBind(
+    sema: *Sema,
+    block: *Block,
+    src: LazySrcLoc,
+    ptr_ty: Type,
+    field_ty: Type,
+    field_index: u32,
+    object_ptr: Air.Inst.Ref,
+) CompileError!Air.Inst.Ref {
+    const arena = sema.arena;
+    const ptr_field_ty = try Type.ptr(arena, .{
+        .pointee_type = field_ty,
+        .mutable = ptr_ty.ptrIsMutable(),
+        .@"addrspace" = ptr_ty.ptrAddressSpace(),
+    });
+    if (try sema.resolveDefinedValue(block, src, object_ptr)) |struct_ptr_val| {
+        const pointer = try sema.addConstant(
+            ptr_field_ty,
+            try Value.Tag.field_ptr.create(arena, .{
+                .container_ptr = struct_ptr_val,
+                .field_index = field_index,
+            }),
+        );
+        return sema.analyzeLoad(block, src, pointer, src);
+    }
+    try sema.requireRuntimeBlock(block, src);
+    const ptr_inst = try block.addStructFieldPtr(object_ptr, field_index, ptr_field_ty);
+    return sema.analyzeLoad(block, src, ptr_inst, src);
+}
 fn namespaceLookup(
     sema: *Sema,
     block: *Block,

test/behavior/union.zig+12

...	@@ -165,6 +165,18 @@ test "union with specified enum tag" {	...	@@ -165,6 +165,18 @@ test "union with specified enum tag" {
165	comptime try doTest();	165	comptime try doTest();
166	}	166	}
167		167
		168	test "packed union generates correctly aligned LLVM type" {
		169	const U = packed union {
		170	f1: fn () error{TestUnexpectedResult}!void,
		171	f2: u32,
		172	};
		173	var foo = [_]U{
		174	U{ .f1 = doTest },
		175	U{ .f2 = 0 },
		176	};
		177	try foo[0].f1();
		178	}
		179
168	fn doTest() error{TestUnexpectedResult}!void {	180	fn doTest() error{TestUnexpectedResult}!void {
169	try expect((try bar(Payload{ .A = 1234 })) == -10);	181	try expect((try bar(Payload{ .A = 1234 })) == -10);
170	}	182	}

test/behavior/union_stage1.zig-32

...	@@ -3,38 +3,6 @@ const expect = std.testing.expect;	...	@@ -3,38 +3,6 @@ const expect = std.testing.expect;
3	const expectEqual = std.testing.expectEqual;	3	const expectEqual = std.testing.expectEqual;
4	const Tag = std.meta.Tag;	4	const Tag = std.meta.Tag;
5		5
6	const Letter = enum { A, B, C };
7	const Payload = union(Letter) {
8	A: i32,
9	B: f64,
10	C: bool,
11	};
12
13	fn doTest() error{TestUnexpectedResult}!void {
14	try expect((try bar(Payload{ .A = 1234 })) == -10);
15	}
16
17	fn bar(value: Payload) error{TestUnexpectedResult}!i32 {
18	try expect(@as(Letter, value) == Letter.A);
19	return switch (value) {
20	Payload.A => \|x\| return x - 1244,
21	Payload.B => \|x\| if (x == 12.34) @as(i32, 20) else 21,
22	Payload.C => \|x\| if (x) @as(i32, 30) else 31,
23	};
24	}
25
26	test "packed union generates correctly aligned LLVM type" {
27	const U = packed union {
28	f1: fn () error{TestUnexpectedResult}!void,
29	f2: u32,
30	};
31	var foo = [_]U{
32	U{ .f1 = doTest },
33	U{ .f2 = 0 },
34	};
35	try foo[0].f1();
36	}
37
38	const MultipleChoice = union(enum(u32)) {	6	const MultipleChoice = union(enum(u32)) {
39	A = 20,	7	A = 20,
40	B = 40,	8	B = 40,