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

package/std/crypto/pcurves/tests/p384.zig

@@ -100,7 +100,7 @@ test "p384 public key is the neutral element (public verification)" {
 }
 
 test "p384 field element non-canonical encoding" {
-    const s = [_]u8{0xff} ** 48;
+    const s: [48]u8 = @splat(0xff);
     try testing.expectError(error.NonCanonical, P384.Fe.fromBytes(s, .little));
 }
 
@@ -113,8 +113,8 @@ test "p384 neutral element decoding" {
 test "p384 double base multiplication" {
     const p1 = P384.basePoint;
     const p2 = P384.basePoint.dbl();
-    const s1 = [_]u8{0x01} ** 48;
-    const s2 = [_]u8{0x02} ** 48;
+    const s1: [48]u8 = @splat(0x01);
+    const s2: [48]u8 = @splat(0x02);
     const pr1 = try P384.mulDoubleBasePublic(p1, s1, p2, s2, .little);
     const pr2 = (try p1.mul(s1, .little)).add(try p2.mul(s2, .little));
     try testing.expect(pr1.equivalent(pr2));
@@ -123,8 +123,8 @@ test "p384 double base multiplication" {
 test "p384 double base multiplication with large scalars" {
     const p1 = P384.basePoint;
     const p2 = P384.basePoint.dbl();
-    const s1 = [_]u8{0xee} ** 48;
-    const s2 = [_]u8{0xdd} ** 48;
+    const s1: [48]u8 = @splat(0xee);
+    const s2: [48]u8 = @splat(0xdd);
     const pr1 = try P384.mulDoubleBasePublic(p1, s1, p2, s2, .little);
     const pr2 = (try p1.mul(s1, .little)).add(try p2.mul(s2, .little));
     try testing.expect(pr1.equivalent(pr2));

package/std/crypto/pcurves/tests/secp256k1.zig

@@ -109,7 +109,7 @@ test "secp256k1 public key is the neutral element (public verification)" {
 }
 
 test "secp256k1 field element non-canonical encoding" {
-    const s = [_]u8{0xff} ** 32;
+    const s: [32]u8 = @splat(0xff);
     try testing.expectError(error.NonCanonical, Secp256k1.Fe.fromBytes(s, .little));
 }
 
@@ -122,8 +122,8 @@ test "secp256k1 neutral element decoding" {
 test "secp256k1 double base multiplication" {
     const p1 = Secp256k1.basePoint;
     const p2 = Secp256k1.basePoint.dbl();
-    const s1 = [_]u8{0x01} ** 32;
-    const s2 = [_]u8{0x02} ** 32;
+    const s1: [32]u8 = @splat(0x01);
+    const s2: [32]u8 = @splat(0x02);
     const pr1 = try Secp256k1.mulDoubleBasePublic(p1, s1, p2, s2, .little);
     const pr2 = (try p1.mul(s1, .little)).add(try p2.mul(s2, .little));
     try testing.expect(pr1.equivalent(pr2));

package/std/crypto/salsa20.zig

@@ -384,7 +384,7 @@ pub const XSalsa20Poly1305 = struct {
     pub fn encrypt(c: []u8, tag: *[tag_length]u8, m: []const u8, ad: []const u8, npub: [nonce_length]u8, k: [key_length]u8) void {
         debug.assert(c.len == m.len);
         const extended = extend(rounds, k, npub);
-        var block0 = [_]u8{0} ** 64;
+        var block0: [64]u8 = @splat(0);
         const mlen0 = @min(32, m.len);
         @memcpy(block0[32..][0..mlen0], m[0..mlen0]);
         Salsa20.xor(block0[0..], block0[0..], 0, extended.key, extended.nonce);
@@ -408,7 +408,7 @@ pub const XSalsa20Poly1305 = struct {
     pub fn decrypt(m: []u8, c: []const u8, tag: [tag_length]u8, ad: []const u8, npub: [nonce_length]u8, k: [key_length]u8) AuthenticationError!void {
         debug.assert(c.len == m.len);
         const extended = extend(rounds, k, npub);
-        var block0 = [_]u8{0} ** 64;
+        var block0: [64]u8 = @splat(0);
         const mlen0 = @min(32, c.len);
         @memcpy(block0[32..][0..mlen0], c[0..mlen0]);
         Salsa20.xor(block0[0..], block0[0..], 0, extended.key, extended.nonce);
@@ -489,7 +489,7 @@ pub const Box = struct {
     /// Compute a secret suitable for `secretbox` given a recipient's public key and a sender's secret key.
     pub fn createSharedSecret(public_key: [public_length]u8, secret_key: [secret_length]u8) (IdentityElementError || WeakPublicKeyError)![shared_length]u8 {
         const p = try X25519.scalarmult(secret_key, public_key);
-        const zero = [_]u8{0} ** 16;
+        const zero: [16]u8 = @splat(0);
         return SalsaImpl(20).hsalsa(zero, p);
     }
 
@@ -559,15 +559,15 @@ const htest = @import("test.zig");
 test "(x)salsa20" {
     if (builtin.cpu.has(.riscv, .v) and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest; // https://github.com/ziglang/zig/issues/24299
 
-    const key = [_]u8{0x69} ** 32;
-    const nonce = [_]u8{0x42} ** 8;
-    const msg = [_]u8{0} ** 20;
+    const key: [32]u8 = @splat(0x69);
+    const nonce: [8]u8 = @splat(0x42);
+    const msg: [20]u8 = @splat(0);
     var c: [msg.len]u8 = undefined;
 
     Salsa20.xor(&c, msg[0..], 0, key, nonce);
     try htest.assertEqual("30ff9933aa6534ff5207142593cd1fca4b23bdd8", c[0..]);
 
-    const extended_nonce = [_]u8{0x42} ** 24;
+    const extended_nonce: [24]u8 = @splat(0x42);
     XSalsa20.xor(&c, msg[0..], 0, key, extended_nonce);
     try htest.assertEqual("b4ab7d82e750ec07644fa3281bce6cd91d4243f9", c[0..]);
 }
@@ -637,7 +637,7 @@ test "xsalsa20poly1305 sealedbox" {
 test "secretbox twoblocks" {
     const key = [_]u8{ 0xc9, 0xc9, 0x4d, 0xcf, 0x68, 0xbe, 0x00, 0xe4, 0x7f, 0xe6, 0x13, 0x26, 0xfc, 0xc4, 0x2f, 0xd0, 0xdb, 0x93, 0x91, 0x1c, 0x09, 0x94, 0x89, 0xe1, 0x1b, 0x88, 0x63, 0x18, 0x86, 0x64, 0x8b, 0x7b };
     const nonce = [_]u8{ 0xa4, 0x33, 0xe9, 0x0a, 0x07, 0x68, 0x6e, 0x9a, 0x2b, 0x6d, 0xd4, 0x59, 0x04, 0x72, 0x3e, 0xd3, 0x8a, 0x67, 0x55, 0xc7, 0x9e, 0x3e, 0x77, 0xdc };
-    const msg = [_]u8{'a'} ** 97;
+    const msg: [97]u8 = @splat('a');
     var ciphertext: [msg.len + SecretBox.tag_length]u8 = undefined;
     SecretBox.seal(&ciphertext, &msg, nonce, key);
     try htest.assertEqual("b05760e217288ba079caa2fd57fd3701784974ffcfda20fe523b89211ad8af065a6eb37cdb29d51aca5bd75dafdd21d18b044c54bb7c526cf576c94ee8900f911ceab0147e82b667a28c52d58ceb29554ff45471224d37b03256b01c119b89ff6d36855de8138d103386dbc9d971f52261", &ciphertext);

package/std/crypto/sha2.zig

@@ -461,7 +461,7 @@ test "sha256 streaming" {
 }
 
 test "sha256 aligned final" {
-    var block = [_]u8{0} ** Sha256.block_length;
+    var block: [Sha256.block_length]u8 = @splat(0);
     var out: [Sha256.digest_length]u8 = undefined;
 
     var h = Sha256.init(.{});
@@ -833,7 +833,7 @@ test "sha512 streaming" {
 }
 
 test "sha512 aligned final" {
-    var block = [_]u8{0} ** Sha512.block_length;
+    var block: [Sha512.block_length]u8 = @splat(0);
     var out: [Sha512.digest_length]u8 = undefined;
 
     var h = Sha512.init(.{});

package/std/crypto/sha3.zig

@@ -543,7 +543,7 @@ test "sha3-256 streaming" {
 }
 
 test "sha3-256 aligned final" {
-    var block = [_]u8{0} ** Sha3_256.block_length;
+    var block: [Sha3_256.block_length]u8 = @splat(0);
     var out: [Sha3_256.digest_length]u8 = undefined;
 
     var h = Sha3_256.init(.{});
@@ -616,7 +616,7 @@ test "sha3-512 streaming" {
 }
 
 test "sha3-512 aligned final" {
-    var block = [_]u8{0} ** Sha3_512.block_length;
+    var block: [Sha3_512.block_length]u8 = @splat(0);
     var out: [Sha3_512.digest_length]u8 = undefined;
 
     var h = Sha3_512.init(.{});

package/std/crypto/siphash.zig

@@ -91,7 +91,7 @@ fn SipHashStateless(comptime T: type, comptime c_rounds: usize, comptime d_round
 
             self.msg_len +%= @as(u8, @truncate(b.len));
 
-            var buf = [_]u8{0} ** 8;
+            var buf: [8]u8 = @splat(0);
             @memcpy(buf[0..b.len], b);
             buf[7] = self.msg_len;
             self.round(buf);

package/std/crypto/timing_safe.zig

@@ -207,8 +207,8 @@ test "eql (vectors)" {
 
 test compare {
     const expectEqual = std.testing.expectEqual;
-    var a = [_]u8{10} ** 32;
-    var b = [_]u8{10} ** 32;
+    var a: [32]u8 = @splat(10);
+    var b: [32]u8 = @splat(10);
     try expectEqual(compare(u8, &a, &b, .big), .eq);
     try expectEqual(compare(u8, &a, &b, .little), .eq);
     a[31] = 1;
@@ -228,7 +228,7 @@ test "add and sub" {
     var a: [len]u8 = undefined;
     var b: [len]u8 = undefined;
     var c: [len]u8 = undefined;
-    const zero = [_]u8{0} ** len;
+    const zero: [len]u8 = @splat(0);
     var iterations: usize = 100;
     while (iterations != 0) : (iterations -= 1) {
         io.random(&a);
@@ -262,7 +262,8 @@ test classify {
     declassify(&out);
 
     // Comparing public data in non-constant time is acceptable.
-    try expect(!std.mem.eql(u8, &out, &[_]u8{0} ** out.len));
+    const zeroes: [out.len]u8 = @splat(0);
+    try expect(!std.mem.eql(u8, &out, &zeroes));
 
     // Comparing secret data must be done in constant time. The result
     // is going to be considered as secret as well.

package/std/crypto/tls/Client.zig

@@ -375,7 +375,7 @@ pub fn init(input: *Reader, output: *Writer, options: Options) InitError!Client
                         const auth_tag = record_decoder.array(P.AEAD.tag_length).*;
                         const nonce = nonce: {
                             const V = @Vector(P.AEAD.nonce_length, u8);
-                            const pad = [1]u8{0} ** (P.AEAD.nonce_length - 8);
+                            const pad: [P.AEAD.nonce_length - 8]u8 = @splat(0);
                             const operand: V = pad ++ @as([8]u8, @bitCast(big(read_seq)));
                             break :nonce @as(V, pv.server_handshake_iv) ^ operand;
                         };
@@ -415,7 +415,7 @@ pub fn init(input: *Reader, output: *Writer, options: Options) InitError!Client
                             comptime std.math.shl(u64, std.math.maxInt(u64), 8 * P.record_iv_length);
                         const nonce: [P.AEAD.nonce_length]u8 = nonce: {
                             const V = @Vector(P.AEAD.nonce_length, u8);
-                            const pad = [1]u8{0} ** (P.AEAD.nonce_length - 8);
+                            const pad: [P.AEAD.nonce_length - 8]u8 = @splat(0);
                             const operand: V = pad ++ @as([8]u8, @bitCast(big(masked_read_seq)));
                             break :nonce @as(V, pv.app_cipher.server_write_IV ++ record_iv) ^ operand;
                         };
@@ -539,7 +539,7 @@ pub fn init(input: *Reader, output: *Writer, options: Options) InitError!Client
                                         const p = &@field(handshake_cipher, @tagName(tag.with()));
                                         const P = @TypeOf(p.*).A;
                                         const hello_hash = p.transcript_hash.peek();
-                                        const zeroes = [1]u8{0} ** P.Hash.digest_length;
+                                        const zeroes: [P.Hash.digest_length]u8 = @splat(0);
                                         const early_secret = P.Hkdf.extract(&[1]u8{0}, &zeroes);
                                         const empty_hash = tls.emptyHash(P.Hash);
                                         p.version = .{ .tls_1_3 = undefined };
@@ -791,7 +791,7 @@ pub fn init(input: *Reader, output: *Writer, options: Options) InitError!Client
                                 const pv = &p.version.tls_1_2;
                                 const nonce: [P.AEAD.nonce_length]u8 = nonce: {
                                     const V = @Vector(P.AEAD.nonce_length, u8);
-                                    const pad = [1]u8{0} ** (P.AEAD.nonce_length - 8);
+                                    const pad: [P.AEAD.nonce_length - 8]u8 = @splat(0);
                                     const operand: V = pad ++ @as([8]u8, @bitCast(big(write_seq)));
                                     break :nonce @as(V, pv.app_cipher.client_write_IV ++ pv.app_cipher.client_salt) ^ operand;
                                 };
@@ -832,8 +832,9 @@ pub fn init(input: *Reader, output: *Writer, options: Options) InitError!Client
                         }
                         switch (handshake_cipher) {
                             inline else => |*p| {
+                                const pad: [64]u8 = @splat(' ');
                                 try main_cert_pub_key.verifySignature(&hsd, &.{
-                                    " " ** 64 ++ "TLS 1.3, server CertificateVerify\x00",
+                                    pad ++ "TLS 1.3, server CertificateVerify\x00",
                                     &p.transcript_hash.peek(),
                                 });
                                 p.transcript_hash.update(wrapped_handshake);
@@ -1066,7 +1067,7 @@ fn prepareCiphertextRecord(
                     ciphertext_end += auth_tag.len;
                     const nonce = nonce: {
                         const V = @Vector(P.AEAD.nonce_length, u8);
-                        const pad = [1]u8{0} ** (P.AEAD.nonce_length - 8);
+                        const pad: [P.AEAD.nonce_length - 8]u8 = @splat(0);
                         const operand: V = pad ++ mem.toBytes(big(c.write_seq));
                         break :nonce @as(V, pv.client_iv) ^ operand;
                     };
@@ -1103,7 +1104,7 @@ fn prepareCiphertextRecord(
                     ciphertext_end += P.record_iv_length;
                     const nonce: [P.AEAD.nonce_length]u8 = nonce: {
                         const V = @Vector(P.AEAD.nonce_length, u8);
-                        const pad = [1]u8{0} ** (P.AEAD.nonce_length - 8);
+                        const pad: [P.AEAD.nonce_length - 8]u8 = @splat(0);
                         const operand: V = pad ++ @as([8]u8, @bitCast(big(c.write_seq)));
                         break :nonce @as(V, pv.client_write_IV ++ pv.client_salt) ^ operand;
                     };
@@ -1185,7 +1186,7 @@ fn readIndirect(c: *Client) Reader.Error!usize {
                 const auth_tag = (input.takeArray(P.AEAD.tag_length) catch unreachable).*; // already peeked
                 const nonce = nonce: {
                     const V = @Vector(P.AEAD.nonce_length, u8);
-                    const pad = [1]u8{0} ** (P.AEAD.nonce_length - 8);
+                    const pad: [P.AEAD.nonce_length - 8]u8 = @splat(0);
                     const operand: V = pad ++ mem.toBytes(big(c.read_seq));
                     break :nonce @as(V, pv.server_iv) ^ operand;
                 };
@@ -1211,7 +1212,7 @@ fn readIndirect(c: *Client) Reader.Error!usize {
                     comptime std.math.shl(u64, std.math.maxInt(u64), 8 * P.record_iv_length);
                 const nonce: [P.AEAD.nonce_length]u8 = nonce: {
                     const V = @Vector(P.AEAD.nonce_length, u8);
-                    const pad = [1]u8{0} ** (P.AEAD.nonce_length - 8);
+                    const pad: [P.AEAD.nonce_length - 8]u8 = @splat(0);
                     const operand: V = pad ++ @as([8]u8, @bitCast(big(masked_read_seq)));
                     break :nonce @as(V, pv.server_write_IV ++ record_iv) ^ operand;
                 };

package/std/crypto.zig

@@ -394,7 +394,7 @@ test "issue #4532: no index out of bounds" {
     };
 
     inline for (types) |Hasher| {
-        var block = [_]u8{'#'} ** Hasher.block_length;
+        var block: [Hasher.block_length]u8 = @splat('#');
         var out1: [Hasher.digest_length]u8 = undefined;
         var out2: [Hasher.digest_length]u8 = undefined;
         const h0 = Hasher.init(.{});
@@ -417,8 +417,8 @@ pub fn secureZero(comptime T: type, s: []volatile T) void {
 }
 
 test secureZero {
-    var a = [_]u8{0xfe} ** 8;
-    var b = [_]u8{0xfe} ** 8;
+    var a: [8]u8 = @splat(0xFE);
+    var b: [8]u8 = @splat(0xFE);
 
     @memset(&a, 0);
     secureZero(u8, &b);

package/std/debug/Dwarf.zig

@@ -1346,7 +1346,7 @@ const FileEntry = struct {
     dir_index: u32 = 0,
     mtime: u64 = 0,
     size: u64 = 0,
-    md5: [16]u8 = [1]u8{0} ** 16,
+    md5: [16]u8 = @splat(0),
 };
 
 const LineNumberProgram = struct {

package/std/debug.zig

@@ -1381,7 +1381,7 @@ test printLineFromFile {
         try writer.flush();
 
         try printLineFromFile(io, output_stream, .{ .file_name = path, .line = 2, .column = 0 });
-        try expectEqualStrings(("a" ** overlap) ++ "\n", aw.written());
+        try expectEqualStrings(&@as([overlap]u8, @splat('a')) ++ "\n", aw.written());
         aw.clearRetainingCapacity();
     }
     {
@@ -1395,7 +1395,7 @@ test printLineFromFile {
         try writer.splatByteAll('a', std.heap.page_size_max);
 
         try printLineFromFile(io, output_stream, .{ .file_name = path, .line = 1, .column = 0 });
-        try expectEqualStrings(("a" ** std.heap.page_size_max) ++ "\n", aw.written());
+        try expectEqualStrings(&@as([std.heap.page_size_max]u8, @splat('a')) ++ "\n", aw.written());
         aw.clearRetainingCapacity();
     }
     {
@@ -1410,14 +1410,16 @@ test printLineFromFile {
 
         try expectError(error.EndOfStream, printLineFromFile(io, output_stream, .{ .file_name = path, .line = 2, .column = 0 }));
 
+        const many_a: [3 * std.heap.page_size_max]u8 = @splat('a');
+
         try printLineFromFile(io, output_stream, .{ .file_name = path, .line = 1, .column = 0 });
-        try expectEqualStrings(("a" ** (3 * std.heap.page_size_max)) ++ "\n", aw.written());
+        try expectEqualStrings(&many_a ++ "\n", aw.written());
         aw.clearRetainingCapacity();
 
         try writer.writeAll("a\na");
 
         try printLineFromFile(io, output_stream, .{ .file_name = path, .line = 1, .column = 0 });
-        try expectEqualStrings(("a" ** (3 * std.heap.page_size_max)) ++ "a\n", aw.written());
+        try expectEqualStrings(&many_a ++ "a\n", aw.written());
         aw.clearRetainingCapacity();
 
         try printLineFromFile(io, output_stream, .{ .file_name = path, .line = 2, .column = 0 });

package/std/elf.zig

@@ -3054,7 +3054,7 @@ pub const ar_hdr = extern struct {
 fn genSpecialMemberName(comptime name: []const u8) *const [16]u8 {
     assert(name.len <= 16);
     const padding = 16 - name.len;
-    return name ++ &[_]u8{0x20} ** padding;
+    return name ++ @as([padding]u8, @splat(0x20));
 }
 
 // Archive files start with the ARMAG identifying string.  Then follows a

package/std/enums.zig

@@ -166,7 +166,7 @@ pub fn directEnumArrayDefault(
     init_values: EnumFieldStruct(E, Data, default),
 ) [directEnumArrayLen(E, max_unused_slots)]Data {
     const len = comptime directEnumArrayLen(E, max_unused_slots);
-    var result: [len]Data = if (default) |d| [_]Data{d} ** len else undefined;
+    var result: [len]Data = @splat(default orelse undefined);
     inline for (@typeInfo(@TypeOf(init_values)).@"struct".fields) |f| {
         const enum_value = @field(E, f.name);
         const index = @as(usize, @intCast(@intFromEnum(enum_value)));

package/std/fmt/parse_float/decimal.zig

@@ -80,7 +80,7 @@ pub fn Decimal(comptime T: type) type {
                 .num_digits = 0,
                 .decimal_point = 0,
                 .truncated = false,
-                .digits = [_]u8{0} ** max_digits,
+                .digits = @splat(0),
             };
         }
 

package/std/fmt.zig

@@ -1194,8 +1194,12 @@ test bytesToHex {
 }
 
 test hexToBytes {
+    const repeated: []const u8 = repeated: {
+        const buf: [32][2]u8 = @splat("90".*);
+        break :repeated @ptrCast(&buf);
+    };
     var buf: [32]u8 = undefined;
-    try expectFmt("90" ** 32, "{X}", .{try hexToBytes(&buf, "90" ** 32)});
+    try expectFmt(repeated, "{X}", .{try hexToBytes(&buf, repeated)});
     try expectFmt("ABCD", "{X}", .{try hexToBytes(&buf, "ABCD")});
     try expectFmt("", "{X}", .{try hexToBytes(&buf, "")});
     try std.testing.expectError(error.InvalidCharacter, hexToBytes(&buf, "012Z"));

package/std/hash/Adler32.zig

@@ -88,15 +88,15 @@ test "sanity" {
 }
 
 test "long" {
-    const long1 = [_]u8{1} ** 1024;
+    const long1: [1024]u8 = @splat(1);
     try testing.expectEqual(@as(u32, 0x06780401), hash(long1[0..]));
 
-    const long2 = [_]u8{1} ** 1025;
+    const long2: [1025]u8 = @splat(1);
     try testing.expectEqual(@as(u32, 0x0a7a0402), hash(long2[0..]));
 }
 
 test "very long" {
-    const long = [_]u8{1} ** 5553;
+    const long: [5553]u8 = @splat(1);
     try testing.expectEqual(@as(u32, 0x707f15b2), hash(long[0..]));
 }
 

package/std/hash/benchmark.zig

@@ -93,13 +93,13 @@ const hashes = [_]Hash{
         .ty = hash.SipHash64(1, 3),
         .name = "siphash64",
         .has_crypto_api = true,
-        .init_u8s = &[_]u8{0} ** 16,
+        .init_u8s = &@as([16]u8, @splat(0)),
     },
     Hash{
         .ty = hash.SipHash128(1, 3),
         .name = "siphash128",
         .has_crypto_api = true,
-        .init_u8s = &[_]u8{0} ** 16,
+        .init_u8s = &@as([16]u8, @splat(0)),
     },
 };
 

package/std/hash/wyhash.zig

@@ -253,7 +253,7 @@ test "iterative api" {
 }
 
 test "iterative maintains last sixteen" {
-    const input = "Z" ** 48 ++ "01234567890abcdefg";
+    const input = &@as([48]u8, @splat('Z')) ++ "01234567890abcdefg";
     const seed = 0;
 
     for (0..17) |i| {

package/std/heap/debug_allocator.zig

@@ -164,7 +164,7 @@ pub fn DebugAllocator(comptime config: Config) type {
     return struct {
         backing_allocator: Allocator = std.heap.page_allocator,
         /// Tracks the active bucket, which is the one that has free slots in it.
-        buckets: [small_bucket_count]?*BucketHeader = [1]?*BucketHeader{null} ** small_bucket_count,
+        buckets: [small_bucket_count]?*BucketHeader = @splat(null),
         large_allocations: LargeAllocTable = .empty,
         total_requested_bytes: @TypeOf(total_requested_bytes_init) = total_requested_bytes_init,
         requested_memory_limit: @TypeOf(requested_memory_limit_init) = requested_memory_limit_init,

package/std/http.zig

@@ -749,7 +749,7 @@ pub const BodyWriter = struct {
     /// How many zeroes to reserve for hex-encoded chunk length.
     const chunk_len_digits = 8;
     const max_chunk_len: usize = std.math.pow(u64, 16, chunk_len_digits) - 1;
-    const chunk_header_template = ("0" ** chunk_len_digits) ++ "\r\n";
+    const chunk_header_template = @as([chunk_len_digits]u8, @splat('0')) ++ "\r\n";
 
     comptime {
         assert(max_chunk_len == std.math.maxInt(u32));

package/std/json/static.zig

@@ -334,7 +334,7 @@ pub fn innerParse(
             if (.object_begin != try source.next()) return error.UnexpectedToken;
 
             var r: T = undefined;
-            var fields_seen = [_]bool{false} ** structInfo.fields.len;
+            var fields_seen: [structInfo.fields.len]bool = @splat(false);
 
             while (true) {
                 var name_token: ?Token = try source.nextAllocMax(allocator, .alloc_if_needed, options.max_value_len.?);
@@ -649,7 +649,7 @@ pub fn innerParseFromValue(
             if (source != .object) return error.UnexpectedToken;
 
             var r: T = undefined;
-            var fields_seen = [_]bool{false} ** structInfo.fields.len;
+            var fields_seen: [structInfo.fields.len]bool = @splat(false);
 
             var it = source.object.iterator();
             while (it.next()) |kv| {

package/std/math/big/int.zig

@@ -29,8 +29,8 @@ const Constants = struct {
 };
 const constants: Constants = blk: {
     @setEvalBranchQuota(2000);
-    var digits_per_limb = [_]u8{0} ** 37;
-    var bases = [_]Limb{0} ** 37;
+    var digits_per_limb: [37]u8 = @splat(0);
+    var bases: [37]Limb = @splat(0);
     for (2..37) |base| {
         digits_per_limb[base] = @intCast(math.log(Limb, base, math.maxInt(Limb)));
         bases[base] = std.math.pow(Limb, base, digits_per_limb[base]);
@@ -2391,7 +2391,7 @@ pub const Const = struct {
         var limbs: [calcToStringLimbsBufferLen(available_len, 10)]Limb = undefined;
 
         const biggest: Const = .{
-            .limbs = &([1]Limb{comptime math.maxInt(Limb)} ** available_len),
+            .limbs = &@as([available_len]Limb, @splat(comptime math.maxInt(Limb))),
             .positive = false,
         };
         var buf: [biggest.sizeInBaseUpperBound(2)]u8 = undefined;

package/std/math/nextafter.zig

@@ -23,7 +23,7 @@ pub fn nextAfter(comptime T: type, x: T, y: T) T {
 fn nextAfterInt(comptime T: type, x: T, y: T) T {
     comptime assert(@typeInfo(T) == .int or @typeInfo(T) == .comptime_int);
     return if (@typeInfo(T) == .int and @bitSizeOf(T) < 2)
-        // Special case for `i0`, `u0`, `i1`, and `u1`.
+        // Special case for `u0`, `i1`, and `u1`.
         y
     else if (y > x)
         x + 1
@@ -102,7 +102,6 @@ fn nextAfterFloat(comptime T: type, x: T, y: T) T {
 }
 
 test "int" {
-    try expect(nextAfter(i0, 0, 0) == 0);
     try expect(nextAfter(u0, 0, 0) == 0);
     try expect(nextAfter(i1, 0, 0) == 0);
     try expect(nextAfter(i1, 0, -1) == -1);

package/std/math/powi.zig

@@ -15,12 +15,12 @@ const testing = std.testing;
 ///  - Underflow: Absolute value of result smaller than 1
 ///
 /// Edge case rules ordered by precedence:
-///  - powi(T, x, 0)   = 1 unless T is i1, i0, u0
+///  - powi(T, x, 0)   = 1 unless T is i1, u0
 ///  - powi(T, 0, x)   = 0 when x > 0
 ///  - powi(T, 0, x)   = Overflow
 ///  - powi(T, 1, y)   = 1
 ///  - powi(T, -1, y)  = -1 for y an odd integer
-///  - powi(T, -1, y)  = 1 unless T is i1, i0, u0
+///  - powi(T, -1, y)  = 1 unless T is i1, u0
 ///  - powi(T, -1, y)  = Overflow
 ///  - powi(T, x, y)   = Overflow when y >= @bitSizeOf(x)
 ///  - powi(T, x, y)   = Underflow when y < 0
@@ -189,7 +189,6 @@ test "powi.special" {
 
 test "powi.narrow" {
     try testing.expectError(error.Overflow, powi(u0, 0, 0));
-    try testing.expectError(error.Overflow, powi(i0, 0, 0));
     try testing.expectError(error.Overflow, powi(i1, 0, 0));
     try testing.expectError(error.Overflow, powi(i1, -1, 0));
     try testing.expectError(error.Overflow, powi(i1, 0, -1));

package/std/math/signbit.zig

@@ -13,7 +13,6 @@ pub fn signbit(x: anytype) bool {
 }
 
 test signbit {
-    try testInts(i0);
     try testInts(u0);
     try testInts(i1);
     try testInts(u1);

package/std/math.zig

@@ -1141,13 +1141,11 @@ test isPowerOfTwo {
 pub fn ByteAlignedInt(comptime T: type) type {
     const info = @typeInfo(T).int;
     const bits = (info.bits + 7) / 8 * 8;
-    const extended_type = std.meta.Int(info.signedness, bits);
-    return extended_type;
+    return @Int(info.signedness, bits);
 }
 
 test ByteAlignedInt {
     try testing.expect(ByteAlignedInt(u0) == u0);
-    try testing.expect(ByteAlignedInt(i0) == i0);
     try testing.expect(ByteAlignedInt(u3) == u8);
     try testing.expect(ByteAlignedInt(u8) == u8);
     try testing.expect(ByteAlignedInt(i111) == i112);
@@ -1218,7 +1216,7 @@ pub fn ceilPowerOfTwoPromote(comptime T: type, value: T) std.meta.Int(@typeInfo(
     comptime assert(@typeInfo(T) == .int);
     comptime assert(@typeInfo(T).int.signedness == .unsigned);
     assert(value != 0);
-    const PromotedType = std.meta.Int(@typeInfo(T).int.signedness, @typeInfo(T).int.bits + 1);
+    const PromotedType = @Int(@typeInfo(T).int.signedness, @typeInfo(T).int.bits + 1);
     const ShiftType = std.math.Log2Int(PromotedType);
     return @as(PromotedType, 1) << @as(ShiftType, @intCast(@typeInfo(T).int.bits - @clz(value - 1)));
 }
@@ -1230,7 +1228,7 @@ pub fn ceilPowerOfTwo(comptime T: type, value: T) (error{Overflow}!T) {
     comptime assert(@typeInfo(T) == .int);
     const info = @typeInfo(T).int;
     comptime assert(info.signedness == .unsigned);
-    const PromotedType = std.meta.Int(info.signedness, info.bits + 1);
+    const PromotedType = @Int(info.signedness, info.bits + 1);
     const overflowBit = @as(PromotedType, 1) << info.bits;
     const x = ceilPowerOfTwoPromote(T, value);
     if (overflowBit & x != 0) {
@@ -1442,19 +1440,17 @@ test lerp {
 
 /// Returns the maximum value of integer type T.
 pub fn maxInt(comptime T: type) comptime_int {
-    const info = @typeInfo(T);
-    const bit_count = info.int.bits;
-    if (bit_count == 0) return 0;
-    return (1 << (bit_count - @intFromBool(info.int.signedness == .signed))) - 1;
+    const info = @typeInfo(T).int;
+    return (1 << (info.bits - @intFromBool(info.signedness == .signed))) - 1;
 }
 
 /// Returns the minimum value of integer type T.
 pub fn minInt(comptime T: type) comptime_int {
-    const info = @typeInfo(T);
-    const bit_count = info.int.bits;
-    if (info.int.signedness == .unsigned) return 0;
-    if (bit_count == 0) return 0;
-    return -(1 << (bit_count - 1));
+    const info = @typeInfo(T).int;
+    return switch (info.signedness) {
+        .unsigned => 0,
+        .signed => -(1 << (info.bits - 1)),
+    };
 }
 
 test maxInt {
@@ -1466,7 +1462,6 @@ test maxInt {
     try testing.expect(maxInt(u64) == 18446744073709551615);
     try testing.expect(maxInt(u128) == 340282366920938463463374607431768211455);
 
-    try testing.expect(maxInt(i0) == 0);
     try testing.expect(maxInt(i1) == 0);
     try testing.expect(maxInt(i8) == 127);
     try testing.expect(maxInt(i16) == 32767);
@@ -1486,7 +1481,6 @@ test minInt {
     try testing.expect(minInt(u64) == 0);
     try testing.expect(minInt(u128) == 0);
 
-    try testing.expect(minInt(i0) == 0);
     try testing.expect(minInt(i1) == -1);
     try testing.expect(minInt(i8) == -128);
     try testing.expect(minInt(i16) == -32768);
@@ -1710,8 +1704,8 @@ pub inline fn boolMask(comptime MaskInt: type, value: bool) MaskInt {
     if (@typeInfo(MaskInt) != .int)
         @compileError("boolMask requires an integer mask type.");
 
-    if (MaskInt == u0 or MaskInt == i0)
-        @compileError("boolMask cannot convert to u0 or i0, they are too small.");
+    if (MaskInt == u0)
+        @compileError("boolMask cannot convert to u0, it is too small.");
 
     // The u1 and i1 cases tend to overflow,
     // so we special case them here.