Commit 276f2e1b810aef048c3ce324e0977ba2d9ff8200 | zig

author	Andrew Kelley <andrew@ziglang.org> 2026-08-08 09:43:59+02:00
committer	Andrew Kelley <andrew@ziglang.org> 2026-08-08 09:43:59+02:00
log	276f2e1b810aef048c3ce324e0977ba2d9ff8200
tree	ad66f0e1a007298b564f084e1ffc89d99a191d8c
parent	5152987072ef2d030a704d2b4ca9cebd757d4cec
parent	c0924842744fea67df49c9942b99d855b83578e5

Merge pull request 'fix: Allocator contract should allow *[len]T in more places' (#36113) from robbielyman/zig:push-oxmuzrvppsyx into master

Reviewed-on: https://codeberg.org/ziglang/zig/pulls/36113
Reviewed-by: Andrew Kelley <andrew@ziglang.org>

3 files changed, 130 insertions(+), 27 deletions(-)

lib
- std
  - mem.zig
  - mem
    Allocator.zig
  - meta.zig

lib/std/mem.zig+26-12

 @@ -9,6 +9,7 @@ const assert = debug.assert;
 const math = std.math;
 const testing = std.testing;
 const Endian = std.lang.Endian;
+const AbsorbSentinel = std.meta.AbsorbSentinel;
 /// The standard library currently thoroughly depends on byte size
 /// being 8 bits.  (see the use of u8 throughout allocation code as
 @@ -4738,22 +4739,28 @@ test "sliceAsBytes preserves pointer attributes" {
     try testing.expectEqual(in_attrs.@"align", out_attrs.@"align");
 }
-fn AbsorbSentinelReturnType(comptime Slice: type) type {
-    const info = @typeInfo(Slice).pointer;
-    assert(info.size == .slice);
-    return @Pointer(.slice, info.attrs, info.child, null);
-}
 /// If the provided slice is not sentinel terminated, do nothing and return that slice.
 /// If it is sentinel-terminated, return a non-sentinel-terminated slice with the
 /// length increased by one to include the absorbed sentinel element.
-pub fn absorbSentinel(slice: anytype) AbsorbSentinelReturnType(@TypeOf(slice)) {
+pub fn absorbSentinel(slice: anytype) AbsorbSentinel(@TypeOf(slice)) {
     const info = @typeInfo(@TypeOf(slice)).pointer;
-    comptime assert(info.size == .slice);
+    switch (info.size) {
-    if (info.sentinel_ptr == null) {
+        .slice => {
-        return slice;
+            if (info.sentinel_ptr == null) {
-    } else {
+                return slice;
-        return slice.ptr[0 .. slice.len + 1];
+            } else {
+                return slice.ptr[0 .. slice.len + 1];
+            }
+        },
+        .one => {
+            const child_info = @typeInfo(info.child).array;
+            if (child_info.sentinel_ptr == null) {
+                return slice;
+            } else {
+                return slice[0 .. child_info.len + 1];
+            }
+        },
+        else => unreachable,
     }
 }
 @@ -4762,21 +4769,28 @@ test absorbSentinel {
         var buffer: [3:0]u8 = .{ 1, 2, 3 };
         const foo: [:0]const u8 = &buffer;
         const bar: []const u8 = &buffer;
+        const baz: *const [3:0]u8 = &buffer;
         try testing.expectEqual([]const u8, @TypeOf(absorbSentinel(foo)));
         try testing.expectEqual([]const u8, @TypeOf(absorbSentinel(bar)));
+        try testing.expectEqual(*const [4]u8, @TypeOf(absorbSentinel(baz)));
         try testing.expectEqualSlices(u8, &.{ 1, 2, 3, 0 }, absorbSentinel(foo));
         try testing.expectEqualSlices(u8, &.{ 1, 2, 3 }, absorbSentinel(bar));
+        try testing.expectEqualSlices(u8, &.{ 1, 2, 3, 0 }, absorbSentinel(baz));
     }
     {
         var buffer: [3:0]u8 = .{ 1, 2, 3 };
         const foo: [:0]u8 = &buffer;
         const bar: []u8 = &buffer;
+        const baz: *[3:0]u8 = &buffer;
         try testing.expectEqual([]u8, @TypeOf(absorbSentinel(foo)));
         try testing.expectEqual([]u8, @TypeOf(absorbSentinel(bar)));
+        try testing.expectEqual(*[4]u8, @TypeOf(absorbSentinel(baz)));
         var expected_foo = [_]u8{ 1, 2, 3, 0 };
         try testing.expectEqualSlices(u8, &expected_foo, absorbSentinel(foo));
         var expected_bar = [_]u8{ 1, 2, 3 };
         try testing.expectEqualSlices(u8, &expected_bar, absorbSentinel(bar));
+        var expected_baz = [_]u8{ 1, 2, 3, 0 };
+        try testing.expectEqualSlices(u8, &expected_baz, absorbSentinel(baz));
     }
 }

lib/std/mem/Allocator.zig+53-10

 @@ -8,6 +8,8 @@ const assert = std.debug.assert;
 const math = std.math;
 const mem = std.mem;
 const Alignment = std.mem.Alignment;
+const Slice = std.meta.Slice;
+const AbsorbSentinel = std.meta.AbsorbSentinel;
 pub const Error = error{OutOfMemory};
 pub const Log2Align = math.Log2Int(usize);
 @@ -316,8 +318,10 @@ pub fn allocBytesAligned(
 /// `new_len` may be zero, in which case the allocation is freed.
 pub fn resize(self: Allocator, allocation: anytype, new_len: usize) bool {
     const slice_info = @typeInfo(@TypeOf(allocation)).pointer;
-    comptime assert(slice_info.size == .slice);
+    const T = if (slice_info.size != .slice) comptime T: {
-    const T = slice_info.child;
+        assert(slice_info.size == .one);
+        break :T @typeInfo(slice_info.child).array.child;
+    } else slice_info.child;
     if (new_len == 0) {
         self.free(allocation);
         return true;
 @@ -351,10 +355,12 @@ pub fn resize(self: Allocator, allocation: anytype, new_len: usize) bool {
 /// `new_len` may be zero, in which case the allocation is freed.
 ///
 /// If the allocation's elements' type is zero bytes sized, `allocation.len` is set to `new_len`.
-pub fn remap(self: Allocator, allocation: anytype, new_len: usize) ?@TypeOf(allocation) {
+pub fn remap(self: Allocator, allocation: anytype, new_len: usize) ?Slice(AbsorbSentinel(@TypeOf(allocation))) {
     const slice_info = @typeInfo(@TypeOf(allocation)).pointer;
-    comptime assert(slice_info.size == .slice);
+    const T = if (slice_info.size != .slice) comptime T: {
-    const T = slice_info.child;
+        assert(slice_info.size == .one);
+        break :T @typeInfo(slice_info.child).array.child;
+    } else slice_info.child;
     if (new_len == 0) {
         self.free(allocation);
 @@ -393,7 +399,7 @@ pub fn remap(self: Allocator, allocation: anytype, new_len: usize) ?@TypeOf(allo
 ///   do the realloc more efficiently than the caller
 /// * `resize` which returns `false` when the `Allocator` implementation cannot
 ///   change the size without relocating the allocation.
-pub fn realloc(self: Allocator, old_mem: anytype, new_n: usize) Error!@TypeOf(old_mem) {
+pub fn realloc(self: Allocator, old_mem: anytype, new_n: usize) Error!Slice(AbsorbSentinel(@TypeOf(old_mem))) {
     return self.reallocAdvanced(old_mem, new_n, @returnAddress());
 }
 @@ -402,10 +408,12 @@ pub fn reallocAdvanced(
     old_mem: anytype,
     new_n: usize,
     return_address: usize,
-) Error!@TypeOf(old_mem) {
+) Error!Slice(AbsorbSentinel(@TypeOf(old_mem))) {
     const slice_info = @typeInfo(@TypeOf(old_mem)).pointer;
-    comptime assert(slice_info.size == .slice);
+    const T = if (slice_info.size != .slice) comptime T: {
-    const T = slice_info.child;
+        assert(slice_info.size == .one);
+        break :T @typeInfo(slice_info.child).array.child;
+    } else slice_info.child;
     if (old_mem.len == 0) {
         return self.allocAdvancedWithRetAddr(T, .fromByteUnitsOptional(slice_info.attrs.@"align"), new_n, return_address);
     }
 @@ -440,7 +448,6 @@ pub fn reallocAdvanced(
 pub fn free(self: Allocator, memory: anytype) void {
     const slice_info = @typeInfo(@TypeOf(memory)).pointer;
     if (slice_info.size != .slice) {
-        // slicing with comptime-known start and end results in *[len]T, which may be free'd
         comptime assert(slice_info.size == .one and @typeInfo(slice_info.child) == .array);
     }
     const bytes: []u8 = @ptrCast(@constCast(mem.absorbSentinel(memory)));
 @@ -585,3 +592,39 @@ test failing {
     try std.testing.expectError(error.OutOfMemory, f.alloc(u8, std.math.maxInt(usize)));
     try std.testing.expectError(error.OutOfMemory, f.allocSentinel(u8, std.math.maxInt(usize) - 1, 0));
 }
+test "free single-pointer to array" {
+    const allocator = std.testing.allocator;
+    {
+        const allocation = try allocator.alloc(u32, 128);
+        allocation[127] = 0;
+        const ptr: *[127:0]u32 = allocation[0..127 :0];
+        allocator.free(ptr);
+    }
+    {
+        const allocation = try allocator.alloc(u32, 128);
+        allocation[127] = 0;
+        const ptr: *[127:0]u32 = allocation[0..127 :0];
+        if (allocator.resize(ptr, 16)) {
+            allocator.free(ptr[0..16]);
+        } else allocator.free(ptr);
+    }
+    {
+        const allocation = try allocator.alloc(u32, 128);
+        allocation[127] = 0;
+        const ptr: *[127:0]u32 = allocation[0..127 :0];
+        if (allocator.remap(ptr, 16)) |new| {
+            allocator.free(new);
+        } else allocator.free(ptr);
+    }
+    {
+        const allocation = try allocator.alloc(u32, 128);
+        allocation[127] = 0;
+        const ptr: *[127:0]u32 = allocation[0..127 :0];
+        if (allocator.realloc(ptr, 16)) |new| {
+            allocator.free(new);
+        } else |_| {
+            allocator.free(allocation);
+        }
+    }
+}

lib/std/meta.zig+51-5

...	@@ -1,10 +1,9 @@	...	@@ -1,10 +1,9 @@
1	const builtin = @import("builtin");	1	const builtin = @import("builtin");
		2
2	const std = @import("std.zig");	3	const std = @import("std.zig");
3	const debug = std.debug;	4	const assert = std.debug.assert;
4	const mem = std.mem;	5	const mem = std.mem;
5	const math = std.math;
6	const testing = std.testing;	6	const testing = std.testing;
7	const root = @import("root");
8		7
9	pub const TrailerFlags = @import("meta/trailer_flags.zig").TrailerFlags;	8	pub const TrailerFlags = @import("meta/trailer_flags.zig").TrailerFlags;
10		9
...	@@ -821,8 +820,8 @@ pub fn isError(error_union: anytype) bool {	...	@@ -821,8 +820,8 @@ pub fn isError(error_union: anytype) bool {
821	}	820	}
822		821
823	test isError {	822	test isError {
824	try std.testing.expect(isError(math.divTrunc(u8, 5, 0)));	823	try std.testing.expect(isError(std.math.divTrunc(u8, 5, 0)));
825	try std.testing.expect(!isError(math.divTrunc(u8, 5, 5)));	824	try std.testing.expect(!isError(std.math.divTrunc(u8, 5, 5)));
826	}	825	}
827		826
828	/// Returns true if a type has a namespace and the namespace contains `name`;	827	/// Returns true if a type has a namespace and the namespace contains `name`;
...	@@ -1070,3 +1069,50 @@ test hasUniqueRepresentation {	...	@@ -1070,3 +1069,50 @@ test hasUniqueRepresentation {
1070		1069
1071	try testing.expect(hasUniqueRepresentation(StructWithComptimeFields));	1070	try testing.expect(hasUniqueRepresentation(StructWithComptimeFields));
1072	}	1071	}
		1072
		1073	/// Given a pointer type, type-erases the array length if present, returning an
		1074	/// equivalent pointer type that is always a slice.
		1075	pub fn Slice(comptime Pointer: type) type {
		1076	const info = @typeInfo(Pointer).pointer;
		1077	switch (info.size) {
		1078	.slice => return Pointer,
		1079	.one => {
		1080	const child_info = @typeInfo(info.child);
		1081	comptime assert(child_info == .array);
		1082	const sentinel_ptr: ?*const child_info.array.child = @ptrCast(@alignCast(child_info.array.sentinel_ptr));
		1083	return @Pointer(
		1084	.slice,
		1085	info.attrs,
		1086	child_info.array.child,
		1087	if (sentinel_ptr) \|ptr\| ptr.* else null,
		1088	);
		1089	},
		1090	else => unreachable,
		1091	}
		1092	}
		1093
		1094	/// Given a pointer type, removes the sentinel if present, returning an
		1095	/// equivalent pointer type with no sentinel
		1096	pub fn AbsorbSentinel(comptime Pointer: type) type {
		1097	const info = @typeInfo(Pointer).pointer;
		1098	switch (info.size) {
		1099	.slice => return @Pointer(.slice, info.attrs, info.child, null),
		1100	.one => {
		1101	const child_info = @typeInfo(info.child).array;
		1102	if (child_info.sentinel_ptr == null) {
		1103	return Pointer;
		1104	} else {
		1105	return @Pointer(.one, info.attrs, [child_info.len + 1]child_info.child, null);
		1106	}
		1107	},
		1108	else => unreachable,
		1109	}
		1110	}
		1111
		1112	test Slice {
		1113	try testing.expectEqual([]i32, Slice(*[10]i32));
		1114	}
		1115
		1116	test AbsorbSentinel {
		1117	try testing.expectEqual([5]u32, AbsorbSentinel([4:0]u32));
		1118	}