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

package/std/crypto/blake2.zig

@@ -199,7 +199,9 @@ test "blake2s160 single" {
     try htest.assertEqualHash(Blake2s160, h3, "The quick brown fox jumps over the lazy dog");
 
     const h4 = "b60c4dc60e2681e58fbc24e77f07e02c69e72ed0";
-    try htest.assertEqualHash(Blake2s160, h4, "a" ** 32 ++ "b" ** 32);
+    const repeat_a_32: [32]u8 = @splat('a');
+    const repeat_b_32: [32]u8 = @splat('b');
+    try htest.assertEqualHash(Blake2s160, h4, &repeat_a_32 ++ &repeat_b_32);
 }
 
 test "blake2s160 streaming" {
@@ -227,27 +229,30 @@ test "blake2s160 streaming" {
 
     const h3 = "b60c4dc60e2681e58fbc24e77f07e02c69e72ed0";
 
+    const repeat_a_32: [32]u8 = @splat('a');
+    const repeat_b_32: [32]u8 = @splat('b');
+
     h = Blake2s160.init(.{});
-    h.update("a" ** 32);
-    h.update("b" ** 32);
+    h.update(&repeat_a_32);
+    h.update(&repeat_b_32);
     h.final(out[0..]);
     try htest.assertEqual(h3, out[0..]);
 
     h = Blake2s160.init(.{});
-    h.update("a" ** 32 ++ "b" ** 32);
+    h.update(&repeat_a_32 ++ &repeat_b_32);
     h.final(out[0..]);
     try htest.assertEqual(h3, out[0..]);
 
     const h4 = "4667fd60791a7fe41f939bca646b4529e296bd68";
 
-    h = Blake2s160.init(.{ .context = [_]u8{0x69} ** 8, .salt = [_]u8{0x42} ** 8 });
-    h.update("a" ** 32);
-    h.update("b" ** 32);
+    h = Blake2s160.init(.{ .context = @splat(0x69), .salt = @splat(0x42) });
+    h.update(&repeat_a_32);
+    h.update(&repeat_b_32);
     h.final(out[0..]);
     try htest.assertEqual(h4, out[0..]);
 
-    h = Blake2s160.init(.{ .context = [_]u8{0x69} ** 8, .salt = [_]u8{0x42} ** 8 });
-    h.update("a" ** 32 ++ "b" ** 32);
+    h = Blake2s160.init(.{ .context = @splat(0x69), .salt = @splat(0x42) });
+    h.update(&repeat_a_32 ++ &repeat_b_32);
     h.final(out[0..]);
     try htest.assertEqual(h4, out[0..]);
 }
@@ -256,7 +261,7 @@ test "comptime blake2s160" {
     //comptime
     {
         @setEvalBranchQuota(10000);
-        var block = [_]u8{0} ** Blake2s160.block_length;
+        var block: [Blake2s160.block_length]u8 = @splat(0);
         var out: [Blake2s160.digest_length]u8 = undefined;
 
         const h1 = "2c56ad9d0b2c8b474aafa93ab307db2f0940105f";
@@ -282,7 +287,9 @@ test "blake2s224 single" {
     try htest.assertEqualHash(Blake2s224, h3, "The quick brown fox jumps over the lazy dog");
 
     const h4 = "557381a78facd2b298640f4e32113e58967d61420af1aa939d0cfe01";
-    try htest.assertEqualHash(Blake2s224, h4, "a" ** 32 ++ "b" ** 32);
+    const repeat_a_32: [32]u8 = @splat('a');
+    const repeat_b_32: [32]u8 = @splat('b');
+    try htest.assertEqualHash(Blake2s224, h4, &repeat_a_32 ++ &repeat_b_32);
 }
 
 test "blake2s224 streaming" {
@@ -308,29 +315,32 @@ test "blake2s224 streaming" {
     h.final(out[0..]);
     try htest.assertEqual(h2, out[0..]);
 
+    const repeat_a_32: [32]u8 = @splat('a');
+    const repeat_b_32: [32]u8 = @splat('b');
+
     const h3 = "557381a78facd2b298640f4e32113e58967d61420af1aa939d0cfe01";
 
     h = Blake2s224.init(.{});
-    h.update("a" ** 32);
-    h.update("b" ** 32);
+    h.update(&repeat_a_32);
+    h.update(&repeat_b_32);
     h.final(out[0..]);
     try htest.assertEqual(h3, out[0..]);
 
     h = Blake2s224.init(.{});
-    h.update("a" ** 32 ++ "b" ** 32);
+    h.update(&repeat_a_32 ++ &repeat_b_32);
     h.final(out[0..]);
     try htest.assertEqual(h3, out[0..]);
 
     const h4 = "a4d6a9d253441b80e5dfd60a04db169ffab77aec56a2855c402828c3";
 
-    h = Blake2s224.init(.{ .context = [_]u8{0x69} ** 8, .salt = [_]u8{0x42} ** 8 });
-    h.update("a" ** 32);
-    h.update("b" ** 32);
+    h = Blake2s224.init(.{ .context = @splat(0x69), .salt = @splat(0x42) });
+    h.update(&repeat_a_32);
+    h.update(&repeat_b_32);
     h.final(out[0..]);
     try htest.assertEqual(h4, out[0..]);
 
-    h = Blake2s224.init(.{ .context = [_]u8{0x69} ** 8, .salt = [_]u8{0x42} ** 8 });
-    h.update("a" ** 32 ++ "b" ** 32);
+    h = Blake2s224.init(.{ .context = @splat(0x69), .salt = @splat(0x42) });
+    h.update(&repeat_a_32 ++ &repeat_b_32);
     h.final(out[0..]);
     try htest.assertEqual(h4, out[0..]);
 }
@@ -338,7 +348,7 @@ test "blake2s224 streaming" {
 test "comptime blake2s224" {
     comptime {
         @setEvalBranchQuota(10000);
-        var block = [_]u8{0} ** Blake2s224.block_length;
+        var block: [Blake2s224.block_length]u8 = @splat(0);
         var out: [Blake2s224.digest_length]u8 = undefined;
 
         const h1 = "86b7611563293f8c73627df7a6d6ba25ca0548c2a6481f7d116ee576";
@@ -364,7 +374,9 @@ test "blake2s256 single" {
     try htest.assertEqualHash(Blake2s256, h3, "The quick brown fox jumps over the lazy dog");
 
     const h4 = "8d8711dade07a6b92b9a3ea1f40bee9b2c53ff3edd2a273dec170b0163568977";
-    try htest.assertEqualHash(Blake2s256, h4, "a" ** 32 ++ "b" ** 32);
+    const repeat_a_32: [32]u8 = @splat('a');
+    const repeat_b_32: [32]u8 = @splat('b');
+    try htest.assertEqualHash(Blake2s256, h4, &repeat_a_32 ++ &repeat_b_32);
 }
 
 test "blake2s256 streaming" {
@@ -390,16 +402,19 @@ test "blake2s256 streaming" {
     h.final(out[0..]);
     try htest.assertEqual(h2, out[0..]);
 
+    const repeat_a_32: [32]u8 = @splat('a');
+    const repeat_b_32: [32]u8 = @splat('b');
+
     const h3 = "8d8711dade07a6b92b9a3ea1f40bee9b2c53ff3edd2a273dec170b0163568977";
 
     h = Blake2s256.init(.{});
-    h.update("a" ** 32);
-    h.update("b" ** 32);
+    h.update(&repeat_a_32);
+    h.update(&repeat_b_32);
     h.final(out[0..]);
     try htest.assertEqual(h3, out[0..]);
 
     h = Blake2s256.init(.{});
-    h.update("a" ** 32 ++ "b" ** 32);
+    h.update(&repeat_a_32 ++ &repeat_b_32);
     h.final(out[0..]);
     try htest.assertEqual(h3, out[0..]);
 }
@@ -410,18 +425,21 @@ test "blake2s256 keyed" {
     const h1 = "10f918da4d74fab3302e48a5d67d03804b1ec95372a62a0f33b7c9fa28ba1ae6";
     const key = "secret_key";
 
-    Blake2s256.hash("a" ** 64 ++ "b" ** 64, &out, .{ .key = key });
+    const repeat_a_64: [64]u8 = @splat('a');
+    const repeat_b_64: [64]u8 = @splat('b');
+
+    Blake2s256.hash(&repeat_a_64 ++ &repeat_b_64, &out, .{ .key = key });
     try htest.assertEqual(h1, out[0..]);
 
     var h = Blake2s256.init(.{ .key = key });
-    h.update("a" ** 64 ++ "b" ** 64);
+    h.update(&repeat_a_64 ++ &repeat_b_64);
     h.final(out[0..]);
 
     try htest.assertEqual(h1, out[0..]);
 
     h = Blake2s256.init(.{ .key = key });
-    h.update("a" ** 64);
-    h.update("b" ** 64);
+    h.update(&repeat_a_64);
+    h.update(&repeat_b_64);
     h.final(out[0..]);
 
     try htest.assertEqual(h1, out[0..]);
@@ -430,7 +448,7 @@ test "blake2s256 keyed" {
 test "comptime blake2s256" {
     comptime {
         @setEvalBranchQuota(10000);
-        var block = [_]u8{0} ** Blake2s256.block_length;
+        var block: [Blake2s256.block_length]u8 = @splat(0);
         var out: [Blake2s256.digest_length]u8 = undefined;
 
         const h1 = "ae09db7cd54f42b490ef09b6bc541af688e4959bb8c53f359a6f56e38ab454a3";
@@ -623,7 +641,9 @@ test "blake2b160 single" {
     try htest.assertEqualHash(Blake2b160, h3, "The quick brown fox jumps over the lazy dog");
 
     const h4 = "43758f5de1740f651f1ae39de92260fe8bd5a11f";
-    try htest.assertEqualHash(Blake2b160, h4, "a" ** 64 ++ "b" ** 64);
+    const repeat_a_64: [64]u8 = @splat('a');
+    const repeat_b_64: [64]u8 = @splat('b');
+    try htest.assertEqualHash(Blake2b160, h4, &repeat_a_64 ++ &repeat_b_64);
 }
 
 test "blake2b160 streaming" {
@@ -649,36 +669,39 @@ test "blake2b160 streaming" {
     h.final(out[0..]);
     try htest.assertEqual(h2, out[0..]);
 
+    const repeat_a_64: [64]u8 = @splat('a');
+    const repeat_b_64: [64]u8 = @splat('b');
+
     const h3 = "43758f5de1740f651f1ae39de92260fe8bd5a11f";
 
     h = Blake2b160.init(.{});
-    h.update("a" ** 64 ++ "b" ** 64);
+    h.update(&repeat_a_64 ++ &repeat_b_64);
     h.final(out[0..]);
     try htest.assertEqual(h3, out[0..]);
 
     h = Blake2b160.init(.{});
-    h.update("a" ** 64);
-    h.update("b" ** 64);
+    h.update(&repeat_a_64);
+    h.update(&repeat_b_64);
     h.final(out[0..]);
     try htest.assertEqual(h3, out[0..]);
 
     h = Blake2b160.init(.{});
-    h.update("a" ** 64);
-    h.update("b" ** 64);
+    h.update(&repeat_a_64);
+    h.update(&repeat_b_64);
     h.final(out[0..]);
     try htest.assertEqual(h3, out[0..]);
 
     const h4 = "72328f8a8200663752fc302d372b5dd9b49dd8dc";
 
-    h = Blake2b160.init(.{ .context = [_]u8{0x69} ** 16, .salt = [_]u8{0x42} ** 16 });
-    h.update("a" ** 64);
-    h.update("b" ** 64);
+    h = Blake2b160.init(.{ .context = @splat(0x69), .salt = @splat(0x42) });
+    h.update(&repeat_a_64);
+    h.update(&repeat_b_64);
     h.final(out[0..]);
     try htest.assertEqual(h4, out[0..]);
 
-    h = Blake2b160.init(.{ .context = [_]u8{0x69} ** 16, .salt = [_]u8{0x42} ** 16 });
-    h.update("a" ** 64);
-    h.update("b" ** 64);
+    h = Blake2b160.init(.{ .context = @splat(0x69), .salt = @splat(0x42) });
+    h.update(&repeat_a_64);
+    h.update(&repeat_b_64);
     h.final(out[0..]);
     try htest.assertEqual(h4, out[0..]);
 }
@@ -686,7 +709,7 @@ test "blake2b160 streaming" {
 test "comptime blake2b160" {
     comptime {
         @setEvalBranchQuota(10000);
-        var block = [_]u8{0} ** Blake2b160.block_length;
+        var block: [Blake2b160.block_length]u8 = @splat(0);
         var out: [Blake2b160.digest_length]u8 = undefined;
 
         const h1 = "8d26f158f564e3293b42f5e3d34263cb173aa9c9";
@@ -712,7 +735,9 @@ test "blake2b384 single" {
     try htest.assertEqualHash(Blake2b384, h3, "The quick brown fox jumps over the lazy dog");
 
     const h4 = "b7283f0172fecbbd7eca32ce10d8a6c06b453cb3cf675b33eb4246f0da2bb94a6c0bdd6eec0b5fd71ec4fd51be80bf4c";
-    try htest.assertEqualHash(Blake2b384, h4, "a" ** 64 ++ "b" ** 64);
+    const repeat_a_64: [64]u8 = @splat('a');
+    const repeat_b_64: [64]u8 = @splat('b');
+    try htest.assertEqualHash(Blake2b384, h4, &repeat_a_64 ++ &repeat_b_64);
 }
 
 test "blake2b384 streaming" {
@@ -738,36 +763,39 @@ test "blake2b384 streaming" {
     h.final(out[0..]);
     try htest.assertEqual(h2, out[0..]);
 
+    const repeat_a_64: [64]u8 = @splat('a');
+    const repeat_b_64: [64]u8 = @splat('b');
+
     const h3 = "b7283f0172fecbbd7eca32ce10d8a6c06b453cb3cf675b33eb4246f0da2bb94a6c0bdd6eec0b5fd71ec4fd51be80bf4c";
 
     h = Blake2b384.init(.{});
-    h.update("a" ** 64 ++ "b" ** 64);
+    h.update(&repeat_a_64 ++ &repeat_b_64);
     h.final(out[0..]);
     try htest.assertEqual(h3, out[0..]);
 
     h = Blake2b384.init(.{});
-    h.update("a" ** 64);
-    h.update("b" ** 64);
+    h.update(&repeat_a_64);
+    h.update(&repeat_b_64);
     h.final(out[0..]);
     try htest.assertEqual(h3, out[0..]);
 
     h = Blake2b384.init(.{});
-    h.update("a" ** 64);
-    h.update("b" ** 64);
+    h.update(&repeat_a_64);
+    h.update(&repeat_b_64);
     h.final(out[0..]);
     try htest.assertEqual(h3, out[0..]);
 
     const h4 = "934c48fcb197031c71f583d92f98703510805e72142e0b46f5752d1e971bc86c355d556035613ff7a4154b4de09dac5c";
 
-    h = Blake2b384.init(.{ .context = [_]u8{0x69} ** 16, .salt = [_]u8{0x42} ** 16 });
-    h.update("a" ** 64);
-    h.update("b" ** 64);
+    h = Blake2b384.init(.{ .context = @splat(0x69), .salt = @splat(0x42) });
+    h.update(&repeat_a_64);
+    h.update(&repeat_b_64);
     h.final(out[0..]);
     try htest.assertEqual(h4, out[0..]);
 
-    h = Blake2b384.init(.{ .context = [_]u8{0x69} ** 16, .salt = [_]u8{0x42} ** 16 });
-    h.update("a" ** 64);
-    h.update("b" ** 64);
+    h = Blake2b384.init(.{ .context = @splat(0x69), .salt = @splat(0x42) });
+    h.update(&repeat_a_64);
+    h.update(&repeat_b_64);
     h.final(out[0..]);
     try htest.assertEqual(h4, out[0..]);
 }
@@ -775,7 +803,7 @@ test "blake2b384 streaming" {
 test "comptime blake2b384" {
     comptime {
         @setEvalBranchQuota(20000);
-        var block = [_]u8{0} ** Blake2b384.block_length;
+        var block: [Blake2b384.block_length]u8 = @splat(0);
         var out: [Blake2b384.digest_length]u8 = undefined;
 
         const h1 = "e8aa1931ea0422e4446fecdd25c16cf35c240b10cb4659dd5c776eddcaa4d922397a589404b46eb2e53d78132d05fd7d";
@@ -801,7 +829,9 @@ test "blake2b512 single" {
     try htest.assertEqualHash(Blake2b512, h3, "The quick brown fox jumps over the lazy dog");
 
     const h4 = "049980af04d6a2cf16b4b49793c3ed7e40732073788806f2c989ebe9547bda0541d63abe298ec8955d08af48ae731f2e8a0bd6d201655a5473b4aa79d211b920";
-    try htest.assertEqualHash(Blake2b512, h4, "a" ** 64 ++ "b" ** 64);
+    const repeat_a_64: [64]u8 = @splat('a');
+    const repeat_b_64: [64]u8 = @splat('b');
+    try htest.assertEqualHash(Blake2b512, h4, &repeat_a_64 ++ &repeat_b_64);
 }
 
 test "blake2b512 streaming" {
@@ -827,16 +857,19 @@ test "blake2b512 streaming" {
     h.final(out[0..]);
     try htest.assertEqual(h2, out[0..]);
 
+    const repeat_a_64: [64]u8 = @splat('a');
+    const repeat_b_64: [64]u8 = @splat('b');
+
     const h3 = "049980af04d6a2cf16b4b49793c3ed7e40732073788806f2c989ebe9547bda0541d63abe298ec8955d08af48ae731f2e8a0bd6d201655a5473b4aa79d211b920";
 
     h = Blake2b512.init(.{});
-    h.update("a" ** 64 ++ "b" ** 64);
+    h.update(&repeat_a_64 ++ &repeat_b_64);
     h.final(out[0..]);
     try htest.assertEqual(h3, out[0..]);
 
     h = Blake2b512.init(.{});
-    h.update("a" ** 64);
-    h.update("b" ** 64);
+    h.update(&repeat_a_64);
+    h.update(&repeat_b_64);
     h.final(out[0..]);
     try htest.assertEqual(h3, out[0..]);
 }
@@ -847,18 +880,21 @@ test "blake2b512 keyed" {
     const h1 = "8a978060ccaf582f388f37454363071ac9a67e3a704585fd879fb8a419a447e389c7c6de790faa20a7a7dccf197de736bc5b40b98a930b36df5bee7555750c4d";
     const key = "secret_key";
 
-    Blake2b512.hash("a" ** 64 ++ "b" ** 64, &out, .{ .key = key });
+    const repeat_a_64: [64]u8 = @splat('a');
+    const repeat_b_64: [64]u8 = @splat('b');
+
+    Blake2b512.hash(&repeat_a_64 ++ &repeat_b_64, &out, .{ .key = key });
     try htest.assertEqual(h1, out[0..]);
 
     var h = Blake2b512.init(.{ .key = key });
-    h.update("a" ** 64 ++ "b" ** 64);
+    h.update(&repeat_a_64 ++ &repeat_b_64);
     h.final(out[0..]);
 
     try htest.assertEqual(h1, out[0..]);
 
     h = Blake2b512.init(.{ .key = key });
-    h.update("a" ** 64);
-    h.update("b" ** 64);
+    h.update(&repeat_a_64);
+    h.update(&repeat_b_64);
     h.final(out[0..]);
 
     try htest.assertEqual(h1, out[0..]);
@@ -867,7 +903,7 @@ test "blake2b512 keyed" {
 test "comptime blake2b512" {
     comptime {
         @setEvalBranchQuota(12000);
-        var block = [_]u8{0} ** Blake2b512.block_length;
+        var block: [Blake2b512.block_length]u8 = @splat(0);
         var out: [Blake2b512.digest_length]u8 = undefined;
 
         const h1 = "865939e120e6805438478841afb739ae4250cf372653078a065cdcfffca4caf798e6d462b65d658fc165782640eded70963449ae1500fb0f24981d7727e22c41";

package/std/crypto/cbc_mac.zig

@@ -21,7 +21,7 @@ pub fn CbcMac(comptime BlockCipher: type) type {
         pub const mac_length = block_length;
 
         cipher_ctx: BlockCipherCtx,
-        buf: Block = [_]u8{0} ** block_length,
+        buf: Block = @splat(0),
         pos: usize = 0,
 
         pub fn create(out: *[mac_length]u8, msg: []const u8, key: *const [key_length]u8) void {

package/std/crypto/chacha20.zig

@@ -648,7 +648,7 @@ fn ChaChaPoly1305(comptime rounds_nb: usize) type {
             assert(c.len == m.len);
             assert(m.len <= 64 * (@as(u39, 1 << 32) - 1));
 
-            var polyKey = [_]u8{0} ** 32;
+            var polyKey: [32]u8 = @splat(0);
             ChaChaIETF(rounds_nb).xor(polyKey[0..], polyKey[0..], 0, k, npub);
 
             ChaChaIETF(rounds_nb).xor(c[0..m.len], m, 1, k, npub);
@@ -656,13 +656,13 @@ fn ChaChaPoly1305(comptime rounds_nb: usize) type {
             var mac = Poly1305.init(polyKey[0..]);
             mac.update(ad);
             if (ad.len % 16 != 0) {
-                const zeros = [_]u8{0} ** 16;
+                const zeros: [16]u8 = @splat(0);
                 const padding = 16 - (ad.len % 16);
                 mac.update(zeros[0..padding]);
             }
             mac.update(c[0..m.len]);
             if (m.len % 16 != 0) {
-                const zeros = [_]u8{0} ** 16;
+                const zeros: [16]u8 = @splat(0);
                 const padding = 16 - (m.len % 16);
                 mac.update(zeros[0..padding]);
             }
@@ -685,20 +685,20 @@ fn ChaChaPoly1305(comptime rounds_nb: usize) type {
         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 {
             assert(c.len == m.len);
 
-            var polyKey = [_]u8{0} ** 32;
+            var polyKey: [32]u8 = @splat(0);
             ChaChaIETF(rounds_nb).xor(polyKey[0..], polyKey[0..], 0, k, npub);
 
             var mac = Poly1305.init(polyKey[0..]);
 
             mac.update(ad);
             if (ad.len % 16 != 0) {
-                const zeros = [_]u8{0} ** 16;
+                const zeros: [16]u8 = @splat(0);
                 const padding = 16 - (ad.len % 16);
                 mac.update(zeros[0..padding]);
             }
             mac.update(c);
             if (c.len % 16 != 0) {
-                const zeros = [_]u8{0} ** 16;
+                const zeros: [16]u8 = @splat(0);
                 const padding = 16 - (c.len % 16);
                 mac.update(zeros[0..padding]);
             }
@@ -759,8 +759,8 @@ test "AEAD API" {
     const ad = "Additional data";
 
     inline for (aeads) |aead| {
-        const key = [_]u8{69} ** aead.key_length;
-        const nonce = [_]u8{42} ** aead.nonce_length;
+        const key: [aead.key_length]u8 = @splat(69);
+        const nonce: [aead.nonce_length]u8 = @splat(42);
         var c: [m.len]u8 = undefined;
         var tag: [aead.tag_length]u8 = undefined;
         var out: [m.len]u8 = undefined;
@@ -1138,8 +1138,8 @@ test "open" {
 }
 
 test "xchacha20" {
-    const key = [_]u8{69} ** 32;
-    const nonce = [_]u8{42} ** 24;
+    const key: [32]u8 = @splat(69);
+    const nonce: [24]u8 = @splat(42);
     const m = "Ladies and Gentlemen of the class of '99: If I could offer you only one tip for the future, sunscreen would be it.";
     {
         var c: [m.len]u8 = undefined;

package/std/crypto/cmac.zig

@@ -20,7 +20,7 @@ pub fn Cmac(comptime BlockCipher: type) type {
         cipher_ctx: BlockCipherCtx,
         k1: Block,
         k2: Block,
-        buf: Block = [_]u8{0} ** block_length,
+        buf: Block = @splat(0),
         pos: usize = 0,
 
         pub fn create(out: *[mac_length]u8, msg: []const u8, key: *const [key_length]u8) void {
@@ -31,7 +31,7 @@ pub fn Cmac(comptime BlockCipher: type) type {
 
         pub fn init(key: *const [key_length]u8) Self {
             const cipher_ctx = BlockCipher.initEnc(key.*);
-            const zeros = [_]u8{0} ** block_length;
+            const zeros: [block_length]u8 = @splat(0);
             var k1: Block = undefined;
             cipher_ctx.encrypt(&k1, &zeros);
             k1 = double(k1);

package/std/crypto/codecs/asn1.zig

@@ -233,7 +233,7 @@ test Element {
         .slice = Element.Slice{ .start = 2, .end = short_form.len },
     }, Element.decode(&short_form, 0));
 
-    const long_form = [_]u8{ 0x30, 129, 129 } ++ [_]u8{0} ** 129;
+    const long_form = [_]u8{ 0x30, 129, 129 } ++ @as([129]u8, @splat(0));
     try std.testing.expectEqual(Element{
         .tag = Tag.universal(.sequence, true),
         .slice = Element.Slice{ .start = 3, .end = long_form.len },

package/std/crypto/codecs/base64_hex_ct.zig

@@ -3,7 +3,7 @@
 //! This is designed to be used in cryptographic applications where timing attacks are a concern.
 const std = @import("std");
 const testing = std.testing;
-const StaticBitSet = std.StaticBitSet;
+const StaticBitSet = std.bit_set.Static;
 
 pub const Error = error{
     /// An invalid character was found in the input.

package/std/crypto/ecdsa.zig

@@ -212,7 +212,7 @@ pub fn Ecdsa(comptime Curve: type, comptime Hash: type) type {
             fn finalizePrehashed(self: *Signer, msg_hash: [Hash.digest_length]u8) (IdentityElementError || NonCanonicalError)!Signature {
                 const scalar_encoded_length = Curve.scalar.encoded_length;
                 const h_len = @max(Hash.digest_length, scalar_encoded_length);
-                var h: [h_len]u8 = [_]u8{0} ** (h_len - Hash.digest_length) ++ msg_hash;
+                var h: [h_len]u8 = @as([h_len - Hash.digest_length]u8, @splat(0)) ++ msg_hash;
 
                 std.debug.assert(h.len >= scalar_encoded_length);
                 const z = reduceToScalar(scalar_encoded_length, h[0..scalar_encoded_length].*);
@@ -275,7 +275,7 @@ pub fn Ecdsa(comptime Curve: type, comptime Hash: type) type {
             fn verifyPrehashed(self: *Verifier, msg_hash: [Hash.digest_length]u8) VerifyError!void {
                 const ht = Curve.scalar.encoded_length;
                 const h_len = @max(Hash.digest_length, ht);
-                var h: [h_len]u8 = [_]u8{0} ** (h_len - Hash.digest_length) ++ msg_hash;
+                var h: [h_len]u8 = @as([h_len - Hash.digest_length]u8, @splat(0)) ++ msg_hash;
 
                 const z = reduceToScalar(ht, h[0..ht].*);
                 if (z.isZero()) {
@@ -316,8 +316,8 @@ pub fn Ecdsa(comptime Curve: type, comptime Hash: type) type {
             ///
             /// Except in tests, applications should generally call `generate()` instead of this function.
             pub fn generateDeterministic(seed: [seed_length]u8) IdentityElementError!KeyPair {
-                const h = [_]u8{0x00} ** Hash.digest_length;
-                const k0 = [_]u8{0x01} ** SecretKey.encoded_length;
+                const h: [Hash.digest_length]u8 = @splat(0x00);
+                const k0: [SecretKey.encoded_length]u8 = @splat(0x01);
                 const secret_key = deterministicScalar(h, k0, seed).toBytes(.big);
                 return fromSecretKey(SecretKey{ .bytes = secret_key });
             }
@@ -367,11 +367,11 @@ pub fn Ecdsa(comptime Curve: type, comptime Hash: type) type {
         // Reduce the coordinate of a field element to the scalar field.
         fn reduceToScalar(comptime unreduced_len: usize, s: [unreduced_len]u8) Curve.scalar.Scalar {
             if (unreduced_len >= 48) {
-                var xs = [_]u8{0} ** 64;
+                var xs: [64]u8 = @splat(0);
                 @memcpy(xs[xs.len - s.len ..], s[0..]);
                 return Curve.scalar.Scalar.fromBytes64(xs, .big);
             }
-            var xs = [_]u8{0} ** 48;
+            var xs: [48]u8 = @splat(0);
             @memcpy(xs[xs.len - s.len ..], s[0..]);
             return Curve.scalar.Scalar.fromBytes48(xs, .big);
         }
@@ -379,9 +379,9 @@ pub fn Ecdsa(comptime Curve: type, comptime Hash: type) type {
         // Create a deterministic scalar according to a secret key and optional noise.
         // This uses the overly conservative scheme from the "Deterministic ECDSA and EdDSA Signatures with Additional Randomness" draft.
         fn deterministicScalar(h: [Hash.digest_length]u8, secret_key: Curve.scalar.CompressedScalar, noise: ?[noise_length]u8) Curve.scalar.Scalar {
-            var k = [_]u8{0x00} ** h.len;
-            var m = [_]u8{0x00} ** (h.len + 1 + noise_length + secret_key.len + h.len);
-            var t = [_]u8{0x00} ** Curve.scalar.encoded_length;
+            var k: [h.len]u8 = @splat(0);
+            var m: [h.len + 1 + noise_length + secret_key.len + h.len]u8 = @splat(0);
+            var t: [Curve.scalar.encoded_length]u8 = @splat(0);
             const m_v = m[0..h.len];
             const m_i = &m[m_v.len];
             const m_z = m[m_v.len + 1 ..][0..noise_length];

package/std/crypto/ff.zig

@@ -96,7 +96,7 @@ pub fn Uint(comptime max_bits: comptime_int) type {
 
         /// The zero integer.
         pub const zero: Self = .{
-            .limbs_buffer = [1]Limb{0} ** max_limbs_count,
+            .limbs_buffer = @splat(0),
             .limbs_len = max_limbs_count,
         };
 
@@ -738,7 +738,7 @@ pub fn Modulus(comptime max_bits: comptime_int) type {
                 }
             } else {
                 // Use a precomputation table for large exponents
-                var pc = [1]Fe{x} ++ [_]Fe{self.zero} ** 14;
+                var pc: [15]Fe = [1]Fe{x} ++ @as([14]Fe, @splat(self.zero));
                 if (!x.montgomery) {
                     self.toMontgomery(&pc[0]) catch unreachable;
                 }

package/std/crypto/ghash_polyval.zig

@@ -417,8 +417,8 @@ fn Hash(comptime endian: std.builtin.Endian, comptime shift_key: bool) type {
 const htest = @import("test.zig");
 
 test "ghash" {
-    const key = [_]u8{0x42} ** 16;
-    const m = [_]u8{0x69} ** 256;
+    const key: [16]u8 = @splat(0x42);
+    const m: [256]u8 = @splat(0x69);
 
     var st = Ghash.init(&key);
     st.update(&m);
@@ -467,8 +467,8 @@ test "ghash2" {
 }
 
 test "polyval" {
-    const key = [_]u8{0x42} ** 16;
-    const m = [_]u8{0x69} ** 256;
+    const key: [16]u8 = @splat(0x42);
+    const m: [256]u8 = @splat(0x69);
 
     var st = Polyval.init(&key);
     st.update(&m);

package/std/crypto/hkdf.zig

@@ -72,7 +72,7 @@ pub fn Hkdf(comptime Hmac: type) type {
 const htest = @import("test.zig");
 
 test "Hkdf" {
-    const ikm = [_]u8{0x0b} ** 22;
+    const ikm: [22]u8 = @splat(0x0b);
     const salt = [_]u8{ 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c };
     const context = [_]u8{ 0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8, 0xf9 };
     const kdf = HkdfSha256;

package/std/crypto/isap.zig

@@ -42,7 +42,7 @@ pub const IsapA128A = struct {
                     break;
                 }
             } else {
-                var padded = [_]u8{0} ** 8;
+                var padded: [8]u8 = @splat(0);
                 @memcpy(padded[0..left], m[i..]);
                 padded[left] = 0x80;
                 isap.st.addBytes(&padded);
@@ -169,8 +169,8 @@ pub const IsapA128A = struct {
 };
 
 test "ISAP" {
-    const k = [_]u8{1} ** 16;
-    const n = [_]u8{2} ** 16;
+    const k: [16]u8 = @splat(1);
+    const n: [16]u8 = @splat(2);
     var tag: [16]u8 = undefined;
     const ad = "ad";
     var msg = "test";

package/std/crypto/kangarootwelve.zig

@@ -881,7 +881,7 @@ fn ktMultiThreaded(
         // Buffer for out-of-order results (select_buf slots get reused)
         const pending_cv_buf = try allocator.alloc([leaves_per_batch * cv_size]u8, max_concurrent);
         defer allocator.free(pending_cv_buf);
-        var pending_cv_lens: [256]usize = .{0} ** 256;
+        var pending_cv_lens: [256]usize = @splat(0);
 
         var select_outstanding: usize = 0;
         var select: Select = .init(io, select_buf);