@zigc/lib 0.17.0-dev.44 → 0.17.0-dev.607

package/std/Io/Writer.zig

@@ -781,7 +781,7 @@ test splatByteAll {
     defer aw.deinit();
 
     try aw.writer.splatByteAll('7', 45);
-    try testing.expectEqualStrings("7" ** 45, aw.writer.buffered());
+    try testing.expectEqualStrings(&@as([45]u8, @splat('7')), aw.writer.buffered());
 }
 
 pub fn splatBytePreserve(w: *Writer, preserve: usize, byte: u8, n: usize) Error!void {
@@ -802,12 +802,14 @@ pub fn splatBytePreserve(w: *Writer, preserve: usize, byte: u8, n: usize) Error!
             return;
         }
     }
-    // All the next bytes received must be preserved.
-    if (preserve < w.end) {
-        @memmove(w.buffer[0..preserve], w.buffer[w.end - preserve ..][0..preserve]);
-        w.end = preserve;
-    }
-    while (remaining > 0) remaining -= try w.splatByte(byte, remaining);
+    // Ensure the contract of `rebase` is upheld.
+    assert(w.end + remaining > w.buffer.len);
+    // Offset the amount preserved by the amount we have left to splat
+    // since the remaining splat is always going to be part of that
+    // preservation.
+    try w.vtable.rebase(w, preserve -| remaining, remaining);
+    @memset(w.buffer[w.end..][0..remaining], byte);
+    w.end += remaining;
 }
 
 /// Writes the same byte many times, allowing short writes.
@@ -1170,6 +1172,14 @@ pub fn printValue(
                 },
                 else => invalidFmtError(fmt, value),
             },
+            'q' => switch (@typeInfo(T)) {
+                .pointer => |info| switch (info.size) {
+                    .one, .slice => return printStringEscaped(w, value),
+                    .many, .c => return printStringEscaped(w, std.mem.span(value)),
+                },
+                .array => return printStringEscaped(w, &value),
+                else => invalidFmtError(fmt, value),
+            },
             'B' => switch (@typeInfo(T)) {
                 .int, .comptime_int => return w.printByteSize(value, .decimal, options),
                 .@"struct" => return value.formatByteSize(w, .decimal),
@@ -1446,6 +1456,14 @@ fn printEnumNonexhaustive(w: *Writer, value: anytype) Error!void {
     try w.writeByte(')');
 }
 
+/// Prints a double quote, then escapes a string according to Zig string
+/// literal rules, then a double quote.
+pub fn printStringEscaped(w: *Writer, bytes: []const u8) Error!void {
+    try w.writeByte('"');
+    try std.zig.stringEscape(bytes, w);
+    try w.writeByte('"');
+}
+
 pub fn printVector(
     w: *Writer,
     comptime fmt: []const u8,
@@ -1517,7 +1535,7 @@ pub fn printIntAny(
     // The type must have the same size as `base` or be wider in order for the
     // division to work
     const min_int_bits = comptime @max(value_info.bits, 8);
-    const MinInt = std.meta.Int(.unsigned, min_int_bits);
+    const MinInt = @Int(.unsigned, min_int_bits);
 
     const abs_value = @abs(value);
     // The worst case in terms of space needed is base 2, plus 1 for the sign
@@ -1637,7 +1655,7 @@ pub fn printFloatHex(w: *Writer, value: anytype, case: std.fmt.Case, opt_precisi
     });
 
     const T = @TypeOf(v);
-    const TU = std.meta.Int(.unsigned, @bitSizeOf(T));
+    const TU = @Int(.unsigned, @bitSizeOf(T));
 
     const mantissa_bits = std.math.floatMantissaBits(T);
     const fractional_bits = std.math.floatFractionalBits(T);
@@ -1924,7 +1942,6 @@ test "serialize signed LEB128" {
     try testLeb128Encoding(i128, std.math.minInt(i128), "\x80\x80\x80\x80\x80\x80\x80\x80\x80\x80\x80\x80\x80\x80\x80\x80\x80\x80\x7E");
 
     // Specific cases
-    try testLeb128Encoding(i0, 0, "\x00");
     try testLeb128Encoding(i8, 0, "\x00");
 
     try testLeb128Encoding(i2, -1, "\x7F");
@@ -2101,6 +2118,11 @@ test "printFloat with comptime_float" {
     try testing.expectFmt("1", "{}", .{1.0});
 }
 
+test "{q} format string" {
+    const data: []const u8 = "i\tlike\"cheese\x00\x05cheese";
+    try testing.expectFmt("hello \"i\\tlike\\\"cheese\\x00\\x05cheese\" world", "hello {q} world", .{data});
+}
+
 fn testPrintIntCase(expected: []const u8, value: anytype, base: u8, case: std.fmt.Case, options: std.fmt.Options) !void {
     var buffer: [100]u8 = undefined;
     var w: Writer = .fixed(&buffer);
@@ -2888,3 +2910,46 @@ test "writableSlice with fixed writer" {
     try w.writeByte(1);
     try std.testing.expectError(error.WriteFailed, w.writableSlice(2));
 }
+
+test splatBytePreserve {
+    try testSplatBytePreserve(.{ .buf_len = 10, .fill_len = 5, .preserve = 5, .splat_len = 5 });
+    try testSplatBytePreserve(.{ .buf_len = 10, .fill_len = 9, .preserve = 5, .splat_len = 2 });
+    try testSplatBytePreserve(.{ .buf_len = 10, .fill_len = 5, .preserve = 5, .splat_len = 6 });
+    try testSplatBytePreserve(.{ .buf_len = 10, .fill_len = 5, .preserve = 6, .splat_len = 6 });
+    try testSplatBytePreserve(.{ .buf_len = 10, .fill_len = 5, .preserve = 5, .splat_len = 10 });
+    try testSplatBytePreserve(.{ .buf_len = 10, .fill_len = 5, .preserve = 6, .splat_len = 10 });
+    try testSplatBytePreserve(.{ .buf_len = 10, .fill_len = 5, .preserve = 6, .splat_len = 11 });
+    try testSplatBytePreserve(.{ .buf_len = 10, .fill_len = 5, .preserve = 6, .splat_len = 80 });
+    try testSplatBytePreserve(.{ .buf_len = 10, .fill_len = 5, .preserve = 6, .splat_len = 85 });
+    try testSplatBytePreserve(.{ .buf_len = 10, .fill_len = 5, .preserve = 10, .splat_len = 6 });
+    try testSplatBytePreserve(.{ .buf_len = 10, .fill_len = 5, .preserve = 10, .splat_len = 11 });
+    try testSplatBytePreserve(.{ .buf_len = 10, .fill_len = 5, .preserve = 10, .splat_len = 80 });
+    try testSplatBytePreserve(.{ .buf_len = 10, .fill_len = 5, .preserve = 10, .splat_len = 85 });
+}
+
+fn testSplatBytePreserve(options: struct { buf_len: u4, fill_len: u4, preserve: u4, splat_len: u8 }) !void {
+    assert(options.fill_len <= options.buf_len);
+    assert(options.preserve <= options.buf_len);
+
+    const fill_buf = "abcdefghijklmno";
+    const fill = fill_buf[0..options.fill_len];
+    var expected_out_buf: [256]u8 = @splat('X');
+    @memcpy(expected_out_buf[0..options.fill_len], fill);
+    const expected_out = expected_out_buf[0 .. options.fill_len + options.splat_len];
+    const expected_preserved = expected_out[expected_out.len -| options.preserve..];
+
+    var out_buf: [256]u8 = undefined;
+    var fw: Writer = .fixed(&out_buf);
+    var indirect_buffer: [16]u8 = undefined;
+    var twi: std.testing.WriterIndirect = .init(&fw, indirect_buffer[0..options.buf_len]);
+    const w = &twi.interface;
+
+    try w.writeAll(fill);
+    try w.splatBytePreserve(options.preserve, 'X', options.splat_len);
+
+    try std.testing.expectEqualStrings(expected_preserved, w.buffer[w.end -| options.preserve..w.end]);
+
+    try w.flush();
+
+    try std.testing.expectEqualStrings(expected_out, fw.buffer[0..fw.end]);
+}

package/std/Io/net/HostName.zig

@@ -76,9 +76,14 @@ test validate {
     try validate("a-b.com");
     try validate("a.b.c.d.e.f.g");
     try validate("127.0.0.1"); // Also a valid hostname
-    try validate("a" ** 63 ++ ".com"); // Label exactly 63 chars (valid)
-    try validate("a." ** 127 ++ "a"); // Total length 255 (valid)
-    try validate("a." ** 127 ++ "a."); // Total length 255 + trailing dot (valid)
+
+    const many_a: [63]u8 = @splat('a');
+    try validate(&many_a ++ ".com"); // Label exactly 63 chars (valid)
+
+    const many_a_dot_buf: [127][2]u8 = @splat(.{ 'a', '.' });
+    const many_a_dot: []const u8 = @ptrCast(&many_a_dot_buf);
+    try validate(many_a_dot ++ "a"); // Total length 255 (valid)
+    try validate(many_a_dot ++ "a."); // Total length 255 + trailing dot (valid)
 
     // Invalid hostnames
     try std.testing.expectError(error.InvalidHostName, validate(""));
@@ -92,9 +97,9 @@ test validate {
     try std.testing.expectError(error.InvalidHostName, validate("host_name.com"));
     try std.testing.expectError(error.InvalidHostName, validate("."));
     try std.testing.expectError(error.InvalidHostName, validate(".."));
-    try std.testing.expectError(error.InvalidHostName, validate("a" ** 64 ++ ".com")); // Label length 64 (too long)
-    try std.testing.expectError(error.NameTooLong, validate("a." ** 127 ++ "ab")); // Total length 256 (too long)
-    try std.testing.expectError(error.NameTooLong, validate("a." ** 127 ++ "ab.")); // Total length 256 + trailing dot (too long)
+    try std.testing.expectError(error.InvalidHostName, validate(&many_a ++ "a.com")); // Label length 64 (too long)
+    try std.testing.expectError(error.NameTooLong, validate(many_a_dot ++ "ab")); // Total length 256 (too long)
+    try std.testing.expectError(error.NameTooLong, validate(many_a_dot ++ "ab.")); // Total length 256 + trailing dot (too long)
 }
 
 pub fn init(bytes: []const u8) ValidateError!HostName {

package/std/Io/net.zig

@@ -1245,6 +1245,15 @@ pub const Stream = struct {
 
     const max_iovecs_len = 8;
 
+    /// This is a low-level API that calls the `Io` interface function directly.
+    /// For a higher level API, see `reader`.
+    pub fn read(s: *const Stream, io: Io, data: [][]u8) Reader.Error!usize {
+        return (try io.operate(.{ .net_read = .{
+            .socket_handle = s.socket.handle,
+            .data = data,
+        } })).net_read;
+    }
+
     pub fn close(s: *const Stream, io: Io) void {
         io.vtable.netClose(io.userdata, (&s.socket.handle)[0..1]);
     }
@@ -1259,16 +1268,7 @@ pub const Stream = struct {
         stream: Stream,
         err: ?Error,
 
-        pub const Error = error{
-            SystemResources,
-            ConnectionResetByPeer,
-            Timeout,
-            SocketUnconnected,
-            /// The file descriptor does not hold the required rights to read
-            /// from it.
-            AccessDenied,
-            NetworkDown,
-        } || Io.Cancelable || Io.UnexpectedError;
+        pub const Error = Io.Operation.NetRead.Error || Io.Cancelable;
 
         pub fn init(stream: Stream, io: Io, buffer: []u8) Reader {
             return .{
@@ -1302,7 +1302,7 @@ pub const Stream = struct {
             const dest_n, const data_size = try io_r.writableVector(&iovecs_buffer, data);
             const dest = iovecs_buffer[0..dest_n];
             assert(dest[0].len > 0);
-            const n = io.vtable.netRead(io.userdata, r.stream.socket.handle, dest) catch |err| {
+            const n = r.stream.read(io, dest) catch |err| {
                 r.err = err;
                 return error.ReadFailed;
             };

package/std/Io.zig

@@ -54,9 +54,6 @@ pub const VTable = struct {
     /// If it returns `null` it means `result` has been already populated and
     /// `await` will be a no-op.
     ///
-    /// When this function returns non-null, the implementation guarantees that
-    /// a unit of concurrency has been assigned to the returned task.
-    ///
     /// Thread-safe.
     async: *const fn (
         /// Corresponds to `Io.userdata`.
@@ -111,10 +108,6 @@ pub const VTable = struct {
         result_alignment: std.mem.Alignment,
     ) void,
 
-    /// When this function returns, implementation guarantees that `start` has
-    /// either already been called, or a unit of concurrency has been assigned
-    /// to the task of calling the function.
-    ///
     /// Thread-safe.
     groupAsync: *const fn (
         /// Corresponds to `Io.userdata`.
@@ -243,8 +236,6 @@ pub const VTable = struct {
     netConnectUnix: *const fn (?*anyopaque, *const net.UnixAddress) net.UnixAddress.ConnectError!net.Socket.Handle,
     netSocketCreatePair: *const fn (?*anyopaque, net.Socket.CreatePairOptions) net.Socket.CreatePairError![2]net.Socket,
     netSend: *const fn (?*anyopaque, net.Socket.Handle, []net.OutgoingMessage, net.SendFlags) struct { ?net.Socket.SendError, usize },
-    /// Returns 0 on end of stream.
-    netRead: *const fn (?*anyopaque, src: net.Socket.Handle, data: [][]u8) net.Stream.Reader.Error!usize,
     netWrite: *const fn (?*anyopaque, dest: net.Socket.Handle, header: []const u8, data: []const []const u8, splat: usize) net.Stream.Writer.Error!usize,
     netWriteFile: *const fn (?*anyopaque, net.Socket.Handle, header: []const u8, *Io.File.Reader, Io.Limit) net.Stream.Writer.WriteFileError!usize,
     netClose: *const fn (?*anyopaque, handle: []const net.Socket.Handle) void,
@@ -261,6 +252,7 @@ pub const Operation = union(enum) {
     /// other systems this tag is unreachable.
     device_io_control: DeviceIoControl,
     net_receive: NetReceive,
+    net_read: NetRead,
 
     pub const Tag = @typeInfo(Operation).@"union".tag_type.?;
 
@@ -386,6 +378,23 @@ pub const Operation = union(enum) {
         pub const Result = struct { ?net.Socket.ReceiveError, usize };
     };
 
+    pub const NetRead = struct {
+        socket_handle: net.Socket.Handle,
+        data: [][]u8,
+
+        pub const Error = error{
+            SystemResources,
+            ConnectionResetByPeer,
+            SocketUnconnected,
+            /// The file descriptor does not hold the required rights to read
+            /// from it.
+            AccessDenied,
+            NetworkDown,
+        } || Io.UnexpectedError;
+
+        pub const Result = Error!usize;
+    };
+
     pub const Result = Result: {
         const operation_fields = @typeInfo(Operation).@"union".fields;
         var field_names: [operation_fields.len][]const u8 = undefined;
@@ -680,6 +689,13 @@ pub const Limit = enum(usize) {
         };
     }
 
+    pub fn toInt64(l: Limit) ?u64 {
+        return switch (l) {
+            else => @intFromEnum(l),
+            .unlimited => null,
+        };
+    }
+
     /// Reduces a slice to account for the limit, leaving room for one extra
     /// byte above the limit, allowing for the use case of differentiating
     /// between end-of-stream and reaching the limit.
@@ -874,7 +890,7 @@ pub const Clock = enum {
             if (t.clock == clock) return t;
             const now_old = t.clock.now(io);
             const now_new = clock.now(io);
-            const duration = now_old.durationTo(t);
+            const duration = now_old.durationTo(t.raw);
             return .{
                 .clock = clock,
                 .raw = now_new.addDuration(duration),
@@ -1235,8 +1251,11 @@ pub const Group = struct {
     /// cancelation propagation boundary.
     ///
     /// Once this function is called, there are resources associated with the
-    /// group. To release those resources, `Group.await` or `Group.cancel` must
-    /// eventually be called.
+    /// group. To release those resources, `await` or `cancel` must eventually
+    /// be called.
+    ///
+    /// `function` is not guaranteed to have been called until `await` or
+    /// `cancel` is called.
     pub fn async(g: *Group, io: Io, function: anytype, args: std.meta.ArgsTuple(@TypeOf(function))) void {
         const Args = @TypeOf(args);
         const TypeErased = struct {
@@ -1274,6 +1293,9 @@ pub const Group = struct {
     /// will also cause `error.Canceled` to be returned when the group
     /// does ultimately finish.
     ///
+    /// After this function returns, all tasks of the `Group` created with
+    /// `async` or `concurrent` are guaranteed to have run.
+    ///
     /// Idempotent. Not threadsafe.
     ///
     /// It is safe to call this function concurrently with `Group.async` or
@@ -1288,6 +1310,9 @@ pub const Group = struct {
     /// Equivalent to `await` but immediately requests cancelation on all
     /// members of the group.
     ///
+    /// After this function returns, all tasks of the `Group` created with
+    /// `async` or `concurrent` are guaranteed to have run.
+    ///
     /// For a description of cancelation and cancelation points, see `Future.cancel`.
     ///
     /// Idempotent. Not threadsafe.
@@ -1665,20 +1690,29 @@ pub const Condition = struct {
         .epoch = .init(0),
     };
 
+    /// Blocks until the condition is signaled or canceled.
+    ///
+    /// See also:
+    /// * `waitUncancelable`
+    /// * `waitTimeout`
     pub fn wait(cond: *Condition, io: Io, mutex: *Mutex) Cancelable!void {
-        try waitInner(cond, io, mutex, false);
+        waitTimeout(cond, io, mutex, .none) catch |err| switch (err) {
+            error.Timeout => unreachable,
+            error.Canceled => |e| return e,
+        };
     }
 
-    /// Same as `wait`, except does not introduce a cancelation point.
+    pub const WaitTimeoutError = Cancelable || Timeout.Error;
+
+    /// Blocks until the condition is signaled, canceled, or the provided
+    /// timeout expires.
     ///
-    /// For a description of cancelation and cancelation points, see `Future.cancel`.
-    pub fn waitUncancelable(cond: *Condition, io: Io, mutex: *Mutex) void {
-        waitInner(cond, io, mutex, true) catch |err| switch (err) {
-            error.Canceled => unreachable,
-        };
-    }
+    /// See also:
+    /// * `wait`
+    /// * `waitUncancelable`
+    pub fn waitTimeout(cond: *Condition, io: Io, mutex: *Mutex, timeout: Timeout) WaitTimeoutError!void {
+        const deadline = timeout.toDeadline(io);
 
-    fn waitInner(cond: *Condition, io: Io, mutex: *Mutex, uncancelable: bool) Cancelable!void {
         var epoch = cond.epoch.load(.acquire); // `.acquire` to ensure ordered before state load
 
         {
@@ -1690,10 +1724,7 @@ pub const Condition = struct {
         defer mutex.lockUncancelable(io);
 
         while (true) {
-            const result = if (uncancelable)
-                io.futexWaitUncancelable(u32, &cond.epoch.raw, epoch)
-            else
-                io.futexWait(u32, &cond.epoch.raw, epoch);
+            const result = io.futexWaitTimeout(u32, &cond.epoch.raw, epoch, deadline);
 
             epoch = cond.epoch.load(.acquire); // `.acquire` to ensure ordered before `state` laod
 
@@ -1713,13 +1744,62 @@ pub const Condition = struct {
             }
 
             // There are no more signals available; this was a spurious wakeup or an error. If it
-            // was an error, we will remove ourselves as a waiter and return that error. Otherwise,
-            // we'll loop back to the futex wait.
+            // was an error, we will remove ourselves as a waiter and return that error. If a
+            // timeout was specified and the deadline has passed, we remove ourselves as a waiter
+            // and return `error.Timeout`. Otherwise, we'll loop back to the futex wait.
             result catch |err| {
                 const prev_state = cond.state.fetchSub(.{ .waiters = 1, .signals = 0 }, .monotonic);
                 assert(prev_state.waiters > 0); // underflow caused by illegal state
                 return err;
             };
+            switch (deadline) {
+                .none => {},
+                .deadline => |d| if (d.untilNow(io).raw.nanoseconds >= 0) {
+                    const prev_state = cond.state.fetchSub(.{ .waiters = 1, .signals = 0 }, .monotonic);
+                    assert(prev_state.waiters > 0); // underflow caused by illegal state
+                    return error.Timeout;
+                },
+                .duration => unreachable,
+            }
+        }
+    }
+
+    /// Same as `wait`, except does not introduce a cancelation point.
+    ///
+    /// See `Future.cancel` for a description of cancelation points.
+    pub fn waitUncancelable(cond: *Condition, io: Io, mutex: *Mutex) void {
+        var epoch = cond.epoch.load(.acquire); // `.acquire` to ensure ordered before state load
+
+        {
+            const prev_state = cond.state.fetchAdd(.{ .waiters = 1, .signals = 0 }, .monotonic);
+            assert(prev_state.waiters < math.maxInt(u16)); // overflow caused by too many waiters
+        }
+
+        mutex.unlock(io);
+        defer mutex.lockUncancelable(io);
+
+        while (true) {
+            io.futexWaitUncancelable(u32, &cond.epoch.raw, epoch);
+
+            epoch = cond.epoch.load(.acquire); // `.acquire` to ensure ordered before `state` laod
+
+            // Even on error, try to consume a pending signal first. Otherwise a race might
+            // cause a signal to get stuck in the state with no corresponding waiter.
+            {
+                var prev_state = cond.state.load(.monotonic);
+                while (prev_state.signals > 0) {
+                    prev_state = cond.state.cmpxchgWeak(prev_state, .{
+                        .waiters = prev_state.waiters - 1,
+                        .signals = prev_state.signals - 1,
+                    }, .acquire, .monotonic) orelse {
+                        // We successfully consumed a signal.
+                        return;
+                    };
+                }
+            }
+
+            // There are no more signals available; this was a spurious wakeup,
+            // so we'll loop back to the futex wait.
         }
     }
 
@@ -2626,7 +2706,6 @@ pub const failing: std.Io = .{
         .netConnectUnix = failingNetConnectUnix,
         .netSocketCreatePair = failingNetSocketCreatePair,
         .netSend = failingNetSend,
-        .netRead = failingNetRead,
         .netWrite = failingNetWrite,
         .netWriteFile = failingNetWriteFile,
         .netClose = unreachableNetClose,
@@ -2774,6 +2853,7 @@ pub fn failingOperate(userdata: ?*anyopaque, operation: Operation) Cancelable!Op
         .file_write_streaming => .{ .file_write_streaming = error.InputOutput },
         .device_io_control => unreachable,
         .net_receive => .{ .net_receive = .{ error.NetworkDown, 0 } },
+        .net_read => .{ .net_read = error.NetworkDown },
     };
 }
 
@@ -2851,7 +2931,7 @@ pub fn failingDirAccess(userdata: ?*anyopaque, dir: Dir, sub_path: []const u8, o
     return error.FileNotFound;
 }
 
-pub fn failingDirCreateFile(userdata: ?*anyopaque, dir: Dir, sub_path: []const u8, options: File.CreateFlags) File.OpenError!File {
+pub fn failingDirCreateFile(userdata: ?*anyopaque, dir: Dir, sub_path: []const u8, options: Dir.CreateFileOptions) File.OpenError!File {
     _ = userdata;
     _ = dir;
     _ = sub_path;
@@ -2867,7 +2947,7 @@ pub fn failingDirCreateFileAtomic(userdata: ?*anyopaque, dir: Dir, sub_path: []c
     return error.NoSpaceLeft;
 }
 
-pub fn failingDirOpenFile(userdata: ?*anyopaque, dir: Dir, sub_path: []const u8, flags: File.OpenFlags) File.OpenError!File {
+pub fn failingDirOpenFile(userdata: ?*anyopaque, dir: Dir, sub_path: []const u8, flags: Dir.OpenFileOptions) File.OpenError!File {
     _ = userdata;
     _ = dir;
     _ = sub_path;
@@ -3204,7 +3284,7 @@ pub fn unreachableFileMemoryMapWrite(userdata: ?*anyopaque, mm: *File.MemoryMap)
     unreachable;
 }
 
-pub fn failingProcessExecutableOpen(userdata: ?*anyopaque, flags: File.OpenFlags) std.process.OpenExecutableError!File {
+pub fn failingProcessExecutableOpen(userdata: ?*anyopaque, flags: Dir.OpenFileOptions) std.process.OpenExecutableError!File {
     _ = userdata;
     _ = flags;
     return error.FileNotFound;
@@ -3377,13 +3457,6 @@ pub fn failingNetSend(userdata: ?*anyopaque, handle: net.Socket.Handle, messages
     return .{ error.NetworkDown, 0 };
 }
 
-pub fn failingNetRead(userdata: ?*anyopaque, src: net.Socket.Handle, data: [][]u8) net.Stream.Reader.Error!usize {
-    _ = userdata;
-    _ = src;
-    _ = data;
-    return error.NetworkDown;
-}
-
 pub fn failingNetWrite(userdata: ?*anyopaque, dest: net.Socket.Handle, header: []const u8, data: []const []const u8, splat: usize) net.Stream.Writer.Error!usize {
     _ = userdata;
     _ = dest;

package/std/Random/ChaCha.zig

@@ -14,7 +14,7 @@ const State = [8 * Cipher.block_length]u8;
 state: State,
 offset: usize,
 
-const nonce = [_]u8{0} ** Cipher.nonce_length;
+const nonce: [Cipher.nonce_length]u8 = @splat(0);
 
 pub const secret_seed_length = Cipher.key_length;
 
@@ -38,7 +38,7 @@ pub fn addEntropy(self: *Self, bytes: []const u8) void {
         );
     }
     if (i < bytes.len) {
-        var k = [_]u8{0} ** Cipher.key_length;
+        var k: [Cipher.key_length]u8 = @splat(0);
         const src = bytes[i..];
         @memcpy(k[0..src.len], src);
         Cipher.xor(

package/std/Random/benchmark.zig

@@ -55,12 +55,12 @@ const csprngs = [_]Rng{
     Rng{
         .ty = Random.Ascon,
         .name = "ascon",
-        .init_u8s = &[_]u8{0} ** 32,
+        .init_u8s = &@as([32]u8, @splat(0)),
     },
     Rng{
         .ty = Random.ChaCha,
         .name = "chacha",
-        .init_u8s = &[_]u8{0} ** 32,
+        .init_u8s = &@as([32]u8, @splat(0)),
     },
 };
 

package/std/Random.zig

@@ -125,9 +125,9 @@ pub fn enumValueWithIndex(r: Random, comptime EnumType: type, comptime Index: ty
 /// `i` is evenly distributed.
 pub fn int(r: Random, comptime T: type) T {
     const bits = @typeInfo(T).int.bits;
-    const UnsignedT = std.meta.Int(.unsigned, bits);
+    const UnsignedT = @Int(.unsigned, bits);
     const ceil_bytes = comptime std.math.divCeil(u16, bits, 8) catch unreachable;
-    const ByteAlignedT = std.meta.Int(.unsigned, ceil_bytes * 8);
+    const ByteAlignedT = @Int(.unsigned, ceil_bytes * 8);
 
     var rand_bytes: [ceil_bytes]u8 = undefined;
     r.bytes(&rand_bytes);
@@ -215,7 +215,7 @@ pub fn intRangeLessThanBiased(r: Random, comptime T: type, at_least: T, less_tha
     const info = @typeInfo(T).int;
     if (info.signedness == .signed) {
         // Two's complement makes this math pretty easy.
-        const UnsignedT = std.meta.Int(.unsigned, info.bits);
+        const UnsignedT = @Int(.unsigned, info.bits);
         const lo: UnsignedT = @bitCast(at_least);
         const hi: UnsignedT = @bitCast(less_than);
         const result = lo +% r.uintLessThanBiased(UnsignedT, hi -% lo);
@@ -234,7 +234,7 @@ pub fn intRangeLessThan(r: Random, comptime T: type, at_least: T, less_than: T)
     const info = @typeInfo(T).int;
     if (info.signedness == .signed) {
         // Two's complement makes this math pretty easy.
-        const UnsignedT = std.meta.Int(.unsigned, info.bits);
+        const UnsignedT = @Int(.unsigned, info.bits);
         const lo: UnsignedT = @bitCast(at_least);
         const hi: UnsignedT = @bitCast(less_than);
         const result = lo +% r.uintLessThan(UnsignedT, hi -% lo);
@@ -252,7 +252,7 @@ pub fn intRangeAtMostBiased(r: Random, comptime T: type, at_least: T, at_most: T
     const info = @typeInfo(T).int;
     if (info.signedness == .signed) {
         // Two's complement makes this math pretty easy.
-        const UnsignedT = std.meta.Int(.unsigned, info.bits);
+        const UnsignedT = @Int(.unsigned, info.bits);
         const lo: UnsignedT = @bitCast(at_least);
         const hi: UnsignedT = @bitCast(at_most);
         const result = lo +% r.uintAtMostBiased(UnsignedT, hi -% lo);
@@ -271,7 +271,7 @@ pub fn intRangeAtMost(r: Random, comptime T: type, at_least: T, at_most: T) T {
     const info = @typeInfo(T).int;
     if (info.signedness == .signed) {
         // Two's complement makes this math pretty easy.
-        const UnsignedT = std.meta.Int(.unsigned, info.bits);
+        const UnsignedT = @Int(.unsigned, info.bits);
         const lo: UnsignedT = @bitCast(at_least);
         const hi: UnsignedT = @bitCast(at_most);
         const result = lo +% r.uintAtMost(UnsignedT, hi -% lo);

package/std/SemanticVersion.zig

@@ -146,7 +146,7 @@ fn parseNum(text: []const u8) error{ InvalidVersion, Overflow }!usize {
 
     return std.fmt.parseUnsigned(usize, text, 10) catch |err| switch (err) {
         error.InvalidCharacter => return error.InvalidVersion,
-        error.Overflow => return error.Overflow,
+        error.Overflow => |e| return e,
     };
 }
 

package/std/Target/Query.zig

@@ -253,7 +253,7 @@ pub fn parse(args: ParseOptions) !Query {
             } else if (abi.isAndroid()) {
                 result.android_api_level = std.fmt.parseUnsigned(u32, abi_ver_text, 10) catch |err| switch (err) {
                     error.InvalidCharacter => return error.InvalidVersion,
-                    error.Overflow => return error.Overflow,
+                    error.Overflow => |e| return e,
                 };
             } else {
                 return error.InvalidAbiVersion;
@@ -282,7 +282,7 @@ pub fn parse(args: ParseOptions) !Query {
         } else if (mem.eql(u8, cpu_name, "baseline")) {
             result.cpu_model = .baseline;
         } else {
-            result.cpu_model = .{ .explicit = try arch.parseCpuModel(cpu_name) };
+            result.cpu_model = .{ .explicit = arch.parseCpuModel(cpu_name) orelse return error.UnknownCpuModel };
         }
 
         while (index < cpu_features.len) {
@@ -346,7 +346,7 @@ pub fn parseVersion(ver: []const u8) error{ InvalidVersion, Overflow }!SemanticV
         fn parseVersionComponentInner(component: []const u8) error{ InvalidVersion, Overflow }!usize {
             return std.fmt.parseUnsigned(usize, component, 10) catch |err| switch (err) {
                 error.InvalidCharacter => return error.InvalidVersion,
-                error.Overflow => return error.Overflow,
+                error.Overflow => |e| return e,
             };
         }
     }).parseVersionComponentInner;
@@ -533,9 +533,8 @@ pub fn serializeCpuAlloc(q: Query, ally: Allocator) Allocator.Error![]u8 {
     return buffer.toOwnedSlice();
 }
 
+/// Deprecated; use `zigTriple` instead. Will be removed in 0.18.0.
 pub fn allocDescription(self: Query, allocator: Allocator) ![]u8 {
-    // TODO is there anything else worthy of the description that is not
-    // already captured in the triple?
     return self.zigTriple(allocator);
 }