@zigc/lib 0.17.0-dev.224 → 0.17.0-dev.242

package/c/math.zig

@@ -2,6 +2,7 @@ const builtin = @import("builtin");
 
 const std = @import("std");
 const math = std.math;
+const ld = math.long_double;
 
 const symbol = @import("../c.zig").symbol;
 
@@ -35,7 +36,9 @@ comptime {
         symbol(&frexpl, "frexpl");
         symbol(&hypotf, "hypotf");
         symbol(&hypotl, "hypotl");
+        symbol(&lrintl, "lrintl");
         symbol(&modfl, "modfl");
+        symbol(&rintl, "rintl");
     }
 
     if ((builtin.target.isMinGW() and @sizeOf(f64) != @sizeOf(c_longdouble)) or builtin.target.isMuslLibC() or builtin.target.isWasiLibC()) {
@@ -254,11 +257,15 @@ fn isnanl(x: c_longdouble) callconv(.c) c_int {
 }
 
 fn lrint(x: f64) callconv(.c) c_long {
-    return @intFromFloat(rint(x));
+    return @trunc(rint(x));
 }
 
 fn lrintf(x: f32) callconv(.c) c_long {
-    return @intFromFloat(rintf(x));
+    return @trunc(rintf(x));
+}
+
+fn lrintl(x: c_longdouble) callconv(.c) c_long {
+    return @trunc(rintl(x));
 }
 
 fn modfGeneric(comptime T: type, x: T, iptr: *T) T {
@@ -364,6 +371,28 @@ fn rintf(x: f32) callconv(.c) f32 {
     return y;
 }
 
+fn rintl(x: c_longdouble) callconv(.c) c_longdouble {
+    if (@typeInfo(c_longdouble).float.bits == 64)
+        return rint(x);
+
+    const toint: c_longdouble = 1 << math.floatFractionalBits(c_longdouble);
+    const se = ld.signExponent(x);
+
+    if (se & 0x7fff >= 0x3fff + math.floatFractionalBits(c_longdouble))
+        return x;
+
+    var y: c_longdouble = undefined;
+    if ((se >> 15) == 1) {
+        y = x - toint + toint;
+    } else {
+        y = x + toint - toint;
+    }
+
+    if (y == 0)
+        return 0 * x;
+    return y;
+}
+
 fn tanh(x: f64) callconv(.c) f64 {
     return math.tanh(x);
 }

package/compiler/build_runner.zig

@@ -1557,7 +1557,7 @@ fn printUsage(b: *std.Build, w: *Writer) !void {
             const name = try fmt.allocPrint(arena, "  -D{s}=[{t}]", .{ option.name, option.type_id });
             try w.print("{s:<30} {s}\n", .{ name, option.description });
             if (option.enum_options) |enum_options| {
-                const padding = " " ** 33;
+                const padding: [33]u8 = @splat(' ');
                 try w.writeAll(padding ++ "Supported Values:\n");
                 for (enum_options) |enum_option| {
                     try w.print(padding ++ "  {s}\n", .{enum_option});

package/compiler/reduce/Walk.zig

@@ -223,12 +223,8 @@ fn walkExpression(w: *Walk, node: Ast.Node.Index) Error!void {
             return walkBlock(w, node, statements);
         },
 
-        .@"errdefer" => {
-            const expr = ast.nodeData(node).opt_token_and_node[1];
-            return walkExpression(w, expr);
-        },
-
         .@"defer",
+        .@"errdefer",
         .@"comptime",
         .@"nosuspend",
         .@"suspend",
@@ -252,7 +248,6 @@ fn walkExpression(w: *Walk, node: Ast.Node.Index) Error!void {
         .add_wrap,
         .add_sat,
         .array_cat,
-        .array_mult,
         .assign,
         .assign_bit_and,
         .assign_bit_or,

package/compiler/resinator/compile.zig

@@ -3084,7 +3084,7 @@ pub const StringTable = struct {
 
     pub const Block = struct {
         strings: std.ArrayList(Token) = .empty,
-        set_indexes: std.bit_set.IntegerBitSet(16) = .{ .mask = 0 },
+        set_indexes: std.bit_set.Integer(16) = .{ .mask = 0 },
         memory_flags: MemoryFlags = MemoryFlags.defaults(res.RT.STRING),
         characteristics: u32,
         version: u32,

package/compiler/resinator/cvtres.zig

@@ -321,7 +321,7 @@ pub fn writeCoff(
         .checksum = 0,
         .number = 0,
         .selection = .NONE,
-        .unused = .{0} ** 3,
+        .unused = @splat(0),
     });
 
     try writeSymbol(writer, .{
@@ -342,7 +342,7 @@ pub fn writeCoff(
         .checksum = 0,
         .number = 0,
         .selection = .NONE,
-        .unused = .{0} ** 3,
+        .unused = @splat(0),
     });
 
     for (resource_symbols) |resource_symbol| {
@@ -353,11 +353,11 @@ pub fn writeCoff(
         const name_bytes: [8]u8 = name_bytes: {
             if (external_symbol_name.len > 8) {
                 const string_table_offset: u32 = try string_table.put(allocator, external_symbol_name);
-                var bytes = [_]u8{0} ** 8;
+                var bytes: [8]u8 = @splat(0);
                 std.mem.writeInt(u32, bytes[4..8], string_table_offset, .little);
                 break :name_bytes bytes;
             } else {
-                var symbol_shortname = [_]u8{0} ** 8;
+                var symbol_shortname: [8]u8 = @splat(0);
                 @memcpy(symbol_shortname[0..external_symbol_name.len], external_symbol_name);
                 break :name_bytes symbol_shortname;
             }

package/compiler/resinator/ico.zig

@@ -183,7 +183,7 @@ pub const Entry = struct {
 };
 
 test "icon" {
-    const data = "\x00\x00\x01\x00\x01\x00\x10\x10\x00\x00\x01\x00\x10\x00\x10\x00\x00\x00\x16\x00\x00\x00" ++ [_]u8{0} ** 16;
+    const data = "\x00\x00\x01\x00\x01\x00\x10\x10\x00\x00\x01\x00\x10\x00\x10\x00\x00\x00\x16\x00\x00\x00" ++ @as([16]u8, @splat(0));
     var fbs: std.Io.Reader = .fixed(data);
     const icon = try read(std.testing.allocator, &fbs, data.len);
     defer icon.deinit();
@@ -196,19 +196,19 @@ test "icon too many images" {
     // Note that with verifying that all data sizes are within the file bounds and >= 16,
     // it's not possible to hit EOF when looking for more RESDIR structures, since they are
     // themselves 16 bytes long, so we'll always hit ImpossibleDataSize instead.
-    const data = "\x00\x00\x01\x00\x02\x00\x10\x10\x00\x00\x01\x00\x10\x00\x10\x00\x00\x00\x16\x00\x00\x00" ++ [_]u8{0} ** 16;
+    const data = "\x00\x00\x01\x00\x02\x00\x10\x10\x00\x00\x01\x00\x10\x00\x10\x00\x00\x00\x16\x00\x00\x00" ++ @as([16]u8, @splat(0));
     var fbs: std.Io.Reader = .fixed(data);
     try std.testing.expectError(error.ImpossibleDataSize, read(std.testing.allocator, &fbs, data.len));
 }
 
 test "icon data size past EOF" {
-    const data = "\x00\x00\x01\x00\x01\x00\x10\x10\x00\x00\x01\x00\x10\x00\x10\x01\x00\x00\x16\x00\x00\x00" ++ [_]u8{0} ** 16;
+    const data = "\x00\x00\x01\x00\x01\x00\x10\x10\x00\x00\x01\x00\x10\x00\x10\x01\x00\x00\x16\x00\x00\x00" ++ @as([16]u8, @splat(0));
     var fbs: std.Io.Reader = .fixed(data);
     try std.testing.expectError(error.ImpossibleDataSize, read(std.testing.allocator, &fbs, data.len));
 }
 
 test "icon data offset past EOF" {
-    const data = "\x00\x00\x01\x00\x01\x00\x10\x10\x00\x00\x01\x00\x10\x00\x10\x00\x00\x00\x17\x00\x00\x00" ++ [_]u8{0} ** 16;
+    const data = "\x00\x00\x01\x00\x01\x00\x10\x10\x00\x00\x01\x00\x10\x00\x10\x00\x00\x00\x17\x00\x00\x00" ++ @as([16]u8, @splat(0));
     var fbs: std.Io.Reader = .fixed(data);
     try std.testing.expectError(error.ImpossibleDataSize, read(std.testing.allocator, &fbs, data.len));
 }

package/compiler/resinator/parse.zig

@@ -138,8 +138,8 @@ pub const Parser = struct {
         var optional_statements: std.ArrayList(*Node) = .empty;
 
         const num_statement_types = @typeInfo(rc.OptionalStatements).@"enum".fields.len;
-        var statement_type_has_duplicates = [_]bool{false} ** num_statement_types;
-        var last_statement_per_type = [_]?*Node{null} ** num_statement_types;
+        var statement_type_has_duplicates: [num_statement_types]bool = @splat(false);
+        var last_statement_per_type: [num_statement_types]?*Node = @splat(null);
 
         while (true) {
             const lookahead_token = try self.lookaheadToken(.normal);

package/compiler/resinator/res.zig

@@ -1068,7 +1068,7 @@ pub const FixedFileInfo = struct {
     pub const key = std.unicode.utf8ToUtf16LeStringLiteral("VS_VERSION_INFO");
 
     pub const Version = struct {
-        parts: [4]u16 = [_]u16{0} ** 4,
+        parts: [4]u16 = @splat(0),
 
         pub fn mostSignificantCombinedParts(self: Version) u32 {
             return (@as(u32, self.parts[0]) << 16) + self.parts[1];

package/compiler/translate-c/ast.zig

@@ -242,7 +242,7 @@ pub const Node = extern union {
 
         /// array_type{}
         empty_array,
-        /// [1]type{val} ** count
+        /// @as([count]type, @splat(val))
         array_filler,
 
         /// comptime { if (!(lhs)) @compileError(rhs); }
@@ -1976,28 +1976,18 @@ fn renderNode(c: *Context, node: Node) Allocator.Error!NodeIndex {
         .array_filler => {
             const payload = node.castTag(.array_filler).?.data;
 
-            const type_expr = try renderArrayType(c, 1, payload.type);
-            const l_brace = try c.addToken(.l_brace, "{");
-            const val = try renderNode(c, payload.filler);
-            _ = try c.addToken(.r_brace, "}");
+            const as_tok = try c.addToken(.builtin, "@as");
+            _ = try c.addToken(.l_paren, "(");
+            const type_node = try renderArrayType(c, payload.count, payload.type);
+            _ = try c.addToken(.comma, ",");
+            const splat_node = try renderBuiltinCall(c, "@splat", &.{payload.filler});
+            _ = try c.addToken(.r_paren, ")");
 
-            const init = try c.addNode(.{
-                .tag = .array_init_one,
-                .main_token = l_brace,
-                .data = .{ .node_and_node = .{
-                    type_expr, val,
-                } },
-            });
             return c.addNode(.{
-                .tag = .array_cat,
-                .main_token = try c.addToken(.asterisk_asterisk, "**"),
-                .data = .{ .node_and_node = .{
-                    init,
-                    try c.addNode(.{
-                        .tag = .number_literal,
-                        .main_token = try c.addTokenFmt(.number_literal, "{d}", .{payload.count}),
-                        .data = undefined,
-                    }),
+                .tag = .builtin_call_two,
+                .main_token = as_tok,
+                .data = .{ .opt_node_and_opt_node = .{
+                    .fromOptional(type_node), .fromOptional(splat_node),
                 } },
             });
         },

package/compiler_rt/atomics.zig

@@ -94,7 +94,7 @@ const SpinlockTable = struct {
         }
     };
 
-    list: [max_spinlocks]Spinlock = [_]Spinlock{.{}} ** max_spinlocks,
+    list: [max_spinlocks]Spinlock = @splat(.{}),
 
     // The spinlock table behaves as a really simple hash table, mapping
     // addresses to spinlocks. The mapping is not unique but that's only a

package/compiler_rt/cos.zig

@@ -7,6 +7,7 @@
 
 const std = @import("std");
 const math = std.math;
+const ld = math.long_double;
 const mem = std.mem;
 const expect = std.testing.expect;
 const expectApproxEqAbs = std.testing.expectApproxEqAbs;
@@ -17,7 +18,6 @@ const trig = @import("trig.zig");
 const rem_pio2 = @import("rem_pio2.zig").rem_pio2;
 const rem_pio2f = @import("rem_pio2f.zig").rem_pio2f;
 const rem_pio2l = @import("rem_pio2l.zig").rem_pio2l;
-const ld = @import("long_double.zig");
 
 comptime {
     symbol(&cosh, "__cosh");

package/compiler_rt/rem_pio2l.zig

@@ -5,8 +5,8 @@
 
 const std = @import("std");
 const math = std.math;
+const ld = math.long_double;
 
-const ld = @import("long_double.zig");
 const rem_pio2_large = @import("rem_pio2_large.zig").rem_pio2_large;
 
 pub fn rem_pio2l(comptime T: type, x: T, y: *[2]T) i32 {

package/compiler_rt/sin.zig

@@ -7,6 +7,7 @@
 
 const std = @import("std");
 const math = std.math;
+const ld = math.long_double;
 const mem = std.mem;
 const expect = std.testing.expect;
 const expectApproxEqAbs = std.testing.expectApproxEqAbs;
@@ -17,7 +18,6 @@ const trig = @import("trig.zig");
 const rem_pio2 = @import("rem_pio2.zig").rem_pio2;
 const rem_pio2f = @import("rem_pio2f.zig").rem_pio2f;
 const rem_pio2l = @import("rem_pio2l.zig").rem_pio2l;
-const ld = @import("long_double.zig");
 
 comptime {
     symbol(&sinh, "__sinh");

package/compiler_rt/sincos.zig

@@ -2,6 +2,7 @@ const std = @import("std");
 const builtin = @import("builtin");
 const arch = builtin.cpu.arch;
 const math = std.math;
+const ld = math.long_double;
 const mem = std.mem;
 const expect = std.testing.expect;
 const expectApproxEqAbs = std.testing.expectApproxEqAbs;
@@ -9,7 +10,6 @@ const trig = @import("trig.zig");
 const rem_pio2 = @import("rem_pio2.zig").rem_pio2;
 const rem_pio2f = @import("rem_pio2f.zig").rem_pio2f;
 const rem_pio2l = @import("rem_pio2l.zig").rem_pio2l;
-const ld = @import("long_double.zig");
 const compiler_rt = @import("../compiler_rt.zig");
 const symbol = compiler_rt.symbol;
 

package/compiler_rt/ssp.zig

@@ -44,10 +44,10 @@ fn __chk_fail() callconv(.c) noreturn {
 
 // TODO: Initialize the canary with random data
 var __stack_chk_guard: usize = blk: {
-    var buf = [1]u8{0} ** @sizeOf(usize);
+    var buf: [@sizeOf(usize)]u8 = @splat(0);
     buf[@sizeOf(usize) - 1] = 255;
     buf[@sizeOf(usize) - 2] = '\n';
-    break :blk @as(usize, @bitCast(buf));
+    break :blk @bitCast(buf);
 };
 
 fn __strcpy_chk(dest: [*:0]u8, src: [*:0]const u8, dest_n: usize) callconv(.c) [*:0]u8 {

package/compiler_rt/tan.zig

@@ -9,6 +9,7 @@
 const std = @import("std");
 const builtin = @import("builtin");
 const math = std.math;
+const ld = math.long_double;
 const mem = std.mem;
 const expect = std.testing.expect;
 const expectApproxEqAbs = std.testing.expectApproxEqAbs;
@@ -17,7 +18,6 @@ const kernel = @import("trig.zig");
 const rem_pio2 = @import("rem_pio2.zig").rem_pio2;
 const rem_pio2f = @import("rem_pio2f.zig").rem_pio2f;
 const rem_pio2l = @import("rem_pio2l.zig").rem_pio2l;
-const ld = @import("long_double.zig");
 
 const arch = builtin.cpu.arch;
 const compiler_rt = @import("../compiler_rt.zig");

package/docs/wasm/Walk.zig

@@ -709,7 +709,6 @@ fn expr(w: *Walk, scope: *Scope, parent_decl: Decl.Index, node: Ast.Node.Index)
         .less_or_equal,
         .array_cat,
 
-        .array_mult,
         .error_union,
         .merge_error_sets,
         .bool_and,
@@ -1014,8 +1013,7 @@ fn block(
 
             .grouped_expression => try expr(w, scope, parent_decl, ast.nodeData(node).node_and_token[0]),
 
-            .@"defer" => try expr(w, scope, parent_decl, ast.nodeData(node).node),
-            .@"errdefer" => try expr(w, scope, parent_decl, ast.nodeData(node).opt_token_and_node[1]),
+            .@"defer", .@"errdefer" => try expr(w, scope, parent_decl, ast.nodeData(node).node),
 
             else => try expr(w, scope, parent_decl, node),
         }

package/docs/wasm/html_render.zig

@@ -302,7 +302,6 @@ pub fn fileSourceHtml(
             .minus_pipe_equal,
             .asterisk,
             .asterisk_equal,
-            .asterisk_asterisk,
             .asterisk_percent,
             .asterisk_percent_equal,
             .asterisk_pipe,
@@ -328,7 +327,7 @@ pub fn fileSourceHtml(
             .tilde,
             => try appendEscaped(out, slice),
 
-            .invalid, .invalid_periodasterisks => return error.InvalidToken,
+            .invalid => return error.InvalidToken,
         }
     }
 }

package/package.json

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

package/std/Build/Step/ConfigHeader.zig

@@ -290,7 +290,7 @@ fn render_autoconf_undef(
     const build = step.owner;
     const allocator = build.allocator;
 
-    var is_used: std.DynamicBitSetUnmanaged = try .initEmpty(allocator, values.count());
+    var is_used: std.bit_set.Dynamic = try .initEmpty(allocator, values.count());
     defer is_used.deinit(allocator);
 
     var any_errors = false;

package/std/Io/Kqueue.zig

@@ -79,7 +79,7 @@ const Fiber = struct {
     awaiter: ?*Fiber,
     queue_next: ?*Fiber,
     cancel_thread: ?*Thread,
-    awaiting_completions: std.StaticBitSet(3),
+    awaiting_completions: std.bit_set.Static(3),
 
     const finished: ?*Fiber = @ptrFromInt(@alignOf(Thread));
 

package/std/Io/Reader.zig

@@ -2097,7 +2097,6 @@ test "deserialize signed LEB128" {
     try testing.expectEqual(std.math.minInt(i128), testLeb128(i128, "\x80\x80\x80\x80\x80\x80\x80\x80\x80\x80\x80\x80\x80\x80\x80\x80\x80\x80\x7E"));
 
     // Specific cases
-    try testing.expectEqual(0, testLeb128(i0, "\x00"));
     try testing.expectEqual(0, testLeb128(i2, "\x00"));
     try testing.expectEqual(0, testLeb128(i8, "\x00"));
 
@@ -2134,8 +2133,6 @@ test "deserialize signed LEB128" {
     try testing.expectError(error.EndOfStream, testLeb128(i128, &end_of_stream));
 
     // Overflow
-    try testing.expectError(error.Overflow, testLeb128(i0, "\x01"));
-    try testing.expectError(error.Overflow, testLeb128(i0, "\x7F"));
     try testing.expectError(error.Overflow, testLeb128(i8, "\x80\x01"));
     try testing.expectError(error.Overflow, testLeb128(i8, "\xFF\x7E"));
     try testing.expectError(error.Overflow, testLeb128(i8, "\x80\x80\x40"));
@@ -2145,7 +2142,6 @@ test "deserialize signed LEB128" {
     try testing.expectError(error.Overflow, testLeb128(i64, "\x80\x80\x80\x80\x80\x80\x80\x80\x80\x01"));
     try testing.expectError(error.Overflow, testLeb128(i64, "\x80\x80\x80\x80\x80\x80\x80\x80\x80\x40"));
 
-    try testing.expectError(error.Overflow, testLeb128(i0, &overflow));
     try testing.expectError(error.Overflow, testLeb128(i7, &overflow));
     try testing.expectError(error.Overflow, testLeb128(i8, &overflow));
     try testing.expectError(error.Overflow, testLeb128(i14, &overflow));
@@ -2159,7 +2155,6 @@ test "deserialize signed LEB128" {
     try testing.expectEqual(0x80, testLeb128(i64, "\x80\x81\x00"));
     try testing.expectEqual(0x80, testLeb128(i64, "\x80\x81\x80\x00"));
 
-    try testing.expectEqual(0, testLeb128(i0, &long_zero));
     try testing.expectEqual(0, testLeb128(i7, &long_zero));
     try testing.expectEqual(0, testLeb128(i8, &long_zero));
     try testing.expectEqual(0, testLeb128(i14, &long_zero));

package/std/Io/Threaded.zig

@@ -6329,7 +6329,7 @@ pub fn GetFinalPathNameByHandle(
             const MIN_SIZE = @sizeOf(windows.MOUNTMGR_MOUNT_POINT) + windows.MAX_PATH;
             // We initialize the input buffer to all zeros for convenience since
             // `DeviceIoControl` with `IOCTL_MOUNTMGR_QUERY_POINTS` expects this.
-            var input_buf: [MIN_SIZE]u8 align(@alignOf(windows.MOUNTMGR_MOUNT_POINT)) = [_]u8{0} ** MIN_SIZE;
+            var input_buf: [MIN_SIZE]u8 align(@alignOf(windows.MOUNTMGR_MOUNT_POINT)) = @splat(0);
             var output_buf: [MIN_SIZE * 4]u8 align(@alignOf(windows.MOUNTMGR_MOUNT_POINTS)) = undefined;
 
             // This surprising path is a filesystem path to the mount manager on Windows.
@@ -6409,7 +6409,7 @@ pub fn GetFinalPathNameByHandle(
 
                     // 49 is the maximum length accepted by mountmgrIsVolumeName
                     const vol_input_size = @sizeOf(windows.MOUNTMGR_TARGET_NAME) + (49 * 2);
-                    var vol_input_buf: [vol_input_size]u8 align(@alignOf(windows.MOUNTMGR_TARGET_NAME)) = [_]u8{0} ** vol_input_size;
+                    var vol_input_buf: [vol_input_size]u8 align(@alignOf(windows.MOUNTMGR_TARGET_NAME)) = @splat(0);
                     // Note: If the path exceeds MAX_PATH, the Disk Management GUI doesn't accept the full path,
                     // and instead if must be specified using a shortened form (e.g. C:\FOO~1\BAR~1\<...>).
                     // However, just to be sure we can handle any path length, we use PATH_MAX_WIDE here.
@@ -8914,7 +8914,7 @@ fn isCygwinPty(file: File) Io.Cancelable!bool {
     // we can use this smaller buffer and just return false on any error from
     // NtQueryInformationFile.
     const num_name_bytes = windows.MAX_PATH * 2;
-    var name_info_bytes align(@alignOf(windows.FILE.NAME_INFORMATION)) = [_]u8{0} ** (name_bytes_offset + num_name_bytes);
+    var name_info_bytes: [name_bytes_offset + num_name_bytes]u8 align(@alignOf(windows.FILE.NAME_INFORMATION)) = @splat(0);
 
     var io_status_block: windows.IO_STATUS_BLOCK = undefined;
     const syscall: Syscall = try .start();
@@ -16191,7 +16191,7 @@ fn windowsCreateProcessPathExt(
     var io_status: windows.IO_STATUS_BLOCK = undefined;
 
     const num_supported_pathext = @typeInfo(process.WindowsExtension).@"enum".fields.len;
-    var pathext_seen = [_]bool{false} ** num_supported_pathext;
+    var pathext_seen: [num_supported_pathext]bool = @splat(false);
     var any_pathext_seen = false;
     var unappended_exists = false;
 

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 {
@@ -1924,7 +1924,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");

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/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/Thread.zig

@@ -1574,9 +1574,9 @@ const LinuxThreadImpl = struct {
 };
 
 fn testThreadName(io: Io, thread: *Thread) !void {
-    const testCases = &[_][]const u8{
+    const testCases: []const []const u8 = &.{
         "mythread",
-        "b" ** max_name_len,
+        &@as([max_name_len]u8, @splat('b')),
     };
 
     inline for (testCases) |tc| {

package/std/base64.zig

@@ -86,7 +86,7 @@ pub const Base64Encoder = struct {
     /// A bunch of assertions, then simply pass the data right through.
     pub fn init(alphabet_chars: [64]u8, pad_char: ?u8) Base64Encoder {
         assert(alphabet_chars.len == 64);
-        var char_in_alphabet = [_]bool{false} ** 256;
+        var char_in_alphabet: [256]bool = @splat(false);
         for (alphabet_chars) |c| {
             assert(!char_in_alphabet[c]);
             assert(pad_char == null or c != pad_char.?);
@@ -176,12 +176,12 @@ pub const Base64Decoder = struct {
 
     pub fn init(alphabet_chars: [64]u8, pad_char: ?u8) Base64Decoder {
         var result = Base64Decoder{
-            .char_to_index = [_]u8{invalid_char} ** 256,
-            .fast_char_to_index = .{[_]u32{invalid_char_tst} ** 256} ** 4,
+            .char_to_index = @splat(invalid_char),
+            .fast_char_to_index = @splat(@splat(invalid_char_tst)),
             .pad_char = pad_char,
         };
 
-        var char_in_alphabet = [_]bool{false} ** 256;
+        var char_in_alphabet: [256]bool = @splat(false);
         for (alphabet_chars, 0..) |c, i| {
             assert(!char_in_alphabet[c]);
             assert(pad_char == null or c != pad_char.?);
@@ -302,7 +302,7 @@ pub const Base64DecoderWithIgnore = struct {
     pub fn init(alphabet_chars: [64]u8, pad_char: ?u8, ignore_chars: []const u8) Base64DecoderWithIgnore {
         var result = Base64DecoderWithIgnore{
             .decoder = Base64Decoder.init(alphabet_chars, pad_char),
-            .char_is_ignored = [_]bool{false} ** 256,
+            .char_is_ignored = @splat(false),
         };
         for (ignore_chars) |c| {
             assert(result.decoder.char_to_index[c] == Base64Decoder.invalid_char);