Commit e69d19d1ee06ebb50af191d2911355d817eb1249 | zig

author	Justus Klausecker <justus@klausecker.de> 2026-05-17 19:11:16+02:00
committer	Justus Klausecker <justus@klausecker.de> 2026-08-02 14:41:10+02:00
log	e69d19d1ee06ebb50af191d2911355d817eb1249
tree	a004c24ecaa7cce788883e0a1067c4c8715e75c3
parent	539bdfc46ff75a4a4febb97a7700ade393c1cb22

Sema: allow direct dereference of comptime-known slices

A comptime-known `[]T` should behave as similarly as possible to a comptime-
known `*[n]T`. It is now possible to directly dereference both to an array.

Also adds checks for slices with undefined length in code paths where a
slice is dereferenced as an array which would previously crash.

7 files changed, 126 insertions(+), 34 deletions(-)

lib
- std
  - zig
    Zir.zig
src
- Sema.zig
- Zcu
  - PerThread.zig
test
- behavior
  - slice.zig
- cases
  - compile_errors
    deref_slice_and_get_len_field.zig
    deref_slice_with_undef_len.zig
    dereference_slice.zig

lib/std/zig/Zir.zig+1-1

...	@@ -584,7 +584,7 @@ pub const Inst = struct {	...	@@ -584,7 +584,7 @@ pub const Inst = struct {
584	/// containing the instruction.	584	/// containing the instruction.
585	/// Uses the `un_tok` union field.	585	/// Uses the `un_tok` union field.
586	ref,	586	ref,
587	/// Implements the dereference operand (`.*`). Checks that operand is a pointer	587	/// Implements the dereference operator (`.*`). Checks that operand is a pointer
588	/// that supports being directly dereferenced.	588	/// that supports being directly dereferenced.
589	/// Uses the `un_node` union field.	589	/// Uses the `un_node` union field.
590	deref,	590	deref,

src/Sema.zig+37-31

 @@ -2352,6 +2352,10 @@ pub fn failWithUseOfUndef(sema: *Sema, block: *Block, src: LazySrcLoc, vector_in
     });
 }
+pub fn failWithUndefSliceLen(sema: *Sema, block: *Block, src: LazySrcLoc) CompileError {
+    return sema.fail(block, src, "use of slice with undefined length here causes illegal behavior", .{});
+}
 pub fn failWithDivideByZero(sema: *Sema, block: *Block, src: LazySrcLoc) CompileError {
     return sema.fail(block, src, "division by zero here causes illegal behavior", .{});
 }
 @@ -3113,9 +3117,14 @@ fn zirRefDeref(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai
     try sema.validateDeref(block, src, operand, operand_ty);
     const ptr_info = operand_ty.ptrInfo(zcu);
-    return switch (ptr_info.flags.size) {
+    return single_ptr: switch (ptr_info.flags.size) {
-        .many, .slice => unreachable, // cannot be dereferenced
+        .many => unreachable, // cannot be dereferenced directly
-        .c => single_ptr: {
+        .slice => {
+            const slice_val = sema.resolveValue(operand).?;
+            const slice = zcu.intern_pool.indexToKey(slice_val.toIntern()).slice;
+            break :single_ptr .fromValue(try pt.sliceToArrayPtr(slice));
+        },
+        .c => {
             const single_ptr_ty = try pt.ptrType(p: {
                 var p = ptr_info;
                 p.flags.size = .one;
 @@ -3149,18 +3158,26 @@ fn validateDeref(
 ) CompileError!void {
     const pt = sema.pt;
     const zcu = pt.zcu;
+    const ip = &zcu.intern_pool;
     if (ty.zigTypeTag(zcu) != .pointer) {
         return sema.fail(block, src, "cannot dereference non-pointer type '{f}'", .{ty.fmt(pt)});
-    } else switch (ty.ptrSize(zcu)) {
+    }
-        .one, .c => {},
+    const size = ty.ptrSize(zcu);
+    switch (size) {
         .many => return sema.fail(block, src, "index syntax required for unknown-length pointer type '{f}'", .{ty.fmt(pt)}),
-        .slice => return sema.fail(block, src, "index syntax required for slice type '{f}'", .{ty.fmt(pt)}),
+        .one, .c, .slice => {},
     }
     if (sema.resolveValue(ref)) |val| {
         // Error for deref of undef pointer, unless the pointee is OPV in which case it's legal.
         if (val.isUndef(zcu) and ty.childType(zcu).classify(zcu) != .one_possible_value) {
             return sema.fail(block, src, "cannot dereference undefined value", .{});
         }
+        // We need a defined slice length for the array type the slice should be dereferenced to.
+        if (size == .slice and ip.indexToKey(val.toIntern()).slice.len == .undef_usize) {
+            return sema.fail(block, src, "cannot dereference slice with undefined length", .{});
+        }
+    } else if (size == .slice) {
+        return sema.fail(block, src, "index syntax required to access runtime-known slice", .{});
     }
 }
 @@ -13570,14 +13587,14 @@ fn zirArrayCat(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai
             const lhs_sub_val = if (lhs_ty.isSinglePointer(zcu))
                 try sema.pointerDeref(block, lhs_src, lhs_val, lhs_ty) orelse break :rs lhs_src
             else if (lhs_ty.isSlice(zcu))
-                try sema.maybeDerefSliceAsArray(block, lhs_src, lhs_val) orelse break :rs lhs_src
+                try sema.maybeDerefSliceAsArray(block, lhs_src, lhs_val, lhs_ty) orelse break :rs lhs_src
             else
                 lhs_val;
             const rhs_sub_val = if (rhs_ty.isSinglePointer(zcu))
                 try sema.pointerDeref(block, rhs_src, rhs_val, rhs_ty) orelse break :rs rhs_src
             else if (rhs_ty.isSlice(zcu))
-                try sema.maybeDerefSliceAsArray(block, rhs_src, rhs_val) orelse break :rs rhs_src
+                try sema.maybeDerefSliceAsArray(block, rhs_src, rhs_val, rhs_ty) orelse break :rs rhs_src
             else
                 rhs_val;
 @@ -30940,8 +30957,11 @@ fn analyzeLoad(
     };
     if (try sema.resolveDefinedValue(block, ptr_src, ptr)) |ptr_val| {
-        if (try sema.pointerDeref(block, src, ptr_val, ptr_ty)) |elem_val| {
+        if (switch (ptr_ty.ptrSize(zcu)) {
-            return Air.internedToRef(elem_val.toIntern());
+            .slice => try sema.maybeDerefSliceAsArray(block, src, ptr_val, ptr_ty),
+            else => try sema.pointerDeref(block, src, ptr_val, ptr_ty),
+        }) |elem_val| {
+            return .fromValue(elem_val);
         }
     }
 @@ -34558,7 +34578,7 @@ fn anyUndef(sema: *Sema, block: *Block, src: LazySrcLoc, val: Value) !bool {
         .slice => {
             // If the slice contents are runtime-known, reification will fail later on with a
             // specific error message.
-            const arr = try sema.maybeDerefSliceAsArray(block, src, val) orelse return false;
+            const arr = try sema.maybeDerefSliceAsArray(block, src, val, val.typeOf(zcu)) orelse return false;
             return sema.anyUndef(block, src, arr);
         },
         .aggregate => |aggregate| for (0..aggregate.storage.values().len) |i| {
 @@ -34599,7 +34619,7 @@ fn derefSliceAsArray(
     /// being comptime-resolved is that the block is being comptime-evaluated.
     reason: ?ComptimeReason,
 ) CompileError!Value {
-    return try sema.maybeDerefSliceAsArray(block, src, slice_val) orelse {
+    return try sema.maybeDerefSliceAsArray(block, src, slice_val, slice_val.typeOf(sema.pt.zcu)) orelse {
         return sema.failWithNeededComptime(block, src, reason);
     };
 }
 @@ -34612,37 +34632,23 @@ fn maybeDerefSliceAsArray(
     block: *Block,
     src: LazySrcLoc,
     slice_val: Value,
+    slice_ty: Type,
 ) CompileError!?Value {
     const pt = sema.pt;
     const zcu = pt.zcu;
-    const ip = &zcu.intern_pool;
-    const slice_ty = slice_val.typeOf(zcu);
-    assert(slice_ty.zigTypeTag(zcu) == .pointer);
     switch (slice_ty.ptrInfo(zcu).flags.size) {
         .slice => {},
         .one => return sema.pointerDeref(block, src, slice_val, slice_ty),
         .many, .c => unreachable,
     }
-    const slice = switch (ip.indexToKey(slice_val.toIntern())) {
+    const slice = switch (zcu.intern_pool.indexToKey(slice_val.toIntern())) {
         .undef => return sema.failWithUseOfUndef(block, src, null),
         .slice => |slice| slice,
         else => unreachable,
     };
-    const elem_ty = Type.fromInterned(slice.ty).childType(zcu);
+    if (slice.len == .undef_usize) return sema.failWithUndefSliceLen(block, src);
-    const len = Value.fromInterned(slice.len).toUnsignedInt(zcu);
+    const casted_ptr = try pt.sliceToArrayPtr(slice);
-    const array_ty = try pt.arrayType(.{
+    return sema.pointerDeref(block, src, casted_ptr, casted_ptr.typeOf(zcu));
-        .child = elem_ty.toIntern(),
-        .len = len,
-    });
-    const ptr_ty = try pt.ptrType(p: {
-        var p = Type.fromInterned(slice.ty).ptrInfo(zcu);
-        p.flags.size = .one;
-        p.child = array_ty.toIntern();
-        p.sentinel = .none;
-        break :p p;
-    });
-    const casted_ptr = try pt.getCoerced(Value.fromInterned(slice.ptr), ptr_ty);
-    return sema.pointerDeref(block, src, casted_ptr, ptr_ty);
 }
 fn analyzeUnreachable(sema: *Sema, block: *Block, src: LazySrcLoc, safety_check: bool) !void {

src/Zcu/PerThread.zig+19

...	@@ -3498,6 +3498,25 @@ pub fn getErrorValueFromSlice(pt: Zcu.PerThread, name: []const u8) Allocator.Err	...	@@ -3498,6 +3498,25 @@ pub fn getErrorValueFromSlice(pt: Zcu.PerThread, name: []const u8) Allocator.Err
3498	return pt.getErrorValue(try pt.zcu.intern_pool.getOrPutString(gpa, io, name));	3498	return pt.getErrorValue(try pt.zcu.intern_pool.getOrPutString(gpa, io, name));
3499	}	3499	}
3500		3500
		3501	/// Asserts that `slice.len` is not undef.
		3502	pub fn sliceToArrayPtr(pt: Zcu.PerThread, slice: InternPool.Key.Slice) Allocator.Error!Value {
		3503	const zcu = pt.zcu;
		3504	const slice_info = Type.fromInterned(slice.ty).ptrInfo(zcu);
		3505	const array_ty = try pt.arrayType(.{
		3506	.len = Value.fromInterned(slice.len).toUnsignedInt(zcu),
		3507	.child = slice_info.child,
		3508	.sentinel = slice_info.sentinel,
		3509	});
		3510	const ptr_ty = try pt.ptrType(ptr_info: {
		3511	var ptr_info = slice_info;
		3512	ptr_info.flags.size = .one;
		3513	ptr_info.child = array_ty.toIntern();
		3514	ptr_info.sentinel = .none;
		3515	break :ptr_info ptr_info;
		3516	});
		3517	return pt.getCoerced(.fromInterned(slice.ptr), ptr_ty);
		3518	}
		3519
3501	/// Removes any entry from `Zcu.failed_files` associated with `file`. Acquires `Compilation.mutex` as needed.	3520	/// Removes any entry from `Zcu.failed_files` associated with `file`. Acquires `Compilation.mutex` as needed.
3502	/// `file.zir` must be unchanged from the last update, as it is used to determine if there is such an entry.	3521	/// `file.zir` must be unchanged from the last update, as it is used to determine if there is such an entry.
3503	fn lockAndClearFileCompileError(pt: Zcu.PerThread, file_index: Zcu.File.Index, file: *Zcu.File) void {	3522	fn lockAndClearFileCompileError(pt: Zcu.PerThread, file_index: Zcu.File.Index, file: *Zcu.File) void {

test/behavior/slice.zig+44

...	@@ -1089,3 +1089,47 @@ test "slice field alignment" {	...	@@ -1089,3 +1089,47 @@ test "slice field alignment" {
1089	var arr: [10]u8 = @splat(0);	1089	var arr: [10]u8 = @splat(0);
1090	try S.doTheTest(&&arr);	1090	try S.doTheTest(&&arr);
1091	}	1091	}
		1092
		1093	test "directly deref slice with comptime-known length" {
		1094	{
		1095	const slice: []const u16 = &.{ 1, 2, 3 };
		1096	const array = slice.*;
		1097
		1098	comptime assert(@TypeOf(array) == [3]u16);
		1099	comptime assert(array[0] == 1);
		1100	comptime assert(array[1] == 2);
		1101	comptime assert(array[2] == 3);
		1102	}
		1103	{
		1104	const slice: [:0]const u16 = &.{ 1, 2, 3 };
		1105	const array = slice.*;
		1106
		1107	comptime assert(@TypeOf(array) == [3:0]u16);
		1108	comptime assert(array[0] == 1);
		1109	comptime assert(array[1] == 2);
		1110	comptime assert(array[2] == 3);
		1111	comptime assert(array[3] == 0);
		1112	}
		1113	}
		1114
		1115	test "address of dereferenced slice is array pointer" {
		1116	{
		1117	const slice: []const u16 = &.{ 1, 2, 3 };
		1118	const array_ptr = &slice.*;
		1119
		1120	comptime assert(@TypeOf(array_ptr) == *const [3]u16);
		1121	comptime assert(array_ptr[0] == 1);
		1122	comptime assert(array_ptr[1] == 2);
		1123	comptime assert(array_ptr[2] == 3);
		1124	}
		1125	{
		1126	const slice: [:0]const u16 = &.{ 1, 2, 3 };
		1127	const array_ptr = &slice.*;
		1128
		1129	comptime assert(@TypeOf(array_ptr) == *const [3:0]u16);
		1130	comptime assert(array_ptr[0] == 1);
		1131	comptime assert(array_ptr[1] == 2);
		1132	comptime assert(array_ptr[2] == 3);
		1133	comptime assert(array_ptr[3] == 0);
		1134	}
		1135	}

test/cases/compile_errors/deref_slice_and_get_len_field.zig+1-1

...	@@ -6,4 +6,4 @@ export fn entry() void {	...	@@ -6,4 +6,4 @@ export fn entry() void {
6		6
7	// error	7	// error
8	//	8	//
9	// :3:10: error: index syntax required for slice type '[]u8'	9	// :3:10: error: index syntax required to access runtime-known slice

test/cases/compile_errors/deref_slice_with_undef_len.zig created+23

...	@@ -0,0 +1,23 @@
1	export fn entry2() void {
2	comptime var slice: []const u16 = &.{ 1, 2, 3 };
3	slice.len = undefined;
4	_ = slice.*;
5	}
6
7	export fn entry3() void {
8	comptime var slice: []const u16 = &.{ 1, 2, 3 };
9	slice.len = undefined;
10	_ = &slice.*;
11	}
12
13	export fn entry4() void {
14	comptime var slice: []const u8 = "hello";
15	slice.len = undefined;
16	@compileError(slice);
17	}
18
19	// error
20	//
21	// :4:14: error: cannot dereference slice with undefined length
22	// :10:15: error: cannot dereference slice with undefined length
23	// :16:19: error: use of slice with undefined length here causes illegal behavior

test/cases/compile_errors/dereference_slice.zig+1-1

...	@@ -7,4 +7,4 @@ comptime {	...	@@ -7,4 +7,4 @@ comptime {
7		7
8	// error	8	// error
9	//	9	//
10	// :2:13: error: index syntax required for slice type '[]i32'	10	// :2:13: error: index syntax required to access runtime-known slice