@zigc/lib 0.17.0-dev.27 → 0.17.0-dev.296

package/std/crypto/ff.zig

@@ -10,7 +10,6 @@ const builtin = @import("builtin");
 const crypto = std.crypto;
 const math = std.math;
 const mem = std.mem;
-const meta = std.meta;
 const testing = std.testing;
 const assert = std.debug.assert;
 const Endian = std.builtin.Endian;
@@ -25,7 +24,7 @@ const carry_bits = 1;
 const t_bits: usize = @bitSizeOf(Limb) - carry_bits;
 
 // A TLimb is a Limb that is truncated to t_bits.
-const TLimb = meta.Int(.unsigned, t_bits);
+const TLimb = @Int(.unsigned, t_bits);
 
 const native_endian = builtin.target.cpu.arch.endian();
 
@@ -96,7 +95,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 +737,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;
                 }
@@ -906,7 +905,7 @@ const ct_protected = struct {
     // Multiplies two limbs and returns the result as a wide limb.
     fn mulWide(x: Limb, y: Limb) WideLimb {
         const half_bits = @typeInfo(Limb).int.bits / 2;
-        const Half = meta.Int(.unsigned, half_bits);
+        const Half = @Int(.unsigned, half_bits);
         const x0 = @as(Half, @truncate(x));
         const x1 = @as(Half, @truncate(x >> half_bits));
         const y0 = @as(Half, @truncate(y));

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

@@ -9,7 +9,7 @@ const mode = @import("builtin").mode;
 /// The Keccak-f permutation.
 pub fn KeccakF(comptime f: u11) type {
     comptime assert(f >= 200 and f <= 1600 and f % 200 == 0); // invalid bit size
-    const T = std.meta.Int(.unsigned, f / 25);
+    const T = @Int(.unsigned, f / 25);
     const Block = [25]T;
 
     const PI = [_]u5{
@@ -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);
@@ -3413,7 +3413,7 @@ fn modularInverse(comptime T: type, comptime a: T, comptime p: T) T {
     // Use a signed type for EEA computation
     const type_info = @typeInfo(T);
     const SignedT = if (type_info == .int and type_info.int.signedness == .unsigned)
-        std.meta.Int(.signed, type_info.int.bits)
+        @Int(.signed, type_info.int.bits)
     else
         T;
 
@@ -3436,7 +3436,7 @@ fn modularInverse(comptime T: type, comptime a: T, comptime p: T) T {
 fn modularPow(comptime T: type, comptime a: T, s: T, comptime p: T) T {
     const type_info = @typeInfo(T);
     const bits = type_info.int.bits;
-    const WideT = std.meta.Int(.unsigned, bits * 2);
+    const WideT = @Int(.unsigned, bits * 2);
 
     var ret: T = 1;
     var base: T = a;
@@ -3465,14 +3465,14 @@ fn bitMask(comptime T: type, bit: T) T {
 
 /// Creates a mask from the sign bit of a signed integer.
 /// Returns all 1s (0xFF...FF) if x < 0, all 0s if x >= 0.
-fn signMask(comptime T: type, x: T) std.meta.Int(.unsigned, @typeInfo(T).int.bits) {
+fn signMask(comptime T: type, x: T) @Int(.unsigned, @typeInfo(T).int.bits) {
     const type_info = @typeInfo(T);
     if (type_info != .int) {
         @compileError("signMask requires an integer type");
     }
 
     const bits = type_info.int.bits;
-    const SignedT = std.meta.Int(.signed, bits);
+    const SignedT = @Int(.signed, bits);
 
     // Convert to signed if needed, arithmetic right shift to propagate sign bit
     const x_signed: SignedT = if (type_info.int.signedness == .signed) x else @bitCast(x);
@@ -3499,8 +3499,8 @@ fn montgomeryReduce(
     const m: OutT = @truncate(m_full);
 
     const yR = x -% @as(InT, m) * @as(InT, q);
-    const y_shifted = @as(std.meta.Int(.unsigned, @typeInfo(InT).Int.bits), @bitCast(yR)) >> r_bits;
-    return @bitCast(@as(std.meta.Int(.unsigned, @typeInfo(OutT).Int.bits), @truncate(y_shifted)));
+    const y_shifted = @as(@Int(.unsigned, @typeInfo(InT).Int.bits), @bitCast(yR)) >> r_bits;
+    return @bitCast(@as(@Int(.unsigned, @typeInfo(OutT).Int.bits), @truncate(y_shifted)));
 }
 
 /// Uniform sampling using SHAKE-128 with rejection sampling.

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.
@@ -1456,8 +1456,6 @@ fn randPolyNormalized(rnd: anytype) Poly {
 }
 
 test "MulHat" {
-    if (comptime builtin.cpu.has(.s390x, .vector)) return error.SkipZigTest;
-
     var rnd = RndGen.init(0);
 
     for (0..100) |_| {
@@ -1612,8 +1610,6 @@ test "Polynomial packing" {
 }
 
 test "Test inner PKE" {
-    if (comptime builtin.cpu.has(.s390x, .vector)) return error.SkipZigTest;
-
     var seed: [32]u8 = undefined;
     var pt: [32]u8 = undefined;
     for (&seed, &pt, 0..) |*s, *p, i| {
@@ -1635,8 +1631,6 @@ test "Test inner PKE" {
 }
 
 test "Test happy flow" {
-    if (comptime builtin.cpu.has(.s390x, .vector)) return error.SkipZigTest;
-
     var seed: [64]u8 = undefined;
     for (&seed, 0..) |*s, i| {
         s.* = @as(u8, @intCast(i));
@@ -1661,23 +1655,14 @@ test "Test happy flow" {
 // Code to test NIST Known Answer Tests (KAT), see PQCgenKAT.c.
 
 test "NIST KAT test d00.Kyber512" {
-    if (comptime builtin.cpu.has(.loongarch, .lsx)) return error.SkipZigTest;
-    if (comptime builtin.cpu.has(.s390x, .vector)) return error.SkipZigTest;
-
     try testNistKat(d00.Kyber512, "e9c2bd37133fcb40772f81559f14b1f58dccd1c816701be9ba6214d43baf4547");
 }
 
 test "NIST KAT test d00.Kyber1024" {
-    if (comptime builtin.cpu.has(.loongarch, .lsx)) return error.SkipZigTest;
-    if (comptime builtin.cpu.has(.s390x, .vector)) return error.SkipZigTest;
-
     try testNistKat(d00.Kyber1024, "89248f2f33f7f4f7051729111f3049c409a933ec904aedadf035f30fa5646cd5");
 }
 
 test "NIST KAT test d00.Kyber768" {
-    if (comptime builtin.cpu.has(.loongarch, .lsx)) return error.SkipZigTest;
-    if (comptime builtin.cpu.has(.s390x, .vector)) return error.SkipZigTest;
-
     try testNistKat(d00.Kyber768, "a1e122cad3c24bc51622e4c242d8b8acbcd3f618fee4220400605ca8f9ea02c2");
 }
 
@@ -1725,15 +1710,8 @@ const NistDRBG = struct {
     v: [16]u8,
 
     fn incV(g: *NistDRBG) void {
-        var j: usize = 15;
-        while (j >= 0) : (j -= 1) {
-            if (g.v[j] == 255) {
-                g.v[j] = 0;
-            } else {
-                g.v[j] += 1;
-                break;
-            }
-        }
+        const val = std.mem.readInt(u128, &g.v, .big);
+        std.mem.writeInt(u128, &g.v, val +% 1, .big);
     }
 
     // AES256_CTR_DRBG_Update(pd, &g.key, &g.v).
@@ -1776,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;
     }
@@ -1816,7 +1794,7 @@ fn modularInverse(comptime T: type, comptime a: T, comptime p: T) T {
     // Use a signed type for EEA computation
     const type_info = @typeInfo(T);
     const SignedT = if (type_info == .int and type_info.int.signedness == .unsigned)
-        std.meta.Int(.signed, type_info.int.bits)
+        @Int(.signed, type_info.int.bits)
     else
         T;
 
@@ -1839,7 +1817,7 @@ fn modularInverse(comptime T: type, comptime a: T, comptime p: T) T {
 fn modularPow(comptime T: type, comptime a: T, s: T, comptime p: T) T {
     const type_info = @typeInfo(T);
     const bits = type_info.int.bits;
-    const WideT = std.meta.Int(.unsigned, bits * 2);
+    const WideT = @Int(.unsigned, bits * 2);
 
     var ret: T = 1;
     var base: T = a;
@@ -1868,14 +1846,14 @@ fn bitMask(comptime T: type, bit: T) T {
 
 /// Creates a mask from the sign bit of a signed integer.
 /// Returns all 1s (0xFF...FF) if x < 0, all 0s if x >= 0.
-fn signMask(comptime T: type, x: T) std.meta.Int(.unsigned, @typeInfo(T).int.bits) {
+fn signMask(comptime T: type, x: T) @Int(.unsigned, @typeInfo(T).int.bits) {
     const type_info = @typeInfo(T);
     if (type_info != .int) {
         @compileError("signMask requires an integer type");
     }
 
     const bits = type_info.int.bits;
-    const SignedT = std.meta.Int(.signed, bits);
+    const SignedT = @Int(.signed, bits);
 
     // Convert to signed if needed, arithmetic right shift to propagate sign bit
     const x_signed: SignedT = if (type_info.int.signedness == .signed) x else @bitCast(x);
@@ -1920,8 +1898,8 @@ fn montgomeryReduce(
     const m: OutT = @truncate(m_full);
 
     const yR = x -% @as(InT, m) * @as(InT, q);
-    const y_shifted = @as(std.meta.Int(.unsigned, @typeInfo(InT).Int.bits), @bitCast(yR)) >> r_bits;
-    return @bitCast(@as(std.meta.Int(.unsigned, @typeInfo(OutT).Int.bits), @truncate(y_shifted)));
+    const y_shifted = @as(@Int(.unsigned, @typeInfo(InT).Int.bits), @bitCast(yR)) >> r_bits;
+    return @bitCast(@as(@Int(.unsigned, @typeInfo(OutT).Int.bits), @truncate(y_shifted)));
 }
 
 /// Uniform sampling using SHAKE-128 with rejection sampling.

package/std/crypto/modes.zig

@@ -40,7 +40,7 @@ pub fn ctrSlice(
     var counterBlock = iv;
     var i: usize = 0;
 
-    const CounterInt = std.meta.Int(.unsigned, counter_size * 8);
+    const CounterInt = @Int(.unsigned, counter_size * 8);
 
     const parallel_count = BlockCipher.block.parallel.optimal_parallel_blocks;
     const wide_block_length = parallel_count * block_length;
@@ -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,