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

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);

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));