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

package/std/crypto/keccak_p.zig

@@ -40,7 +40,7 @@ pub fn KeccakF(comptime f: u11) type {
             break :rc rc;
         };
 
-        st: Block = [_]T{0} ** 25,
+        st: Block = @splat(0),
 
         /// Initialize the state from a slice of bytes.
         pub fn init(bytes: [block_bytes]u8) Self {
@@ -70,7 +70,7 @@ pub fn KeccakF(comptime f: u11) type {
                 self.st[i / @sizeOf(T)] = mem.readInt(T, bytes[i..][0..@sizeOf(T)], .little);
             }
             if (i < bytes.len) {
-                var padded = [_]u8{0} ** @sizeOf(T);
+                var padded: [@sizeOf(T)]u8 = @splat(0);
                 @memcpy(padded[0 .. bytes.len - i], bytes[i..]);
                 self.st[i / @sizeOf(T)] = mem.readInt(T, padded[0..], .little);
             }
@@ -89,7 +89,7 @@ pub fn KeccakF(comptime f: u11) type {
                 self.st[i / @sizeOf(T)] ^= mem.readInt(T, bytes[i..][0..@sizeOf(T)], .little);
             }
             if (i < bytes.len) {
-                var padded = [_]u8{0} ** @sizeOf(T);
+                var padded: [@sizeOf(T)]u8 = @splat(0);
                 @memcpy(padded[0 .. bytes.len - i], bytes[i..]);
                 self.st[i / @sizeOf(T)] ^= mem.readInt(T, padded[0..], .little);
             }
@@ -102,7 +102,7 @@ pub fn KeccakF(comptime f: u11) type {
                 mem.writeInt(T, out[i..][0..@sizeOf(T)], self.st[i / @sizeOf(T)], .little);
             }
             if (i < out.len) {
-                var padded = [_]u8{0} ** @sizeOf(T);
+                var padded: [@sizeOf(T)]u8 = @splat(0);
                 mem.writeInt(T, padded[0..], self.st[i / @sizeOf(T)], .little);
                 @memcpy(out[i..], padded[0 .. out.len - i]);
             }
@@ -118,7 +118,7 @@ pub fn KeccakF(comptime f: u11) type {
                 mem.writeInt(T, out[i..][0..@sizeOf(T)], x, native_endian);
             }
             if (i < in.len) {
-                var padded = [_]u8{0} ** @sizeOf(T);
+                var padded: [@sizeOf(T)]u8 = @splat(0);
                 @memcpy(padded[0 .. in.len - i], in[i..]);
                 const x = mem.readInt(T, &padded, native_endian) ^ mem.nativeToLittle(T, self.st[i / @sizeOf(T)]);
                 mem.writeInt(T, &padded, x, native_endian);
@@ -140,7 +140,7 @@ pub fn KeccakF(comptime f: u11) type {
             const st = &self.st;
 
             // theta
-            var t = [_]T{0} ** 5;
+            var t: [5]T = @splat(0);
             inline for (0..5) |i| {
                 inline for (0..5) |j| {
                     t[i] ^= st[j * 5 + i];
@@ -382,7 +382,7 @@ test "Keccak-f800" {
 }
 
 test "squeeze" {
-    var st = State(800, 256, 22).init([_]u8{0x80} ** 100, 0x01);
+    var st: State(800, 256, 22) = .init(@splat(0x80), 0x01);
 
     var out0: [15]u8 = undefined;
     var out1: [out0.len]u8 = undefined;

package/std/crypto/md5.zig

@@ -272,7 +272,7 @@ test "streaming" {
 }
 
 test "aligned final" {
-    var block = [_]u8{0} ** Md5.block_length;
+    const block: [Md5.block_length]u8 = @splat(0);
     var out: [Md5.digest_length]u8 = undefined;
 
     var h = Md5.init(.{});

package/std/crypto/ml_dsa.zig

@@ -156,7 +156,7 @@ const Params = struct {
 const Poly = struct {
     cs: [N]u32,
 
-    const zero: Poly = .{ .cs = .{0} ** N };
+    const zero: Poly = .{ .cs = @splat(0) };
 
     // Add two polynomials (no normalization)
     fn add(a: Poly, b: Poly) Poly {
@@ -302,7 +302,7 @@ fn PolyVec(comptime len: u8) type {
         ps: [len]Poly,
 
         const Self = @This();
-        const zero: Self = .{ .ps = .{Poly.zero} ** len };
+        const zero: Self = .{ .ps = @splat(.zero) };
 
         /// Apply a unary operation to each polynomial in the vector
         fn map(v: Self, comptime op: fn (Poly) Poly) Self {
@@ -581,7 +581,7 @@ fn PolyVec(comptime len: u8) type {
 
         /// Unpack hints from bytes
         fn unpackHint(comptime omega: u16, buf: []const u8) ?Self {
-            var result: Self = .{ .ps = .{Poly.zero} ** len };
+            var result: Self = .{ .ps = @splat(.zero) };
             var prev_sop: u8 = 0; // previous switch-over-point
 
             for (0..len) |i| {
@@ -1839,7 +1839,7 @@ fn MLDSAImpl(comptime p: Params) type {
                 return Signer{
                     .h = h,
                     .secret_key = secret_key,
-                    .rnd = noise orelse .{0} ** 32,
+                    .rnd = noise orelse @splat(0),
                 };
             }
 
@@ -2324,7 +2324,7 @@ test "decompose correctness for ML-DSA-87" {
 
 test "polyDeriveUniform deterministic" {
     // Test that polyDeriveUniform produces deterministic results
-    const seed: [32]u8 = .{0x01} ++ .{0x00} ** 31;
+    const seed: [32]u8 = .{0x01} ++ @as([31]u8, @splat(0x00));
     const nonce: u16 = 0;
 
     const p1 = polyDeriveUniform(&seed, nonce);
@@ -2343,7 +2343,7 @@ test "polyDeriveUniform deterministic" {
 
 test "polyDeriveUniform different nonces" {
     // Test that different nonces produce different polynomials
-    const seed: [32]u8 = .{0x01} ++ .{0x00} ** 31;
+    const seed: [32]u8 = .{0x01} ++ @as([31]u8, @splat(0x00));
 
     const p1 = polyDeriveUniform(&seed, 0);
     const p2 = polyDeriveUniform(&seed, 1);
@@ -2361,7 +2361,7 @@ test "polyDeriveUniform different nonces" {
 
 test "expandS with eta=2" {
     // Test eta=2 sampling
-    const seed: [64]u8 = .{0x02} ++ .{0x00} ** 63;
+    const seed: [64]u8 = .{0x02} ++ @as([63]u8, @splat(0x00));
     const nonce: u16 = 0;
 
     const p = expandS(2, &seed, nonce);
@@ -2378,7 +2378,7 @@ test "expandS with eta=2" {
 
 test "expandS with eta=4" {
     // Test eta=4 sampling
-    const seed: [64]u8 = .{0x03} ++ .{0x00} ** 63;
+    const seed: [64]u8 = .{0x03} ++ @as([63]u8, @splat(0x00));
     const nonce: u16 = 0;
 
     const p = expandS(4, &seed, nonce);
@@ -2395,7 +2395,7 @@ test "expandS with eta=4" {
 test "sampleInBall has correct weight" {
     // Test that ball polynomial has exactly tau non-zero coefficients
     const tau = 39; // From ML-DSA-44
-    const seed: [32]u8 = .{0x04} ++ .{0x00} ** 31;
+    const seed: [32]u8 = .{0x03} ++ @as([31]u8, @splat(0x00));
 
     const p = sampleInBall(tau, &seed);
 
@@ -2415,7 +2415,7 @@ test "sampleInBall has correct weight" {
 test "sampleInBall deterministic" {
     // Test that ball sampling is deterministic
     const tau = 49; // From ML-DSA-65
-    const seed: [32]u8 = .{0x05} ++ .{0x00} ** 31;
+    const seed: [32]u8 = .{0x05} ++ @as([31]u8, @splat(0x00));
 
     const p1 = sampleInBall(tau, &seed);
     const p2 = sampleInBall(tau, &seed);
@@ -2851,13 +2851,13 @@ test "Key generation basic - all variants" {
         .{ .variant = MLDSA65, .seed_byte = 0x65 },
         .{ .variant = MLDSA87, .seed_byte = 0x87 },
     }) |config| {
-        const seed = [_]u8{config.seed_byte} ** 32;
+        const seed: [32]u8 = @splat(config.seed_byte);
         try testKeyGenerationBasic(config.variant, seed);
     }
 }
 
 test "Key generation determinism" {
-    const seed = [_]u8{ 0x12, 0x34, 0x56, 0x78 } ++ [_]u8{0xAB} ** 28;
+    const seed = [_]u8{ 0x12, 0x34, 0x56, 0x78 } ++ @as([28]u8, @splat(0xAB));
 
     // Generate two key pairs from the same seed
     const result1 = MLDSA44.newKeyFromSeed(&seed);
@@ -2874,7 +2874,7 @@ test "Key generation determinism" {
 }
 
 test "Private key can compute public key" {
-    const seed = [_]u8{0xFF} ** 32;
+    const seed: [32]u8 = @splat(0xFF);
     const result = MLDSA44.newKeyFromSeed(&seed);
     const pk = result.pk;
     const sk = result.sk;
@@ -2907,13 +2907,13 @@ test "Sign and verify - all variants" {
         .{ .variant = MLDSA65, .seed_byte = 0x65, .message = "Hello, ML-DSA-65!" },
         .{ .variant = MLDSA87, .seed_byte = 0x87, .message = "Hello, ML-DSA-87!" },
     }) |config| {
-        const seed = [_]u8{config.seed_byte} ** 32;
+        const seed: [32]u8 = @splat(config.seed_byte);
         try testSignAndVerify(config.variant, seed, config.message);
     }
 }
 
 test "Invalid signature rejection" {
-    const seed = [_]u8{0x99} ** 32;
+    const seed: [32]u8 = @splat(0x99);
     const result = MLDSA44.newKeyFromSeed(&seed);
     const kp = try MLDSA44.KeyPair.fromSecretKey(result.sk);
 
@@ -2934,7 +2934,7 @@ test "Invalid signature rejection" {
 }
 
 test "Context string support" {
-    const seed = [_]u8{0xAA} ** 32;
+    const seed: [32]u8 = @splat(0xAA);
     const result = MLDSA44.newKeyFromSeed(&seed);
     const kp = try MLDSA44.KeyPair.fromSecretKey(result.sk);
 
@@ -2964,17 +2964,17 @@ test "Context string support" {
     try testing.expectError(error.SignatureVerificationFailed, sig2.verifyWithContext(message, kp.public_key, context1));
 
     // Test maximum context length (255 bytes)
-    const max_context = [_]u8{0xBB} ** 255;
+    const max_context: [255]u8 = @splat(0xBB);
     const sig3 = try kp.signWithContext(message, null, &max_context);
     try sig3.verifyWithContext(message, kp.public_key, &max_context);
 
     // Test context too long (256 bytes should fail)
-    const too_long_context = [_]u8{0xCC} ** 256;
+    const too_long_context: [256]u8 = @splat(0xCC);
     try testing.expectError(error.ContextTooLong, kp.signWithContext(message, null, &too_long_context));
 }
 
 test "Context string with streaming API" {
-    const seed = [_]u8{0xDD} ** 32;
+    const seed: [32]u8 = @splat(0xDD);
     const result = MLDSA44.newKeyFromSeed(&seed);
     const kp = try MLDSA44.KeyPair.fromSecretKey(result.sk);
 
@@ -3002,12 +3002,12 @@ test "Context string with streaming API" {
 }
 
 test "Signature determinism (same rnd)" {
-    const seed = [_]u8{0x11} ** 32;
+    const seed: [32]u8 = @splat(0x11);
     const result = MLDSA44.newKeyFromSeed(&seed);
     const sk = result.sk;
 
     const message = "Deterministic test";
-    const rnd = [_]u8{0x22} ** 32;
+    const rnd: [32]u8 = @splat(0x22);
 
     // Sign twice with same randomness using streaming API
     var st1 = try sk.signer(rnd);
@@ -3023,7 +3023,7 @@ test "Signature determinism (same rnd)" {
 }
 
 test "Signature toBytes/fromBytes roundtrip" {
-    const seed = [_]u8{0x33} ** 32;
+    const seed: [32]u8 = @splat(0x33);
     const result = MLDSA44.newKeyFromSeed(&seed);
     const kp = try MLDSA44.KeyPair.fromSecretKey(result.sk);
 
@@ -3043,7 +3043,7 @@ test "Signature toBytes/fromBytes roundtrip" {
 }
 
 test "Empty message signing" {
-    const seed = [_]u8{0x44} ** 32;
+    const seed: [32]u8 = @splat(0x44);
     const result = MLDSA44.newKeyFromSeed(&seed);
     const kp = try MLDSA44.KeyPair.fromSecretKey(result.sk);
 
@@ -3057,12 +3057,12 @@ test "Empty message signing" {
 }
 
 test "Long message signing" {
-    const seed = [_]u8{0x55} ** 32;
+    const seed: [32]u8 = @splat(0x55);
     const result = MLDSA44.newKeyFromSeed(&seed);
     const kp = try MLDSA44.KeyPair.fromSecretKey(result.sk);
 
     // Create a long message (1KB)
-    const long_message = [_]u8{0xAB} ** 1024;
+    const long_message: [1024]u8 = @splat(0xAB);
 
     // Sign long message
     const sig = try kp.sign(&long_message, null);
@@ -3209,7 +3209,7 @@ test "KeyPair API - generate and sign" {
 
 test "KeyPair API - generateDeterministic" {
     // Test deterministic key generation
-    const seed = [_]u8{42} ** 32;
+    const seed: [32]u8 = @splat(42);
     const kp1 = try MLDSA44.KeyPair.generateDeterministic(seed);
     const kp2 = try MLDSA44.KeyPair.generateDeterministic(seed);
 
@@ -3240,7 +3240,7 @@ test "Signature verification with noise" {
     const msg = "Message to be signed with randomness";
 
     // Create some noise
-    const noise = [_]u8{ 1, 2, 3, 4, 5 } ++ [_]u8{0} ** 27;
+    const noise = [_]u8{ 1, 2, 3, 4, 5 } ++ @as([27]u8, @splat(0));
 
     // Sign with noise
     const sig = try kp.sign(msg, noise);
@@ -3262,7 +3262,7 @@ test "Signature verification failure" {
 }
 
 test "Streaming API - sign and verify" {
-    const seed = [_]u8{0x55} ** 32;
+    const seed: [32]u8 = @splat(0x55);
     const kp = try MLDSA44.KeyPair.generateDeterministic(seed);
 
     const msg = "Test message for streaming API";
@@ -3279,7 +3279,7 @@ test "Streaming API - sign and verify" {
 }
 
 test "Streaming API - chunked message" {
-    const seed = [_]u8{0x66} ** 32;
+    const seed: [32]u8 = @splat(0x66);
     const kp = try MLDSA44.KeyPair.generateDeterministic(seed);
 
     // Create a message in chunks
@@ -3313,7 +3313,7 @@ test "Streaming API - chunked message" {
 }
 
 test "Streaming API - large message" {
-    const seed = [_]u8{0x77} ** 32;
+    const seed: [32]u8 = @splat(0x77);
     const kp = try MLDSA44.KeyPair.generateDeterministic(seed);
 
     // Create a large message (1MB)
@@ -3344,7 +3344,7 @@ test "Streaming API - all parameter sets" {
 
     // ML-DSA-44
     {
-        const seed = [_]u8{0x44} ** 32;
+        const seed: [32]u8 = @splat(0x44);
         const kp = try MLDSA44.KeyPair.generateDeterministic(seed);
         var signer = try kp.signer(null);
         signer.update(test_msg);
@@ -3356,7 +3356,7 @@ test "Streaming API - all parameter sets" {
 
     // ML-DSA-65
     {
-        const seed = [_]u8{0x65} ** 32;
+        const seed: [32]u8 = @splat(0x65);
         const kp = try MLDSA65.KeyPair.generateDeterministic(seed);
         var signer = try kp.signer(null);
         signer.update(test_msg);
@@ -3368,7 +3368,7 @@ test "Streaming API - all parameter sets" {
 
     // ML-DSA-87
     {
-        const seed = [_]u8{0x87} ** 32;
+        const seed: [32]u8 = @splat(0x87);
         const kp = try MLDSA87.KeyPair.generateDeterministic(seed);
         var signer = try kp.signer(null);
         signer.update(test_msg);

package/std/crypto/ml_kem.zig

@@ -615,7 +615,7 @@ const inv_ntt_reductions = [_]i16{
 test "invNTTReductions bounds" {
     // Checks whether the reductions proposed by invNTTReductions
     // don't overflow during invNTT().
-    var xs = [_]i32{1} ** 256; // start at |x| ≤ q
+    var xs: [256]i32 = @splat(1); // start at |x| ≤ q
 
     var r: usize = 0;
     var layer: math.Log2Int(usize) = 1;
@@ -797,7 +797,7 @@ const Poly = struct {
     cs: [N]i16,
 
     const encoded_length = N / 2 * 3;
-    const zero: Poly = .{ .cs = .{0} ** N };
+    const zero: Poly = .{ .cs = @splat(0) };
 
     // Add two polynomials (coefficients not normalized)
     fn add(a: Poly, b: Poly) Poly {
@@ -1011,7 +1011,7 @@ const Poly = struct {
 
         const out_length: usize = comptime @divTrunc(N * d, 8);
         comptime assert(out_length * 8 == d * N);
-        var out = [_]u8{0} ** out_length;
+        var out: [out_length]u8 = @splat(0);
 
         while (in_off < N) {
             // First we compress into in.
@@ -1754,7 +1754,7 @@ const NistDRBG = struct {
     }
 
     fn init(seed: [48]u8) NistDRBG {
-        var ret: NistDRBG = .{ .key = .{0} ** 32, .v = .{0} ** 16 };
+        var ret: NistDRBG = .{ .key = @splat(0), .v = @splat(0) };
         ret.update(seed);
         return ret;
     }

package/std/crypto/modes.zig

@@ -183,7 +183,7 @@ test "ctr mode" {
     // Test 9: Large input (> 2*block_length, 100 bytes)
     {
         // Create a 100-byte input by extending with zeros
-        var in: [100]u8 = [_]u8{0} ** 100;
+        var in: [100]u8 = @splat(0);
         @memcpy(in[0..64], &[_]u8{
             0x6b, 0xc1, 0xbe, 0xe2, 0x2e, 0x40, 0x9f, 0x96, 0xe9, 0x3d, 0x7e, 0x11, 0x73, 0x93, 0x17, 0x2a,
             0xae, 0x2d, 0x8a, 0x57, 0x1e, 0x03, 0xac, 0x9c, 0x9e, 0xb7, 0x6f, 0xac, 0x45, 0xaf, 0x8e, 0x51,

package/std/crypto/pbkdf2.zig

@@ -206,7 +206,7 @@ test "RFC 6070 16,777,216 iterations" {
     const c = 16777216;
     const dk_len = 20;
 
-    var dk = [_]u8{0} ** dk_len;
+    var dk: [dk_len]u8 = @splat(0);
 
     try pbkdf2(&dk, p, s, c, HmacSha1);
 

package/std/crypto/pcurves/p256/scalar.zig

@@ -196,19 +196,19 @@ const ScalarDouble = struct {
         }
         var t = ScalarDouble{ .x1 = undefined, .x2 = Fe.zero, .x3 = Fe.zero };
         {
-            var b = [_]u8{0} ** encoded_length;
+            var b: [encoded_length]u8 = @splat(0);
             const len = @min(s.len, 24);
             b[0..len].* = s[0..len].*;
             t.x1 = Fe.fromBytes(b, .little) catch unreachable;
         }
         if (s_.len >= 24) {
-            var b = [_]u8{0} ** encoded_length;
+            var b: [encoded_length]u8 = @splat(0);
             const len = @min(s.len - 24, 24);
             b[0..len].* = s[24..][0..len].*;
             t.x2 = Fe.fromBytes(b, .little) catch unreachable;
         }
         if (s_.len >= 48) {
-            var b = [_]u8{0} ** encoded_length;
+            var b: [encoded_length]u8 = @splat(0);
             const len = s.len - 48;
             b[0..len].* = s[48..][0..len].*;
             t.x3 = Fe.fromBytes(b, .little) catch unreachable;

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

@@ -184,13 +184,13 @@ const ScalarDouble = struct {
         }
         var t = ScalarDouble{ .x1 = undefined, .x2 = Fe.zero };
         {
-            var b = [_]u8{0} ** encoded_length;
+            var b: [encoded_length]u8 = @splat(0);
             const len = @min(s.len, 32);
             b[0..len].* = s[0..len].*;
             t.x1 = Fe.fromBytes(b, .little) catch unreachable;
         }
         if (s_.len >= 32) {
-            var b = [_]u8{0} ** encoded_length;
+            var b: [encoded_length]u8 = @splat(0);
             const len = @min(s.len - 32, 32);
             b[0..len].* = s[32..][0..len].*;
             t.x2 = Fe.fromBytes(b, .little) catch unreachable;

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

@@ -196,19 +196,19 @@ const ScalarDouble = struct {
         }
         var t = ScalarDouble{ .x1 = undefined, .x2 = Fe.zero, .x3 = Fe.zero };
         {
-            var b = [_]u8{0} ** encoded_length;
+            var b: [encoded_length]u8 = @splat(0);
             const len = @min(s.len, 24);
             b[0..len].* = s[0..len].*;
             t.x1 = Fe.fromBytes(b, .little) catch unreachable;
         }
         if (s_.len >= 24) {
-            var b = [_]u8{0} ** encoded_length;
+            var b: [encoded_length]u8 = @splat(0);
             const len = @min(s.len - 24, 24);
             b[0..len].* = s[24..][0..len].*;
             t.x2 = Fe.fromBytes(b, .little) catch unreachable;
         }
         if (s_.len >= 48) {
-            var b = [_]u8{0} ** encoded_length;
+            var b: [encoded_length]u8 = @splat(0);
             const len = s.len - 48;
             b[0..len].* = s[48..][0..len].*;
             t.x3 = Fe.fromBytes(b, .little) catch unreachable;

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

@@ -97,7 +97,7 @@ test "p256 public key is the neutral element (public verification)" {
 }
 
 test "p256 field element non-canonical encoding" {
-    const s = [_]u8{0xff} ** 32;
+    const s: [32]u8 = @splat(0xff);
     try testing.expectError(error.NonCanonical, P256.Fe.fromBytes(s, .little));
 }
 
@@ -110,8 +110,8 @@ test "p256 neutral element decoding" {
 test "p256 double base multiplication" {
     const p1 = P256.basePoint;
     const p2 = P256.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 P256.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));
@@ -120,8 +120,8 @@ test "p256 double base multiplication" {
 test "p256 double base multiplication with large scalars" {
     const p1 = P256.basePoint;
     const p2 = P256.basePoint.dbl();
-    const s1 = [_]u8{0xee} ** 32;
-    const s2 = [_]u8{0xdd} ** 32;
+    const s1: [32]u8 = @splat(0xee);
+    const s2: [32]u8 = @splat(0xdd);
     const pr1 = try P256.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/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);