Sema: allow indexing tuple and vector pointers

Resolves: #13852
Resolves: #14705

Author: mlugg

src/Sema.zig

@@ -9957,7 +9957,7 @@ fn zirElemPtr(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air
                 indexable_ty.fmt(sema.mod),
             });
             errdefer msg.destroy(sema.gpa);
-            if (indexable_ty.zigTypeTag() == .Array) {
+            if (indexable_ty.isIndexable()) {
                 try sema.errNote(block, src, msg, "consider using '&' here", .{});
             }
             break :msg msg;
@@ -24979,8 +24979,19 @@ fn elemPtrOneLayerOnly(
             return block.addPtrElemPtr(indexable, elem_index, result_ty);
         },
         .One => {
-            assert(indexable_ty.childType().zigTypeTag() == .Array); // Guaranteed by checkIndexable
-            return sema.elemPtrArray(block, src, indexable_src, indexable, elem_index_src, elem_index, init, oob_safety);
+            const child_ty = indexable_ty.childType();
+            switch (child_ty.zigTypeTag()) {
+                .Array, .Vector => {
+                    return sema.elemPtrArray(block, src, indexable_src, indexable, elem_index_src, elem_index, init, oob_safety);
+                },
+                .Struct => {
+                    assert(child_ty.isTuple());
+                    const index_val = try sema.resolveConstValue(block, elem_index_src, elem_index, "tuple field access index must be comptime-known");
+                    const index = @intCast(u32, index_val.toUnsignedInt(target));
+                    return sema.tupleFieldPtr(block, indexable_src, indexable, elem_index_src, index, false);
+                },
+                else => unreachable, // Guaranteed by checkIndexable
+            }
         },
     }
 }
@@ -25026,7 +25037,6 @@ fn elemVal(
                 return block.addBinOp(.ptr_elem_val, indexable, elem_index);
             },
             .One => {
-                assert(indexable_ty.childType().zigTypeTag() == .Array); // Guaranteed by checkIndexable
                 const elem_ptr = try sema.elemPtr(block, indexable_src, indexable, elem_index, elem_index_src, false, oob_safety);
                 return sema.analyzeLoad(block, indexable_src, elem_ptr, elem_index_src);
             },

src/type.zig

@@ -5329,7 +5329,11 @@ pub const Type = extern union {
             .Array, .Vector => true,
             .Pointer => switch (ty.ptrSize()) {
                 .Slice, .Many, .C => true,
-                .One => ty.elemType().zigTypeTag() == .Array,
+                .One => switch (ty.elemType().zigTypeTag()) {
+                    .Array, .Vector => true,
+                    .Struct => ty.elemType().isTuple(),
+                    else => false,
+                },
             },
             .Struct => ty.isTuple(),
             else => false,
@@ -5342,7 +5346,11 @@ pub const Type = extern union {
             .Pointer => switch (ty.ptrSize()) {
                 .Many, .C => false,
                 .Slice => true,
-                .One => ty.elemType().zigTypeTag() == .Array,
+                .One => switch (ty.elemType().zigTypeTag()) {
+                    .Array, .Vector => true,
+                    .Struct => ty.elemType().isTuple(),
+                    else => false,
+                },
             },
             .Struct => ty.isTuple(),
             else => false,

test/behavior/for.zig

@@ -463,3 +463,19 @@ test "inline for with counter as the comptime-known" {
 
     try expect(S.ok == 2);
 }
+
+test "inline for on tuple pointer" {
+    if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; // TODO
+
+    const S = struct { u32, u32, u32 };
+    var s: S = .{ 100, 200, 300 };
+
+    inline for (&s, 0..) |*x, i| {
+        x.* = i;
+    }
+
+    try expectEqual(S{ 0, 1, 2 }, s);
+}

test/behavior/tuple.zig

@@ -1,6 +1,7 @@
 const builtin = @import("builtin");
 const std = @import("std");
 const testing = std.testing;
+const assert = std.debug.assert;
 const expect = testing.expect;
 const expectEqualStrings = std.testing.expectEqualStrings;
 const expectEqual = std.testing.expectEqual;
@@ -428,3 +429,27 @@ test "sentinel slice in tuple" {
 
     _ = S;
 }
+
+test "tuple pointer is indexable" {
+    if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; // TODO
+
+    const S = struct { u32, bool };
+
+    const x: S = .{ 123, true };
+    comptime assert(@TypeOf(&(&x)[0]) == *const u32); // validate constness
+    try expectEqual(@as(u32, 123), (&x)[0]);
+    try expectEqual(true, (&x)[1]);
+
+    var y: S = .{ 123, true };
+    comptime assert(@TypeOf(&(&y)[0]) == *u32); // validate constness
+    try expectEqual(@as(u32, 123), (&y)[0]);
+    try expectEqual(true, (&y)[1]);
+
+    (&y)[0] = 100;
+    (&y)[1] = false;
+    try expectEqual(@as(u32, 100), (&y)[0]);
+    try expectEqual(false, (&y)[1]);
+}

test/behavior/vector.zig

@@ -2,6 +2,7 @@ const std = @import("std");
 const builtin = @import("builtin");
 const mem = std.mem;
 const math = std.math;
+const assert = std.debug.assert;
 const expect = std.testing.expect;
 const expectEqual = std.testing.expectEqual;
 
@@ -1330,3 +1331,29 @@ test "addition of vectors represented as strings" {
     const bar: V = @typeName(u32).*;
     try expectEqual(V{ 219, 162, 161 }, foo + bar);
 }
+
+test "vector pointer is indexable" {
+    if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; // TODO
+
+    const V = @Vector(2, u32);
+
+    const x: V = .{ 123, 456 };
+    comptime assert(@TypeOf(&(&x)[0]) == *const u32); // validate constness
+    try expectEqual(@as(u32, 123), (&x)[0]);
+    try expectEqual(@as(u32, 456), (&x)[1]);
+
+    var y: V = .{ 123, 456 };
+    comptime assert(@TypeOf(&(&y)[0]) == *u32); // validate constness
+    try expectEqual(@as(u32, 123), (&y)[0]);
+    try expectEqual(@as(u32, 456), (&y)[1]);
+
+    (&y)[0] = 100;
+    (&y)[1] = 200;
+    try expectEqual(@as(u32, 100), (&y)[0]);
+    try expectEqual(@as(u32, 200), (&y)[1]);
+}