@zigc/lib 0.16.0-dev.3066 → 0.16.0-dev.3091

package/c/math.zig

@@ -59,6 +59,7 @@ comptime {
         symbol(&cosh, "cosh");
         symbol(&exp10, "exp10");
         symbol(&exp10f, "exp10f");
+        symbol(&fdim, "fdim");
         symbol(&hypot, "hypot");
         symbol(&modf, "modf");
         symbol(&pow, "pow");
@@ -147,6 +148,19 @@ fn exp10f(x: f32) callconv(.c) f32 {
     return math.pow(f32, 10.0, x);
 }
 
+fn fdim(x: f64, y: f64) callconv(.c) f64 {
+    if (math.isNan(x)) {
+        return x;
+    }
+    if (math.isNan(y)) {
+        return y;
+    }
+    if (x > y) {
+        return x - y;
+    }
+    return 0;
+}
+
 fn hypot(x: f64, y: f64) callconv(.c) f64 {
     return math.hypot(x, y);
 }

package/c/stropts.zig

@@ -0,0 +1,17 @@
+const builtin = @import("builtin");
+
+const std = @import("std");
+const linux = std.os.linux;
+
+const symbol = @import("../c.zig").symbol;
+const errno = @import("../c.zig").errno;
+
+comptime {
+    if (builtin.target.isMuslLibC()) {
+        symbol(&isastream, "isastream");
+    }
+}
+
+fn isastream(fd: c_int) callconv(.c) c_int {
+    return if (errno(linux.fcntl(fd, linux.F.GETFD, 0)) < 0) -1 else 0;
+}

package/c.zig

@@ -73,6 +73,7 @@ comptime {
     _ = @import("c/stdlib.zig");
     _ = @import("c/string.zig");
     _ = @import("c/strings.zig");
+    _ = @import("c/stropts.zig");
 
     _ = @import("c/sys/capability.zig");
     _ = @import("c/sys/file.zig");

package/compiler_rt/limb64.zig

@@ -0,0 +1,266 @@
+const std = @import("std");
+const testing = std.testing;
+const assert = std.debug.assert;
+const maxInt = std.math.maxInt;
+const minInt = std.math.minInt;
+const divCeil = std.math.divCeil;
+
+const builtin = @import("builtin");
+const compiler_rt = @import("../compiler_rt.zig");
+
+const endian = builtin.cpu.arch.endian();
+
+inline fn limbGet(limbs: []const u64, i: usize) u64 {
+    return switch (endian) {
+        .little => limbs[i],
+        .big => limbs[limbs.len - 1 - i],
+    };
+}
+
+inline fn limbSet(limbs: []u64, i: usize, value: u64) void {
+    switch (endian) {
+        .little => limbs[i] = value,
+        .big => limbs[limbs.len - 1 - i] = value,
+    }
+}
+
+fn limbCount(bits: u16) u16 {
+    return divCeil(u16, bits, 64) catch unreachable;
+}
+
+fn Limbs(T: type) type {
+    const int_info = @typeInfo(T).int;
+    const limb_cnt = comptime limbCount(int_info.bits);
+    return [limb_cnt]u64;
+}
+
+fn asLimbs(v: anytype) Limbs(@TypeOf(v)) {
+    const T = @TypeOf(v);
+    const int_info = @typeInfo(T).int;
+    const limb_cnt = comptime limbCount(int_info.bits);
+    const ET = @Int(int_info.signedness, limb_cnt * 64);
+    return @bitCast(@as(ET, v));
+}
+
+fn limbWrap(limb: u64, is_signed: bool, bits: u16) u64 {
+    assert(bits % 64 != 0);
+    const pad_bits: u6 = @intCast(64 - bits % 64);
+    if (!is_signed) {
+        const s = limb << pad_bits;
+        return s >> pad_bits;
+    } else {
+        const s = @as(i64, @bitCast(limb)) << pad_bits;
+        return @bitCast(s >> pad_bits);
+    }
+}
+
+comptime {
+    @export(&__addo_limb64, .{ .name = "__addo_limb64", .linkage = compiler_rt.linkage, .visibility = compiler_rt.visibility });
+}
+
+fn __addo_limb64(out_ptr: [*]u64, a_ptr: [*]const u64, b_ptr: [*]const u64, is_signed: bool, bits: u16) callconv(.c) bool {
+    const limb_cnt = limbCount(bits);
+    const out = out_ptr[0..limb_cnt];
+    const a = a_ptr[0..limb_cnt];
+    const b = b_ptr[0..limb_cnt];
+
+    var carry: u1 = 0;
+    var i: usize = 0;
+    while (i < limb_cnt - 1) : (i += 1) {
+        const s1 = @addWithOverflow(limbGet(a, i), limbGet(b, i));
+        const s2 = @addWithOverflow(s1[0], carry);
+        carry = s1[1] | s2[1];
+        limbSet(out, i, s2[0]);
+    }
+
+    const limb: u64 = b: {
+        if (!is_signed) {
+            const s1 = @addWithOverflow(limbGet(a, i), limbGet(b, i));
+            const s2 = @addWithOverflow(s1[0], carry);
+            carry = s1[1] | s2[1];
+            break :b s2[0];
+        } else {
+            const as: i64 = @bitCast(limbGet(a, i));
+            const bs: i64 = @bitCast(limbGet(b, i));
+            const s1 = @addWithOverflow(as, bs);
+            const s2 = @addWithOverflow(s1[0], carry);
+            carry = s1[1] | s2[1];
+            break :b @bitCast(s2[0]);
+        }
+    };
+
+    if (bits % 64 == 0) {
+        limbSet(out, i, limb);
+        return carry != 0;
+    } else {
+        assert(carry == 0);
+        const wrapped_limb = limbWrap(limb, is_signed, bits);
+        limbSet(out, i, wrapped_limb);
+        return wrapped_limb != limb;
+    }
+}
+
+fn test__addo_limb64(comptime T: type, a: T, b: T, expected: struct { T, bool }) !void {
+    const int_info = @typeInfo(T).int;
+    const is_signed = int_info.signedness == .signed;
+
+    var a_limbs = asLimbs(a);
+    var b_limbs = asLimbs(b);
+    var out: Limbs(T) = undefined;
+    const overflow = __addo_limb64(&out, &a_limbs, &b_limbs, is_signed, int_info.bits);
+
+    const expected_limbs = asLimbs(expected[0]);
+    try testing.expectEqual(expected_limbs, out);
+    try testing.expectEqual(expected[1], overflow);
+}
+
+test __addo_limb64 {
+    try test__addo_limb64(u64, 1, 2, .{ 3, false });
+    try test__addo_limb64(u64, maxInt(u64), 2, .{ 1, true });
+    try test__addo_limb64(u65, maxInt(u65), 2, .{ 1, true });
+    try test__addo_limb64(u255, 1, 2, .{ 3, false });
+
+    try test__addo_limb64(i64, 1, 2, .{ 3, false });
+    try test__addo_limb64(i64, maxInt(i64), 1, .{ minInt(i64), true });
+    try test__addo_limb64(i65, maxInt(i65), 1, .{ minInt(i65), true });
+    try test__addo_limb64(i255, -3, 2, .{ -1, false });
+}
+
+comptime {
+    @export(&__subo_limb64, .{ .name = "__subo_limb64", .linkage = compiler_rt.linkage, .visibility = compiler_rt.visibility });
+}
+
+fn __subo_limb64(out_ptr: [*]u64, a_ptr: [*]const u64, b_ptr: [*]const u64, is_signed: bool, bits: u16) callconv(.c) bool {
+    const limb_cnt = limbCount(bits);
+    const out = out_ptr[0..limb_cnt];
+    const a = a_ptr[0..limb_cnt];
+    const b = b_ptr[0..limb_cnt];
+
+    var borrow: u1 = 0;
+    var i: usize = 0;
+    while (i < limb_cnt - 1) : (i += 1) {
+        const s1 = @subWithOverflow(limbGet(a, i), limbGet(b, i));
+        const s2 = @subWithOverflow(s1[0], borrow);
+        borrow = s1[1] | s2[1];
+        limbSet(out, i, s2[0]);
+    }
+
+    const limb: u64 = b: {
+        if (!is_signed) {
+            const s1 = @subWithOverflow(limbGet(a, i), limbGet(b, i));
+            const s2 = @subWithOverflow(s1[0], borrow);
+            borrow = s1[1] | s2[1];
+            break :b s2[0];
+        } else {
+            const as: i64 = @bitCast(limbGet(a, i));
+            const bs: i64 = @bitCast(limbGet(b, i));
+            const s1 = @subWithOverflow(as, bs);
+            const s2 = @subWithOverflow(s1[0], borrow);
+            borrow = s1[1] | s2[1];
+            break :b @bitCast(s2[0]);
+        }
+    };
+
+    if (bits % 64 == 0) {
+        limbSet(out, i, limb);
+        return borrow != 0;
+    } else {
+        const wrapped_limb = limbWrap(limb, is_signed, bits);
+        limbSet(out, i, wrapped_limb);
+        return borrow != 0 or wrapped_limb != limb;
+    }
+}
+
+fn test__subo_limb64(comptime T: type, a: T, b: T, expected: struct { T, bool }) !void {
+    const int_info = @typeInfo(T).int;
+    const is_signed = int_info.signedness == .signed;
+
+    var a_limbs = asLimbs(a);
+    var b_limbs = asLimbs(b);
+    var out: Limbs(T) = undefined;
+    const overflow = __subo_limb64(&out, &a_limbs, &b_limbs, is_signed, int_info.bits);
+
+    const expected_limbs = asLimbs(expected[0]);
+    try testing.expectEqual(expected_limbs, out);
+    try testing.expectEqual(expected[1], overflow);
+}
+
+test __subo_limb64 {
+    try test__subo_limb64(u64, 3, 2, .{ 1, false });
+    try test__subo_limb64(u64, 0, 1, .{ maxInt(u64), true });
+    try test__subo_limb64(u65, 0, 1, .{ maxInt(u65), true });
+    try test__subo_limb64(u255, 3, 2, .{ 1, false });
+
+    try test__subo_limb64(i64, 1, 2, .{ -1, false });
+    try test__subo_limb64(i64, minInt(i64), 1, .{ maxInt(i64), true });
+    try test__subo_limb64(i65, minInt(i65), 1, .{ maxInt(i65), true });
+    try test__subo_limb64(i255, -1, 2, .{ -3, false });
+}
+
+comptime {
+    @export(&__cmp_limb64, .{ .name = "__cmp_limb64", .linkage = compiler_rt.linkage, .visibility = compiler_rt.visibility });
+}
+
+// a < b  -> -1
+// a == b ->  0
+// a > b  ->  1
+fn __cmp_limb64(a_ptr: [*]const u64, b_ptr: [*]const u64, is_signed: bool, bits: u16) callconv(.c) i8 {
+    const limb_cnt = limbCount(bits);
+    const a = a_ptr[0..limb_cnt];
+    const b = b_ptr[0..limb_cnt];
+
+    var i: usize = 0;
+    if (is_signed) {
+        const sa: i64 = @bitCast(limbGet(a, limb_cnt - 1));
+        const sb: i64 = @bitCast(limbGet(b, limb_cnt - 1));
+        if (sa < sb) return -1;
+        if (sa > sb) return 1;
+        i += 1;
+    }
+
+    while (i < limb_cnt) : (i += 1) {
+        const ai = limbGet(a, limb_cnt - 1 - i);
+        const bi = limbGet(b, limb_cnt - 1 - i);
+        if (ai < bi) return -1;
+        if (ai > bi) return 1;
+    }
+
+    return 0;
+}
+
+fn test__cmp_limb64(comptime T: type, a: T, b: T, expected: i8) !void {
+    const int_info = @typeInfo(T).int;
+    const is_signed = int_info.signedness == .signed;
+
+    var a_limbs = asLimbs(a);
+    var b_limbs = asLimbs(b);
+    const actual = __cmp_limb64(&a_limbs, &b_limbs, is_signed, int_info.bits);
+
+    try testing.expectEqual(expected, actual);
+}
+
+test __cmp_limb64 {
+    try test__cmp_limb64(u64, 1, 2, -1);
+    try test__cmp_limb64(u64, 2, 2, 0);
+    try test__cmp_limb64(u64, 3, 2, 1);
+
+    try test__cmp_limb64(u65, 1, 2, -1);
+    try test__cmp_limb64(u65, maxInt(u65), maxInt(u65), 0);
+    try test__cmp_limb64(u65, maxInt(u65), maxInt(u65) - 1, 1);
+
+    try test__cmp_limb64(u255, 1, 2, -1);
+    try test__cmp_limb64(u255, 7, 7, 0);
+    try test__cmp_limb64(u255, maxInt(u255), maxInt(u255) - 1, 1);
+
+    try test__cmp_limb64(i64, -1, 0, -1);
+    try test__cmp_limb64(i64, 0, 0, 0);
+    try test__cmp_limb64(i64, 1, 0, 1);
+
+    try test__cmp_limb64(i65, minInt(i65), maxInt(i65), -1);
+    try test__cmp_limb64(i65, -1, -1, 0);
+    try test__cmp_limb64(i65, maxInt(i65), minInt(i65), 1);
+
+    try test__cmp_limb64(i255, -3, 2, -1);
+    try test__cmp_limb64(i255, -5, -5, 0);
+    try test__cmp_limb64(i255, 2, -3, 1);
+}

package/compiler_rt.zig

@@ -279,6 +279,8 @@ comptime {
     _ = @import("compiler_rt/divmodei4.zig");
     _ = @import("compiler_rt/udivmodei4.zig");
 
+    _ = @import("compiler_rt/limb64.zig");
+
     // extra
     _ = @import("compiler_rt/os_version_check.zig");
     _ = @import("compiler_rt/emutls.zig");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zigc/lib",
-  "version": "0.16.0-dev.3066",
+  "version": "0.16.0-dev.3091",
   "description": "Zig standard library and libc headers (shared across all platforms)",
   "repository": {
     "type": "git",

package/std/Build/Module.zig

@@ -596,7 +596,7 @@ pub fn appendZigProcessFlags(
                 "-target", try target.query.zigTriple(b.allocator),
                 "-mcpu",   try target.query.serializeCpuAlloc(b.allocator),
             });
-            if (target.query.dynamic_linker) |dynamic_linker| {
+            if (target.query.dynamic_linker) |*dynamic_linker| {
                 if (dynamic_linker.get()) |dynamic_linker_path| {
                     try zig_args.append("--dynamic-linker");
                     try zig_args.append(dynamic_linker_path);

package/std/Build/WebServer.zig

@@ -6,7 +6,7 @@ root_prog_node: std.Progress.Node,
 watch: bool,
 
 tcp_server: ?net.Server,
-serve_thread: ?std.Thread,
+serve_task: ?Io.Future(Io.Cancelable!void),
 
 /// Uses `Io.Clock.awake`.
 base_timestamp: Io.Timestamp,
@@ -103,7 +103,7 @@ pub fn init(opts: Options) WebServer {
         .watch = opts.watch,
 
         .tcp_server = null,
-        .serve_thread = null,
+        .serve_task = null,
 
         .base_timestamp = opts.base_timestamp.raw,
         .step_names_trailing = step_names_trailing,
@@ -136,9 +136,9 @@ pub fn deinit(ws: *WebServer) void {
     gpa.free(ws.time_report_msgs);
     gpa.free(ws.time_report_update_times);
 
-    if (ws.serve_thread) |t| {
+    if (ws.serve_task) |t| {
         if (ws.tcp_server) |*s| s.stream.close(io);
-        t.join();
+        t.await();
     }
     if (ws.tcp_server) |*s| s.deinit();
 
@@ -146,15 +146,15 @@ pub fn deinit(ws: *WebServer) void {
 }
 pub fn start(ws: *WebServer) error{AlreadyReported}!void {
     assert(ws.tcp_server == null);
-    assert(ws.serve_thread == null);
+    assert(ws.serve_task == null);
     const io = ws.graph.io;
 
     ws.tcp_server = ws.listen_address.listen(io, .{ .reuse_address = true }) catch |err| {
-        log.err("failed to listen to port {d}: {s}", .{ ws.listen_address.getPort(), @errorName(err) });
+        log.err("failed to listen to port {d}: {t}", .{ ws.listen_address.getPort(), err });
         return error.AlreadyReported;
     };
-    ws.serve_thread = std.Thread.spawn(.{}, serve, .{ws}) catch |err| {
-        log.err("unable to spawn web server thread: {s}", .{@errorName(err)});
+    ws.serve_task = io.concurrent(serve, .{ws}) catch |err| {
+        log.err("unable to spawn web server thread: {t}", .{err});
         ws.tcp_server.?.deinit(io);
         ws.tcp_server = null;
         return error.AlreadyReported;
@@ -165,15 +165,20 @@ pub fn start(ws: *WebServer) error{AlreadyReported}!void {
         log.info("hint: pass '--webui={f}' to use the same port next time", .{ws.tcp_server.?.socket.address});
     }
 }
-fn serve(ws: *WebServer) void {
+fn serve(ws: *WebServer) Io.Cancelable!void {
     const io = ws.graph.io;
+    var group: Io.Group = .init;
+    defer group.cancel(io);
     while (true) {
-        var stream = ws.tcp_server.?.accept(io) catch |err| {
-            log.err("failed to accept connection: {s}", .{@errorName(err)});
-            return;
+        var stream = ws.tcp_server.?.accept(io) catch |err| switch (err) {
+            error.Canceled => |e| return e,
+            else => |e| {
+                log.err("failed to accept connection: {t}", .{e});
+                return;
+            },
         };
-        _ = std.Thread.spawn(.{}, accept, .{ ws, stream }) catch |err| {
-            log.err("unable to spawn connection thread: {s}", .{@errorName(err)});
+        group.concurrent(io, accept, .{ ws, stream }) catch |err| {
+            log.err("unable to spawn connection thread: {t}", .{err});
             stream.close(io);
             continue;
         };
@@ -303,8 +308,8 @@ fn serveWebSocket(ws: *WebServer, sock: *http.Server.WebSocket) !noreturn {
         copy.* = @atomicLoad(u8, shared, .monotonic);
     }
 
-    const recv_thread = try std.Thread.spawn(.{}, recvWebSocketMessages, .{ ws, sock });
-    defer recv_thread.join();
+    var recv_thread = try io.concurrent(recvWebSocketMessages, .{ ws, sock });
+    defer recv_thread.cancel(io);
 
     {
         const hello_header: abi.Hello = .{

package/std/Build/abi.zig

@@ -235,7 +235,8 @@ pub const fuzz = struct {
         max: u64,
         weight: u64,
 
-        fn intFromValue(x: anytype) u64 {
+        /// `inline` to propogate comptimeness
+        inline fn intFromValue(x: anytype) u64 {
             const T = @TypeOf(x);
             return switch (@typeInfo(T)) {
                 .comptime_int => x,
@@ -269,11 +270,13 @@ pub const fuzz = struct {
             };
         }
 
-        pub fn value(T: type, x: T, weight: u64) Weight {
+        /// `inline` to propogate comptimeness
+        pub inline fn value(T: type, x: T, weight: u64) Weight {
             return .{ .min = intFromValue(x), .max = intFromValue(x), .weight = weight };
         }
 
-        pub fn rangeAtMost(T: type, at_least: T, at_most: T, weight: u64) Weight {
+        /// `inline` to propogate comptimeness
+        pub inline fn rangeAtMost(T: type, at_least: T, at_most: T, weight: u64) Weight {
             std.debug.assert(intFromValue(at_least) <= intFromValue(at_most));
             return .{
                 .min = intFromValue(at_least),
@@ -282,7 +285,8 @@ pub const fuzz = struct {
             };
         }
 
-        pub fn rangeLessThan(T: type, at_least: T, less_than: T, weight: u64) Weight {
+        /// `inline` to propogate comptimeness
+        pub inline fn rangeLessThan(T: type, at_least: T, less_than: T, weight: u64) Weight {
             std.debug.assert(intFromValue(at_least) < intFromValue(less_than));
             return .{
                 .min = intFromValue(at_least),

package/std/Io/Dispatch.zig

@@ -2512,6 +2512,7 @@ fn dirCreateFile(
             .OPNOTSUPP => return error.FileLocksUnsupported,
             .AGAIN => return error.WouldBlock,
             .TXTBSY => return error.FileBusy,
+            .ROFS => return error.ReadOnlyFileSystem,
             .NXIO => return error.NoDevice,
             .ILSEQ => return error.BadPathName,
             else => |err| return unexpectedErrno(err),
@@ -2647,6 +2648,7 @@ fn dirOpenFile(
             .AGAIN => return error.WouldBlock,
             .TXTBSY => return error.FileBusy,
             .NXIO => return error.NoDevice,
+            .ROFS => return error.ReadOnlyFileSystem,
             .ILSEQ => return error.BadPathName,
             else => |err| return unexpectedErrno(err),
         }

package/std/Io/File.zig

@@ -202,6 +202,7 @@ pub const OpenError = error{
     NotDir,
     /// The path already exists and the `CREAT` and `EXCL` flags were provided.
     PathAlreadyExists,
+    ReadOnlyFileSystem,
     DeviceBusy,
     FileLocksUnsupported,
     /// One of these three things:

package/std/Io/Threaded.zig

@@ -4290,6 +4290,7 @@ fn dirCreateFilePosix(
                         .AGAIN => return error.WouldBlock,
                         .TXTBSY => return error.FileBusy,
                         .NXIO => return error.NoDevice,
+                        .ROFS => return error.ReadOnlyFileSystem,
                         .ILSEQ => return error.BadPathName,
                         else => |err| return posix.unexpectedErrno(err),
                     }
@@ -4871,6 +4872,7 @@ fn dirOpenFilePosix(
                         .AGAIN => return error.WouldBlock,
                         .TXTBSY => return error.FileBusy,
                         .NXIO => return error.NoDevice,
+                        .ROFS => return error.ReadOnlyFileSystem,
                         .ILSEQ => return error.BadPathName,
                         else => |err| return posix.unexpectedErrno(err),
                     }

package/std/Io/Uring.zig

@@ -5673,6 +5673,7 @@ fn openat(
             .AGAIN => return error.WouldBlock,
             .TXTBSY => return error.FileBusy,
             .NXIO => return error.NoDevice,
+            .ROFS => return error.ReadOnlyFileSystem,
             .ILSEQ => return error.BadPathName,
             else => |err| return unexpectedErrno(err),
         }

package/std/array_list.zig

@@ -857,16 +857,8 @@ pub fn Aligned(comptime T: type, comptime alignment: ?mem.Alignment) type {
             len: usize,
             new_items: []const T,
         ) Allocator.Error!void {
-            const after_range = start + len;
-            const range = self.items[start..after_range];
-            if (range.len < new_items.len) {
-                const first = new_items[0..range.len];
-                const rest = new_items[range.len..];
-                @memcpy(range[0..first.len], first);
-                try self.insertSlice(gpa, after_range, rest);
-            } else {
-                self.replaceRangeAssumeCapacity(start, len, new_items);
-            }
+            try self.ensureTotalCapacity(gpa, try addOrOom(self.items.len - len, new_items.len));
+            self.replaceRangeAssumeCapacity(start, len, new_items);
         }
 
         /// Grows or shrinks the list as necessary.
@@ -874,26 +866,20 @@ pub fn Aligned(comptime T: type, comptime alignment: ?mem.Alignment) type {
         /// Never invalidates element pointers.
         ///
         /// Asserts the capacity is enough for additional items.
-        pub fn replaceRangeAssumeCapacity(self: *Self, start: usize, len: usize, new_items: []const T) void {
-            const after_range = start + len;
-            const range = self.items[start..after_range];
-
-            if (range.len == new_items.len)
-                @memcpy(range[0..new_items.len], new_items)
-            else if (range.len < new_items.len) {
-                const first = new_items[0..range.len];
-                const rest = new_items[range.len..];
-                @memcpy(range[0..first.len], first);
-                const dst = self.addManyAtAssumeCapacity(after_range, rest.len);
-                @memcpy(dst, rest);
-            } else {
-                const extra = range.len - new_items.len;
-                @memcpy(range[0..new_items.len], new_items);
-                const src = self.items[after_range..];
-                @memmove(self.items[after_range - extra ..][0..src.len], src);
-                @memset(self.items[self.items.len - extra ..], undefined);
-                self.items.len -= extra;
-            }
+        pub fn replaceRangeAssumeCapacity(
+            self: *Self,
+            start: usize,
+            len: usize,
+            new_items: []const T,
+        ) void {
+            std.debug.assert(self.capacity - self.items.len >= new_items.len -| len);
+
+            const tail = self.items[start + len ..];
+            const vacated = self.items[self.items.len - (len -| new_items.len) ..];
+            self.items.len = self.items.len - len + new_items.len;
+            @memmove(self.items[start + new_items.len ..], tail);
+            @memcpy(self.items[start..][0..new_items.len], new_items);
+            @memset(vacated, undefined);
         }
 
         /// Grows or shrinks the list as necessary.
@@ -902,7 +888,12 @@ pub fn Aligned(comptime T: type, comptime alignment: ?mem.Alignment) type {
         ///
         /// If the unused capacity is insufficient for additional items,
         /// returns `error.OutOfMemory`.
-        pub fn replaceRangeBounded(self: *Self, start: usize, len: usize, new_items: []const T) error{OutOfMemory}!void {
+        pub fn replaceRangeBounded(
+            self: *Self,
+            start: usize,
+            len: usize,
+            new_items: []const T,
+        ) error{OutOfMemory}!void {
             if (self.capacity - self.items.len < new_items.len -| len) return error.OutOfMemory;
             return replaceRangeAssumeCapacity(self, start, len, new_items);
         }

package/std/debug/SelfInfo/Windows.zig

@@ -360,6 +360,7 @@ const Module = struct {
                 error.SystemFdQuotaExceeded,
                 error.FileLocksUnsupported,
                 error.FileBusy,
+                error.ReadOnlyFileSystem,
                 => return error.ReadFailed,
             };
             errdefer coff_file.close(io);

package/std/testing/Smith.zig

@@ -205,6 +205,24 @@ pub noinline fn valueRangeLessThan(s: *Smith, T: type, at_least: T, less_than: T
     return s.valueRangeLessThanWithHash(T, at_least, less_than, firstHash());
 }
 
+/// It is asserted `len` is nonzero.
+/// It is asserted `len` fits within 64 bits.
+//
+// `noinline` to capture a unique return address
+pub noinline fn index(s: *Smith, len: usize) usize {
+    @disableInstrumentation();
+    return s.indexWithHash(len, firstHash());
+}
+
+/// It is asserted that the weight of `false` is non-zero.
+/// It is asserted that the weight of `true` is non-zero.
+//
+// `noinline` to capture a unique return address
+pub noinline fn boolWeighted(s: *Smith, false_weight: u64, true_weight: u64) bool {
+    @disableInstrumentation();
+    return s.boolWeightedWithHash(false_weight, true_weight, firstHash());
+}
+
 /// This is similar to `value(bool)` however it is gauraunteed to eventually
 /// return `true` and provides the fuzzer with an extra hint about the data.
 //
@@ -228,6 +246,7 @@ pub noinline fn eosWeighted(s: *Smith, weights: []const Weight) bool {
 /// This is similar to `value(bool)` however it is gauraunteed to eventually
 /// return `true` and provides the fuzzer with an extra hint about the data.
 ///
+/// It is asserted that the weight of `false` is non-zero.
 /// It is asserted that the weight of `true` is non-zero.
 //
 // `noinline` to capture a unique return address
@@ -463,6 +482,24 @@ pub fn valueRangeLessThanWithHash(s: *Smith, T: type, at_least: T, less_than: T,
     return s.valueWeightedWithHash(T, &.{.rangeLessThan(T, at_least, less_than, 1)}, hash);
 }
 
+/// It is asserted `len` is nonzero.
+/// It is asserted `len` fits within 64 bits.
+pub fn indexWithHash(s: *Smith, len: usize, hash: u32) usize {
+    @disableInstrumentation();
+    assert(len != 0);
+    return @intCast(s.valueWeightedWithHash(u64, &.{.rangeLessThan(u64, 0, @intCast(len), 1)}, hash));
+}
+
+/// It is asserted that the weight of `false` is non-zero.
+/// It is asserted that the weight of `true` is non-zero.
+pub fn boolWeightedWithHash(s: *Smith, false_weight: u64, true_weight: u64, hash: u32) bool {
+    @disableInstrumentation();
+    return s.valueWeightedWithHash(bool, &.{
+        .value(bool, false, false_weight),
+        .value(bool, true, true_weight),
+    }, hash);
+}
+
 /// This is similar to `value(bool)` however it is gauraunteed to eventually
 /// return `true` and provides the fuzzer with an extra hint about the data.
 pub fn eosWithHash(s: *Smith, hash: u32) bool {
@@ -504,8 +541,6 @@ pub fn eosWeightedWithHash(s: *Smith, weights: []const Weight, hash: u32) bool {
 ///
 /// It is asserted that the weight of `false` is non-zero.
 /// It is asserted that the weight of `true` is non-zero.
-//
-// `noinline` to capture a unique return address
 pub fn eosWeightedSimpleWithHash(s: *Smith, false_weight: u64, true_weight: u64, hash: u32) bool {
     @disableInstrumentation();
     return s.eosWeightedWithHash(&.{