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

package/std/bit_set.zig

@@ -8,50 +8,55 @@
 //!
 //! There are five variants defined here:
 //!
-//! IntegerBitSet:
+//! Integer:
 //!   A bit set with static size, which is backed by a single integer.
 //!   This set is good for sets with a small size, but may generate
 //!   inefficient code for larger sets, especially in debug mode.
 //!
-//! ArrayBitSet:
+//! Array:
 //!   A bit set with static size, which is backed by an array of usize.
 //!   This set is good for sets with a larger size, but may use
 //!   more bytes than necessary if your set is small.
 //!
-//! StaticBitSet:
-//!   Picks either IntegerBitSet or ArrayBitSet depending on the requested
+//! Static:
+//!   Picks either Integer or Array depending on the requested
 //!   size.  The interfaces of these two types match exactly, except for fields.
 //!
-//! DynamicBitSet:
+//! Dynamic:
 //!   A bit set with runtime-known size, backed by an allocated slice
 //!   of usize.
 //!
-//! DynamicBitSetUnmanaged:
-//!   A variant of DynamicBitSet which does not store a pointer to its
-//!   allocator, in order to save space.
+//! DynamicManaged:
+//!   A variant of Dynamic which stores an allocator, using it when needed.
 
 const std = @import("std.zig");
 const assert = std.debug.assert;
 const Allocator = std.mem.Allocator;
 const builtin = @import("builtin");
 
+/// Deprecated: use `Static`.
+pub const StaticBitSet = Static;
+
 /// Returns the optimal static bit set type for the specified number
 /// of elements: either `IntegerBitSet` or `ArrayBitSet`,
 /// both of which fulfill the same interface.
 /// The returned type will perform no allocations,
 /// can be copied by value, and does not require deinitialization.
-pub fn StaticBitSet(comptime size: usize) type {
+pub fn Static(comptime size: usize) type {
     if (size <= @bitSizeOf(usize)) {
-        return IntegerBitSet(size);
+        return Integer(size);
     } else {
-        return ArrayBitSet(usize, size);
+        return Array(usize, size);
     }
 }
 
+/// Deprecated: use `Integer`.
+pub const IntegerBitSet = Integer;
+
 /// A bit set with static size, which is backed by a single integer.
 /// This set is good for sets with a small size, but may generate
 /// inefficient code for larger sets, especially in debug mode.
-pub fn IntegerBitSet(comptime size: u16) type {
+pub fn Integer(comptime size: u16) type {
     return packed struct(MaskInt) {
         const Self = @This();
 
@@ -328,21 +333,24 @@ pub fn IntegerBitSet(comptime size: u16) type {
     };
 }
 
+/// Deprecated: use `Array`.
+pub const ArrayBitSet = Array;
+
 /// A bit set with static size, which is backed by an array of usize.
 /// This set is good for sets with a larger size, but may use
 /// more bytes than necessary if your set is small.
-pub fn ArrayBitSet(comptime MaskIntType: type, comptime size: usize) type {
+pub fn Array(comptime MaskIntType: type, comptime size: usize) type {
     const mask_info: std.builtin.Type = @typeInfo(MaskIntType);
 
     // Make sure the mask int is indeed an int
-    if (mask_info != .int) @compileError("ArrayBitSet can only operate on integer masks, but was passed " ++ @typeName(MaskIntType));
+    if (mask_info != .int) @compileError("Array can only operate on integer masks, but was passed " ++ @typeName(MaskIntType));
 
     // It must also be unsigned.
-    if (mask_info.int.signedness != .unsigned) @compileError("ArrayBitSet requires an unsigned integer mask type, but was passed " ++ @typeName(MaskIntType));
+    if (mask_info.int.signedness != .unsigned) @compileError("Array requires an unsigned integer mask type, but was passed " ++ @typeName(MaskIntType));
 
     // And it must not be empty.
     if (MaskIntType == u0)
-        @compileError("ArrayBitSet requires a sized integer for its mask int.  u0 does not work.");
+        @compileError("Array requires a sized integer for its mask int.  u0 does not work.");
 
     const byte_size = std.mem.byte_size_in_bits;
 
@@ -352,7 +360,7 @@ pub fn ArrayBitSet(comptime MaskIntType: type, comptime size: usize) type {
         var desired_bits = std.math.ceilPowerOfTwoAssert(usize, @bitSizeOf(MaskIntType));
         if (desired_bits < byte_size) desired_bits = byte_size;
         const FixedMaskType = std.meta.Int(.unsigned, desired_bits);
-        @compileError("ArrayBitSet was passed integer type " ++ @typeName(MaskIntType) ++
+        @compileError("Array was passed integer type " ++ @typeName(MaskIntType) ++
             ", which is not a power of two.  Please round this up to a power of two integer size (i.e. " ++ @typeName(FixedMaskType) ++ ").");
     }
 
@@ -363,7 +371,7 @@ pub fn ArrayBitSet(comptime MaskIntType: type, comptime size: usize) type {
         var desired_bits = @sizeOf(MaskIntType) * byte_size;
         desired_bits = std.math.ceilPowerOfTwoAssert(usize, desired_bits);
         const FixedMaskType = std.meta.Int(.unsigned, desired_bits);
-        @compileError("ArrayBitSet was passed integer type " ++ @typeName(MaskIntType) ++
+        @compileError("Array was passed integer type " ++ @typeName(MaskIntType) ++
             ", which contains padding bits.  Please round this up to an unpadded integer size (i.e. " ++ @typeName(FixedMaskType) ++ ").");
     }
 
@@ -398,24 +406,24 @@ pub fn ArrayBitSet(comptime MaskIntType: type, comptime size: usize) type {
         /// Deprecated: use `.empty`.
         /// Creates a bit set with no elements present.
         pub fn initEmpty() Self {
-            return .{ .masks = [_]MaskInt{0} ** num_masks };
+            return .empty;
         }
 
         /// Deprecated: use `.full`.
         /// Creates a bit set with all elements present.
         pub fn initFull() Self {
-            if (num_masks == 0) {
-                return .{ .masks = .{} };
-            } else {
-                return .{ .masks = [_]MaskInt{~@as(MaskInt, 0)} ** (num_masks - 1) ++ [_]MaskInt{last_item_mask} };
-            }
+            return .full;
         }
 
         /// A bit set with no elements present.
         pub const empty: Self = .{ .masks = @splat(0) };
 
         /// A bit set with all elements present.
-        pub const full: Self = .{ .masks = if (num_masks == 0) .{} else ([_]MaskInt{~@as(MaskInt, 0)} ** (num_masks - 1) ++ [_]MaskInt{last_item_mask}) };
+        pub const full: Self = full: {
+            var masks: [num_masks]MaskInt = @splat(~@as(MaskInt, 0));
+            if (num_masks > 0) masks[num_masks - 1] = last_item_mask;
+            break :full .{ .masks = masks };
+        };
 
         /// Returns the number of bits in this bit set
         pub inline fn capacity(self: Self) usize {
@@ -673,7 +681,7 @@ pub fn ArrayBitSet(comptime MaskIntType: type, comptime size: usize) type {
         }
 
         pub fn Iterator(comptime options: IteratorOptions) type {
-            return BitSetIterator(MaskInt, options);
+            return GenericIterator(MaskInt, options);
         }
 
         fn maskBit(index: usize) MaskInt {
@@ -688,9 +696,12 @@ pub fn ArrayBitSet(comptime MaskIntType: type, comptime size: usize) type {
     };
 }
 
+/// Deprecated: use `Dynamic`.
+pub const DynamicBitSetUnmanaged = Dynamic;
+
 /// A bit set with runtime-known size, backed by an allocated slice
 /// of usize.  The allocator must be tracked externally by the user.
-pub const DynamicBitSetUnmanaged = struct {
+pub const Dynamic = struct {
     const Self = @This();
 
     /// The integer type used to represent a mask in this bit set
@@ -1074,7 +1085,7 @@ pub const DynamicBitSetUnmanaged = struct {
     }
 
     pub fn Iterator(comptime options: IteratorOptions) type {
-        return BitSetIterator(MaskInt, options);
+        return GenericIterator(MaskInt, options);
     }
 
     fn maskBit(index: usize) MaskInt {
@@ -1091,10 +1102,16 @@ pub const DynamicBitSetUnmanaged = struct {
     }
 };
 
+/// Deprecated: use `DynamicManaged` or `Dynamic` (will need to update callsites).
+pub const DynamicBitSet = DynamicManaged;
+
 /// A bit set with runtime-known size, backed by an allocated slice
-/// of usize.  Thin wrapper around DynamicBitSetUnmanaged which keeps
+/// of usize.  Thin wrapper around Dynamic which keeps
 /// track of the allocator instance.
-pub const DynamicBitSet = struct {
+///
+/// Deprecated in favor of `Dynamic` which accepts an `Allocator`
+/// as a parameter when needed instead of storing it.
+pub const DynamicManaged = struct {
     const Self = @This();
 
     /// The integer type used to represent a mask in this bit set
@@ -1104,12 +1121,12 @@ pub const DynamicBitSet = struct {
     pub const ShiftInt = std.math.Log2Int(MaskInt);
 
     allocator: Allocator,
-    unmanaged: DynamicBitSetUnmanaged = .{},
+    unmanaged: Dynamic = .{},
 
     /// Creates a bit set with no elements present.
     pub fn initEmpty(allocator: Allocator, bit_length: usize) !Self {
         return Self{
-            .unmanaged = try DynamicBitSetUnmanaged.initEmpty(allocator, bit_length),
+            .unmanaged = try .initEmpty(allocator, bit_length),
             .allocator = allocator,
         };
     }
@@ -1117,7 +1134,7 @@ pub const DynamicBitSet = struct {
     /// Creates a bit set with all elements present.
     pub fn initFull(allocator: Allocator, bit_length: usize) !Self {
         return Self{
-            .unmanaged = try DynamicBitSetUnmanaged.initFull(allocator, bit_length),
+            .unmanaged = try .initFull(allocator, bit_length),
             .allocator = allocator,
         };
     }
@@ -1247,7 +1264,7 @@ pub const DynamicBitSet = struct {
         return self.unmanaged.iterator(options);
     }
 
-    pub const Iterator = DynamicBitSetUnmanaged.Iterator;
+    pub const Iterator = Dynamic.Iterator;
 };
 
 /// Options for configuring an iterator over a bit set
@@ -1274,7 +1291,7 @@ pub const IteratorOptions = struct {
 };
 
 // The iterator is reusable between several bit set types
-fn BitSetIterator(comptime MaskInt: type, comptime options: IteratorOptions) type {
+fn GenericIterator(comptime MaskInt: type, comptime options: IteratorOptions) type {
     const ShiftInt = std.math.Log2Int(MaskInt);
     const kind = options.kind;
     const direction = options.direction;
@@ -1713,37 +1730,37 @@ fn testStaticBitSet(comptime Set: type) !void {
     try testPureBitSet(Set);
 }
 
-test IntegerBitSet {
+test Integer {
     if (builtin.zig_backend == .stage2_c) return error.SkipZigTest;
     if (comptime builtin.cpu.has(.riscv, .v) and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest; // https://github.com/ziglang/zig/issues/24300
 
-    try testStaticBitSet(IntegerBitSet(0));
-    try testStaticBitSet(IntegerBitSet(1));
-    try testStaticBitSet(IntegerBitSet(2));
-    try testStaticBitSet(IntegerBitSet(5));
-    try testStaticBitSet(IntegerBitSet(8));
-    try testStaticBitSet(IntegerBitSet(32));
-    try testStaticBitSet(IntegerBitSet(64));
-    try testStaticBitSet(IntegerBitSet(127));
+    try testStaticBitSet(Integer(0));
+    try testStaticBitSet(Integer(1));
+    try testStaticBitSet(Integer(2));
+    try testStaticBitSet(Integer(5));
+    try testStaticBitSet(Integer(8));
+    try testStaticBitSet(Integer(32));
+    try testStaticBitSet(Integer(64));
+    try testStaticBitSet(Integer(127));
 }
 
-test ArrayBitSet {
+test Array {
     inline for (.{ 0, 1, 2, 31, 32, 33, 63, 64, 65, 254, 500, 3000 }) |size| {
-        try testStaticBitSet(ArrayBitSet(u8, size));
-        try testStaticBitSet(ArrayBitSet(u16, size));
-        try testStaticBitSet(ArrayBitSet(u32, size));
-        try testStaticBitSet(ArrayBitSet(u64, size));
-        try testStaticBitSet(ArrayBitSet(u128, size));
+        try testStaticBitSet(Array(u8, size));
+        try testStaticBitSet(Array(u16, size));
+        try testStaticBitSet(Array(u32, size));
+        try testStaticBitSet(Array(u64, size));
+        try testStaticBitSet(Array(u128, size));
     }
 }
 
-test DynamicBitSetUnmanaged {
+test Dynamic {
     const allocator = std.testing.allocator;
-    var a = try DynamicBitSetUnmanaged.initEmpty(allocator, 300);
+    var a: Dynamic = try .initEmpty(allocator, 300);
     try testing.expectEqual(@as(usize, 0), a.count());
     a.deinit(allocator);
 
-    a = try DynamicBitSetUnmanaged.initEmpty(allocator, 0);
+    a = try .initEmpty(allocator, 0);
     defer a.deinit(allocator);
     for ([_]usize{ 1, 2, 31, 32, 33, 0, 65, 64, 63, 500, 254, 3000 }) |size| {
         const old_len = a.capacity();
@@ -1769,17 +1786,17 @@ test DynamicBitSetUnmanaged {
         }
         try testing.expectEqual(@as(usize, 0), empty.count());
 
-        var full = try DynamicBitSetUnmanaged.initFull(allocator, size);
+        var full: Dynamic = try .initFull(allocator, size);
         defer full.deinit(allocator);
         try testing.expectEqual(@as(usize, size), full.count());
 
         try testEql(empty, full, size);
         {
-            var even = try DynamicBitSetUnmanaged.initEmpty(allocator, size);
+            var even: Dynamic = try .initEmpty(allocator, size);
             defer even.deinit(allocator);
             fillEven(&even, size);
 
-            var odd = try DynamicBitSetUnmanaged.initEmpty(allocator, size);
+            var odd: Dynamic = try .initEmpty(allocator, size);
             defer odd.deinit(allocator);
             fillOdd(&odd, size);
 
@@ -1790,13 +1807,13 @@ test DynamicBitSetUnmanaged {
     }
 }
 
-test DynamicBitSet {
+test DynamicManaged {
     const allocator = std.testing.allocator;
-    var a = try DynamicBitSet.initEmpty(allocator, 300);
+    var a: DynamicManaged = try .initEmpty(allocator, 300);
     try testing.expectEqual(@as(usize, 0), a.count());
     a.deinit();
 
-    a = try DynamicBitSet.initEmpty(allocator, 0);
+    a = try .initEmpty(allocator, 0);
     defer a.deinit();
     for ([_]usize{ 1, 2, 31, 32, 33, 0, 65, 64, 63, 500, 254, 3000 }) |size| {
         const old_len = a.capacity();
@@ -1822,7 +1839,7 @@ test DynamicBitSet {
         }
         try testing.expectEqual(@as(usize, 0), tmp.count());
 
-        var b = try DynamicBitSet.initFull(allocator, size);
+        var b: DynamicManaged = try .initFull(allocator, size);
         defer b.deinit();
         try testing.expectEqual(@as(usize, size), b.count());
 
@@ -1831,10 +1848,10 @@ test DynamicBitSet {
     }
 }
 
-test StaticBitSet {
-    try testing.expectEqual(IntegerBitSet(0), StaticBitSet(0));
-    try testing.expectEqual(IntegerBitSet(5), StaticBitSet(5));
-    try testing.expectEqual(IntegerBitSet(@bitSizeOf(usize)), StaticBitSet(@bitSizeOf(usize)));
-    try testing.expectEqual(ArrayBitSet(usize, @bitSizeOf(usize) + 1), StaticBitSet(@bitSizeOf(usize) + 1));
-    try testing.expectEqual(ArrayBitSet(usize, 500), StaticBitSet(500));
+test Static {
+    try testing.expectEqual(Integer(0), Static(0));
+    try testing.expectEqual(Integer(5), Static(5));
+    try testing.expectEqual(Integer(@bitSizeOf(usize)), Static(@bitSizeOf(usize)));
+    try testing.expectEqual(Array(usize, @bitSizeOf(usize) + 1), Static(@bitSizeOf(usize) + 1));
+    try testing.expectEqual(Array(usize, 500), Static(500));
 }

package/std/c.zig

@@ -1664,12 +1664,12 @@ pub const MSF = switch (native_os) {
         pub const ASYNC = 1;
         pub const INVALIDATE = 2;
     },
-    .openbsd => struct {
+    .openbsd, .haiku => struct {
         pub const ASYNC = 1;
         pub const SYNC = 2;
         pub const INVALIDATE = 4;
     },
-    .haiku, .netbsd, .illumos => struct {
+    .netbsd, .illumos => struct {
         pub const ASYNC = 1;
         pub const INVALIDATE = 2;
         pub const SYNC = 4;
@@ -7914,7 +7914,7 @@ pub const pthread_spinlock_t = switch (native_os) {
 
 pub const pthread_mutex_t = switch (native_os) {
     .linux => extern struct {
-        data: [data_len]u8 align(@alignOf(usize)) = [_]u8{0} ** data_len,
+        data: [data_len]u8 align(@alignOf(usize)) = @splat(0),
 
         const data_len = switch (native_abi) {
             .musl, .musleabi, .musleabihf => if (@sizeOf(usize) == 8) 40 else 24,
@@ -7930,7 +7930,7 @@ pub const pthread_mutex_t = switch (native_os) {
     },
     .driverkit, .ios, .maccatalyst, .macos, .tvos, .visionos, .watchos => extern struct {
         sig: c_long = 0x32AAABA7,
-        data: [data_len]u8 = [_]u8{0} ** data_len,
+        data: [data_len]u8 = @splat(0),
 
         const data_len = if (@sizeOf(usize) == 8) 56 else 40;
     },
@@ -7966,10 +7966,10 @@ pub const pthread_mutex_t = switch (native_os) {
         data: u64 = 0,
     },
     .fuchsia => extern struct {
-        data: [40]u8 align(@alignOf(usize)) = [_]u8{0} ** 40,
+        data: [40]u8 align(@alignOf(usize)) = @splat(0),
     },
     .emscripten => extern struct {
-        data: [24]u8 align(4) = [_]u8{0} ** 24,
+        data: [24]u8 align(4) = @splat(0),
     },
     // https://github.com/SerenityOS/serenity/blob/b98f537f117b341788023ab82e0c11ca9ae29a57/Kernel/API/POSIX/sys/types.h#L68-L73
     .serenity => extern struct {
@@ -7983,11 +7983,11 @@ pub const pthread_mutex_t = switch (native_os) {
 
 pub const pthread_cond_t = switch (native_os) {
     .linux => extern struct {
-        data: [48]u8 align(@alignOf(usize)) = [_]u8{0} ** 48,
+        data: [48]u8 align(@alignOf(usize)) = @splat(0),
     },
     .driverkit, .ios, .maccatalyst, .macos, .tvos, .visionos, .watchos => extern struct {
         sig: c_long = 0x3CB0B1BB,
-        data: [data_len]u8 = [_]u8{0} ** data_len,
+        data: [data_len]u8 = @splat(0),
         const data_len = if (@sizeOf(usize) == 8) 40 else 24;
     },
     .freebsd, .dragonfly, .openbsd => extern struct {
@@ -8012,13 +8012,13 @@ pub const pthread_cond_t = switch (native_os) {
         lock: i32 = 0,
     },
     .illumos => extern struct {
-        flag: [4]u8 = [_]u8{0} ** 4,
+        flag: [4]u8 = @splat(0),
         type: u16 = 0,
         magic: u16 = 0x4356,
         data: u64 = 0,
     },
     .fuchsia, .emscripten => extern struct {
-        data: [48]u8 align(@alignOf(usize)) = [_]u8{0} ** 48,
+        data: [48]u8 align(@alignOf(usize)) = @splat(0),
     },
     // https://github.com/SerenityOS/serenity/blob/b98f537f117b341788023ab82e0c11ca9ae29a57/Kernel/API/POSIX/sys/types.h#L80-L84
     .serenity => extern struct {
@@ -8033,20 +8033,20 @@ pub const pthread_rwlock_t = switch (native_os) {
     .linux => switch (native_abi) {
         .android, .androideabi => switch (@sizeOf(usize)) {
             4 => extern struct {
-                data: [40]u8 align(@alignOf(usize)) = [_]u8{0} ** 40,
+                data: [40]u8 align(@alignOf(usize)) = @splat(0),
             },
             8 => extern struct {
-                data: [56]u8 align(@alignOf(usize)) = [_]u8{0} ** 56,
+                data: [56]u8 align(@alignOf(usize)) = @splat(0),
             },
             else => @compileError("impossible pointer size"),
         },
         else => extern struct {
-            data: [56]u8 align(@alignOf(usize)) = [_]u8{0} ** 56,
+            data: [56]u8 align(@alignOf(usize)) = @splat(0),
         },
     },
     .driverkit, .ios, .maccatalyst, .macos, .tvos, .visionos, .watchos => extern struct {
         sig: c_long = 0x2DA8B3B4,
-        data: [192]u8 = [_]u8{0} ** 192,
+        data: [192]u8 = @splat(0),
     },
     .freebsd, .dragonfly, .openbsd => extern struct {
         ptr: ?*anyopaque = null,
@@ -8079,10 +8079,10 @@ pub const pthread_rwlock_t = switch (native_os) {
         writercv: pthread_cond_t = .{},
     },
     .fuchsia => extern struct {
-        size: [56]u8 align(@alignOf(usize)) = [_]u8{0} ** 56,
+        size: [56]u8 align(@alignOf(usize)) = @splat(0),
     },
     .emscripten => extern struct {
-        size: [32]u8 align(4) = [_]u8{0} ** 32,
+        size: [32]u8 align(4) = @splat(0),
     },
     // https://github.com/SerenityOS/serenity/blob/b98f537f117b341788023ab82e0c11ca9ae29a57/Kernel/API/POSIX/sys/types.h#L86
     .serenity => extern struct {
@@ -8170,8 +8170,8 @@ pub const sem_t = switch (native_os) {
         count: u32 = 0,
         type: u16 = 0,
         magic: u16 = 0x534d,
-        __pad1: [3]u64 = [_]u64{0} ** 3,
-        __pad2: [2]u64 = [_]u64{0} ** 2,
+        __pad1: [3]u64 = @splat(0),
+        __pad2: [2]u64 = @splat(0),
     },
     .openbsd, .netbsd, .dragonfly => ?*opaque {},
     .haiku => extern struct {
@@ -8235,7 +8235,7 @@ pub const Kevent = switch (native_os) {
         /// Opaque user data identifier.
         udata: usize,
         /// Future extensions.
-        _ext: [4]u64 = [_]u64{0} ** 4,
+        _ext: [4]u64 = @splat(0),
     },
     .dragonfly => extern struct {
         ident: usize,

package/std/compress/flate/Decompress.zig

@@ -723,7 +723,7 @@ fn HuffmanDecoder(
             if (alphabet_size == 286)
                 if (lens[256] == 0) return error.MissingEndOfBlockCode;
 
-            var count = [_]u16{0} ** (@as(usize, max_code_bits) + 1);
+            var count: [@as(usize, max_code_bits) + 1]u16 = @splat(0);
             var max: usize = 0;
             for (lens) |n| {
                 if (n == 0) continue;

package/std/crypto/25519/curve25519.zig

@@ -41,7 +41,7 @@ pub const Curve25519 = struct {
 
     /// Multiply a point by the cofactor, returning WeakPublicKey if the element is in a small-order group.
     pub fn clearCofactor(p: Curve25519) WeakPublicKeyError!Curve25519 {
-        const cofactor = [_]u8{8} ++ [_]u8{0} ** 31;
+        const cofactor = [_]u8{8} ++ @as([31]u8, @splat(0));
         return ladder(p, cofactor, 4) catch return error.WeakPublicKey;
     }
 
@@ -168,7 +168,7 @@ test "elligator2" {
 }
 
 test "small order check" {
-    var s: [32]u8 = [_]u8{1} ++ [_]u8{0} ** 31;
+    var s: [32]u8 = [_]u8{1} ++ @as([31]u8, @splat(0));
     const small_order_ss: [7][32]u8 = .{
         .{
             0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0 (order 4)

package/std/crypto/25519/edwards25519.zig

@@ -470,7 +470,7 @@ pub const Edwards25519 = struct {
             st.final(&hctx);
             xctx = hctx[0..];
         }
-        const empty_block = [_]u8{0} ** H.block_length;
+        const empty_block: [H.block_length]u8 = @splat(0);
         var t = [3]u8{ 0, n * h_l, 0 };
         var xctx_len_u8 = [1]u8{@as(u8, @intCast(xctx.len))};
         var st = H.init(.{});
@@ -539,7 +539,7 @@ pub const Edwards25519 = struct {
 const htest = @import("../test.zig");
 
 test "packing/unpacking" {
-    const s = [_]u8{170} ++ [_]u8{0} ** 31;
+    const s = [1]u8{170} ++ @as([31]u8, @splat(0));
     var b = Edwards25519.basePoint;
     const pk = try b.mul(s);
     var buf: [128]u8 = undefined;
@@ -609,7 +609,7 @@ test "hash-to-curve operation" {
 }
 
 test "implicit reduction of invalid scalars" {
-    const s = [_]u8{0} ** 31 ++ [_]u8{255};
+    const s = @as([31]u8, @splat(0)) ++ [1]u8{255};
     const p1 = try Edwards25519.basePoint.mulPublic(s);
     const p2 = try Edwards25519.basePoint.mul(s);
     const p3 = try p1.mulPublic(s);

package/std/crypto/25519/ristretto255.zig

@@ -183,13 +183,13 @@ test "ristretto255" {
     q = q.dbl().add(p);
     try std.testing.expectEqualStrings(try std.fmt.bufPrint(&buf, "{X}", .{&q.toBytes()}), "E882B131016B52C1D3337080187CF768423EFCCBB517BB495AB812C4160FF44E");
 
-    const s = [_]u8{15} ++ [_]u8{0} ** 31;
+    const s = [_]u8{15} ++ @as([31]u8, @splat(0));
     const w = try p.mul(s);
     try std.testing.expectEqualStrings(try std.fmt.bufPrint(&buf, "{X}", .{&w.toBytes()}), "E0C418F7C8D9C4CDD7395B93EA124F3AD99021BB681DFC3302A9D99A2E53E64E");
 
     try std.testing.expect(p.dbl().dbl().dbl().dbl().equivalent(w.add(p)));
 
-    const h = [_]u8{69} ** 32 ++ [_]u8{42} ** 32;
+    const h = @as([32]u8, @splat(69)) ++ @as([32]u8, @splat(42));
     const ph = Ristretto255.fromUniform(h);
     try std.testing.expectEqualStrings(try std.fmt.bufPrint(&buf, "{X}", .{&ph.toBytes()}), "DCCA54E037A4311EFBEEF413ACD21D35276518970B7A61DC88F8587B493D5E19");
 }

package/std/crypto/25519/scalar.zig

@@ -11,7 +11,7 @@ pub const field_order: u256 = 72370055773322622139731865630429942408571163593799
 pub const CompressedScalar = [32]u8;
 
 /// Zero
-pub const zero = [_]u8{0} ** 32;
+pub const zero: [32]u8 = @splat(0);
 
 const field_order_s = s: {
     var s: [32]u8 = undefined;
@@ -81,7 +81,7 @@ pub fn add(a: CompressedScalar, b: CompressedScalar) CompressedScalar {
 
 /// Return -s (mod L)
 pub fn neg(s: CompressedScalar) CompressedScalar {
-    const fs: [64]u8 = field_order_s ++ [_]u8{0} ** 32;
+    const fs: [64]u8 = field_order_s ++ @as([32]u8, @splat(0));
     var sx: [64]u8 = undefined;
     sx[0..32].* = s;
     @memset(sx[32..], 0);
@@ -862,9 +862,9 @@ test "non-canonical scalar25519" {
 }
 
 test "mulAdd overflow check" {
-    const a: [32]u8 = [_]u8{0xff} ** 32;
-    const b: [32]u8 = [_]u8{0xff} ** 32;
-    const c: [32]u8 = [_]u8{0xff} ** 32;
+    const a: [32]u8 = @splat(0xff);
+    const b: [32]u8 = @splat(0xff);
+    const c: [32]u8 = @splat(0xff);
     const x = mulAdd(a, b, c);
     var buf: [128]u8 = undefined;
     try std.testing.expectEqualStrings(try std.fmt.bufPrint(&buf, "{X}", .{&x}), "D14DF91389432C25AD60FF9791B9FD1D67BEF517D273ECCE3D9A307C1B419903");
@@ -886,7 +886,7 @@ test "random scalar" {
 }
 
 test "64-bit reduction" {
-    const bytes = field_order_s ++ [_]u8{0} ** 32;
+    const bytes = field_order_s ++ @as([32]u8, @splat(0));
     const x = Scalar.fromBytes64(bytes);
     try std.testing.expect(x.isZero());
 }

package/std/crypto/25519/x25519.zig

@@ -181,7 +181,7 @@ test "rfc7748 1,000,000 iterations" {
 }
 
 test "edwards25519 -> curve25519 map" {
-    const ed_kp = try crypto.sign.Ed25519.KeyPair.generateDeterministic([_]u8{0x42} ** 32);
+    const ed_kp = try crypto.sign.Ed25519.KeyPair.generateDeterministic(@splat(0x42));
     const mont_kp = try X25519.KeyPair.fromEd25519(ed_kp);
     try htest.assertEqual("90e7595fc89e52fdfddce9c6a43d74dbf6047025ee0462d2d172e8b6a2841d6e", &mont_kp.secret_key);
     try htest.assertEqual("cc4f2cdb695dd766f34118eb67b98652fed1d8bc49c330b119bbfa8a64989378", &mont_kp.public_key);

package/std/crypto/Certificate.zig

@@ -1092,7 +1092,7 @@ pub const rsa = struct {
             }
             var m_p_buf: [8 + Hash.digest_length + Hash.digest_length]u8 = undefined;
             var m_p = m_p_buf[0 .. 8 + Hash.digest_length + sLen];
-            std.mem.copyForwards(u8, m_p, &([_]u8{0} ** 8));
+            std.mem.copyForwards(u8, m_p, @as(*const [8]u8, &@splat(0)));
             std.mem.copyForwards(u8, m_p[8..], &mHash);
             std.mem.copyForwards(u8, m_p[(8 + Hash.digest_length)..], salt);
 

package/std/crypto/Sha1.zig

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