Commit d5f1a8823eb964c6149fc1d627ea6936d70ea7f1 | zig

author	Matthew Lugg <mlugg@mlugg.co.uk> 2023-04-20 00:55:52+01:00
committer	Andrew Kelley <andrew@ziglang.org> 2023-04-20 09:05:22-07:00
log	d5f1a8823eb964c6149fc1d627ea6936d70ea7f1
tree	163967d4c1bac8455b0d3e66734d5788a3f1e6d4
parent	31b6d14bf76fa6b78013a6a32d3066e882d64043

Sema: allow ptr field access on pointer-to-array

Also remove an incorrect piece of logic which allowed fetching the 'len'
property on non-single-ptrs (e.g. many-ptrs) and add a corresponding
compile error test case.

Resolves: #4765

3 files changed, 36 insertions(+), 14 deletions(-)

src
- Sema.zig
test
- behavior
  - array.zig
- cases
  - compile_errors
    len_access_on_array_many_ptr.zig

src/Sema.zig+16-14

 @@ -23279,6 +23279,22 @@ fn fieldVal(
                     Type.usize,
                     try Value.Tag.int_u64.create(arena, inner_ty.arrayLen()),
                 );
+            } else if (mem.eql(u8, field_name, "ptr") and is_pointer_to) {
+                const ptr_info = object_ty.ptrInfo().data;
+                const result_ty = try Type.ptr(sema.arena, sema.mod, .{
+                    .pointee_type = ptr_info.pointee_type.childType(),
+                    .sentinel = ptr_info.sentinel,
+                    .@"align" = ptr_info.@"align",
+                    .@"addrspace" = ptr_info.@"addrspace",
+                    .bit_offset = ptr_info.bit_offset,
+                    .host_size = ptr_info.host_size,
+                    .vector_index = ptr_info.vector_index,
+                    .@"allowzero" = ptr_info.@"allowzero",
+                    .mutable = ptr_info.mutable,
+                    .@"volatile" = ptr_info.@"volatile",
+                    .size = .Many,
+                });
+                return sema.coerce(block, result_ty, object, src);
             } else {
                 return sema.fail(
                     block,
 @@ -23311,20 +23327,6 @@ fn fieldVal(
                         .{ field_name, object_ty.fmt(sema.mod) },
                     );
                 }
-            } else if (ptr_info.pointee_type.zigTypeTag() == .Array) {
-                if (mem.eql(u8, field_name, "len")) {
-                    return sema.addConstant(
-                        Type.usize,
-                        try Value.Tag.int_u64.create(arena, ptr_info.pointee_type.arrayLen()),
-                    );
-                } else {
-                    return sema.fail(
-                        block,
-                        field_name_src,
-                        "no member named '{s}' in '{}'",
-                        .{ field_name, ptr_info.pointee_type.fmt(sema.mod) },
-                    );
-                }
             }
         },
         .Type => {

test/behavior/array.zig+10

...	@@ -677,3 +677,13 @@ test "array of array agregate init" {	...	@@ -677,3 +677,13 @@ test "array of array agregate init" {
677	var b = [1][10]u32{a} ** 2;	677	var b = [1][10]u32{a} ** 2;
678	try std.testing.expect(b[1][1] == 11);	678	try std.testing.expect(b[1][1] == 11);
679	}	679	}
		680
		681	test "pointer to array has ptr field" {
		682	const arr: *const [5]u32 = &.{ 10, 20, 30, 40, 50 };
		683	try std.testing.expect(arr.ptr == @as([*]const u32, arr));
		684	try std.testing.expect(arr.ptr[0] == 10);
		685	try std.testing.expect(arr.ptr[1] == 20);
		686	try std.testing.expect(arr.ptr[2] == 30);
		687	try std.testing.expect(arr.ptr[3] == 40);
		688	try std.testing.expect(arr.ptr[4] == 50);
		689	}

test/cases/compile_errors/len_access_on_array_many_ptr.zig created+10

...	@@ -0,0 +1,10 @@
1	export fn foo() void {
2	const x: [*][5]u8 = undefined;
3	_ = x.len;
4	}
5
6	// error
7	// backend=stage2
8	// target=native
9	//
10	// :3:10: error: type '[*][5]u8' does not support field access