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

package/std/heap/memory_pool.zig

@@ -3,11 +3,6 @@ const Allocator = std.mem.Allocator;
 const Alignment = std.mem.Alignment;
 const MemoryPool = std.heap.MemoryPool;
 
-/// Deprecated.
-pub fn Managed(comptime Item: type) type {
-    return ExtraManaged(Item, .{ .alignment = null });
-}
-
 /// A memory pool that can allocate objects of a single type very quickly.
 /// Use this when you need to allocate a lot of objects of the same type,
 /// because it outperforms general purpose allocators.
@@ -18,11 +13,6 @@ pub fn Aligned(comptime Item: type, comptime alignment: Alignment) type {
     return Extra(Item, .{ .alignment = alignment });
 }
 
-/// Deprecated.
-pub fn AlignedManaged(comptime Item: type, comptime alignment: Alignment) type {
-    return ExtraManaged(Item, .{ .alignment = alignment });
-}
-
 pub const Options = struct {
     /// The alignment of the memory pool items. Use `null` for natural alignment.
     alignment: ?Alignment = null,
@@ -83,13 +73,6 @@ pub fn Extra(comptime Item: type, comptime pool_options: Options) type {
             pool.* = undefined;
         }
 
-        pub fn toManaged(pool: Pool, allocator: Allocator) ExtraManaged(Item, pool_options) {
-            return .{
-                .allocator = allocator,
-                .unmanaged = pool,
-            };
-        }
-
         /// Pre-allocates `num` items and adds them to the memory pool.
         /// This allows at least `num` active allocations before an
         /// `OutOfMemory` error might happen when calling `create()`.
@@ -114,7 +97,7 @@ pub fn Extra(comptime Item: type, comptime pool_options: Options) type {
         /// NOTE: If `mode` is `free_all`, the function will always return `true`.
         pub fn reset(pool: *Pool, allocator: Allocator, mode: ResetMode) bool {
             // TODO: Potentially store all allocated objects in a list as well, allowing to
-            //       just move them into the free list instead of actually releasing the memory.
+            // just move them into the free list instead of actually releasing the memory.
 
             var arena = pool.arena_state.promote(allocator);
             defer pool.arena_state = arena.state;
@@ -155,182 +138,56 @@ pub fn Extra(comptime Item: type, comptime pool_options: Options) type {
     };
 }
 
-/// Deprecated.
-pub fn ExtraManaged(comptime Item: type, comptime pool_options: Options) type {
-    if (pool_options.alignment) |a| {
-        if (a.compare(.eq, .of(Item))) {
-            var new_options = pool_options;
-            new_options.alignment = null;
-            return ExtraManaged(Item, new_options);
-        }
-    }
-    return struct {
-        const Pool = @This();
-
-        allocator: Allocator,
-        unmanaged: Unmanaged,
-
-        pub const Unmanaged = Extra(Item, pool_options);
-        pub const item_size = Unmanaged.item_size;
-        pub const item_alignment = Unmanaged.item_alignment;
-
-        const ItemPtr = Unmanaged.ItemPtr;
-
-        /// Creates a new memory pool.
-        pub fn init(allocator: Allocator) Pool {
-            return Unmanaged.empty.toManaged(allocator);
-        }
-
-        /// Creates a new memory pool and pre-allocates `num` items.
-        /// This allows up to `num` active allocations before an
-        /// `OutOfMemory` error might happen when calling `create()`.
-        pub fn initCapacity(allocator: Allocator, num: usize) Allocator.Error!Pool {
-            return (try Unmanaged.initCapacity(allocator, num)).toManaged(allocator);
-        }
-
-        /// Destroys the memory pool and frees all allocated memory.
-        pub fn deinit(pool: *Pool) void {
-            pool.unmanaged.deinit(pool.allocator);
-            pool.* = undefined;
-        }
-
-        /// Pre-allocates `num` items and adds them to the memory pool.
-        /// This allows at least `num` active allocations before an
-        /// `OutOfMemory` error might happen when calling `create()`.
-        pub fn addCapacity(pool: *Pool, num: usize) Allocator.Error!void {
-            return pool.unmanaged.addCapacity(pool.allocator, num);
-        }
-
-        pub const ResetMode = Unmanaged.ResetMode;
-
-        /// Resets the memory pool and destroys all allocated items.
-        /// This can be used to batch-destroy all objects without invalidating the memory pool.
-        ///
-        /// The function will return whether the reset operation was successful or not.
-        /// If the reallocation  failed `false` is returned. The pool will still be fully
-        /// functional in that case, all memory is released. Future allocations just might
-        /// be slower.
-        ///
-        /// NOTE: If `mode` is `free_all`, the function will always return `true`.
-        pub fn reset(pool: *Pool, mode: ResetMode) bool {
-            return pool.unmanaged.reset(pool.allocator, mode);
-        }
-
-        /// Creates a new item and adds it to the memory pool.
-        pub fn create(pool: *Pool) Allocator.Error!ItemPtr {
-            return pool.unmanaged.create(pool.allocator);
-        }
-
-        /// Destroys a previously created item.
-        /// Only pass items to `ptr` that were previously created with `create()` of the same memory pool!
-        pub fn destroy(pool: *Pool, ptr: ItemPtr) void {
-            return pool.unmanaged.destroy(ptr);
-        }
-
-        fn allocNew(pool: *Pool) Allocator.Error!*align(item_alignment) [item_size]u8 {
-            return pool.unmanaged.allocNew(pool.allocator);
-        }
-    };
-}
-
 test "basic" {
     const a = std.testing.allocator;
 
-    {
-        var pool: MemoryPool(u32) = .empty;
-        defer pool.deinit(a);
-
-        const p1 = try pool.create(a);
-        const p2 = try pool.create(a);
-        const p3 = try pool.create(a);
-
-        // Assert uniqueness
-        try std.testing.expect(p1 != p2);
-        try std.testing.expect(p1 != p3);
-        try std.testing.expect(p2 != p3);
+    var pool: MemoryPool(u32) = .empty;
+    defer pool.deinit(a);
 
-        pool.destroy(p2);
-        const p4 = try pool.create(a);
-
-        // Assert memory reuse
-        try std.testing.expect(p2 == p4);
-    }
+    const p1 = try pool.create(a);
+    const p2 = try pool.create(a);
+    const p3 = try pool.create(a);
 
-    {
-        var pool: Managed(u32) = .init(std.testing.allocator);
-        defer pool.deinit();
+    // Assert uniqueness
+    try std.testing.expect(p1 != p2);
+    try std.testing.expect(p1 != p3);
+    try std.testing.expect(p2 != p3);
 
-        const p1 = try pool.create();
-        const p2 = try pool.create();
-        const p3 = try pool.create();
+    pool.destroy(p2);
+    const p4 = try pool.create(a);
 
-        // Assert uniqueness
-        try std.testing.expect(p1 != p2);
-        try std.testing.expect(p1 != p3);
-        try std.testing.expect(p2 != p3);
-
-        pool.destroy(p2);
-        const p4 = try pool.create();
-
-        // Assert memory reuse
-        try std.testing.expect(p2 == p4);
-    }
+    // Assert memory reuse
+    try std.testing.expect(p2 == p4);
 }
 
 test "initCapacity (success)" {
     const a = std.testing.allocator;
 
-    {
-        var pool: MemoryPool(u32) = try .initCapacity(a, 4);
-        defer pool.deinit(a);
-
-        _ = try pool.create(a);
-        _ = try pool.create(a);
-        _ = try pool.create(a);
-    }
-
-    {
-        var pool: Managed(u32) = try .initCapacity(a, 4);
-        defer pool.deinit();
+    var pool: MemoryPool(u32) = try .initCapacity(a, 4);
+    defer pool.deinit(a);
 
-        _ = try pool.create();
-        _ = try pool.create();
-        _ = try pool.create();
-    }
+    _ = try pool.create(a);
+    _ = try pool.create(a);
+    _ = try pool.create(a);
 }
 
 test "initCapacity (failure)" {
     const failer = std.testing.failing_allocator;
     try std.testing.expectError(error.OutOfMemory, MemoryPool(u32).initCapacity(failer, 5));
-    try std.testing.expectError(error.OutOfMemory, Managed(u32).initCapacity(failer, 5));
 }
 
 test "growable" {
     const a = std.testing.allocator;
 
-    {
-        var pool: Extra(u32, .{ .growable = false }) = try .initCapacity(a, 4);
-        defer pool.deinit(a);
-
-        _ = try pool.create(a);
-        _ = try pool.create(a);
-        _ = try pool.create(a);
-        _ = try pool.create(a);
-
-        try std.testing.expectError(error.OutOfMemory, pool.create(a));
-    }
-
-    {
-        var pool: ExtraManaged(u32, .{ .growable = false }) = try .initCapacity(a, 4);
-        defer pool.deinit();
+    var pool: Extra(u32, .{ .growable = false }) = try .initCapacity(a, 4);
+    defer pool.deinit(a);
 
-        _ = try pool.create();
-        _ = try pool.create();
-        _ = try pool.create();
-        _ = try pool.create();
+    _ = try pool.create(a);
+    _ = try pool.create(a);
+    _ = try pool.create(a);
+    _ = try pool.create(a);
 
-        try std.testing.expectError(error.OutOfMemory, pool.create());
-    }
+    try std.testing.expectError(error.OutOfMemory, pool.create(a));
 }
 
 test "greater than pointer default alignment" {
@@ -339,21 +196,11 @@ test "greater than pointer default alignment" {
     };
     const a = std.testing.allocator;
 
-    {
-        var pool: MemoryPool(Foo) = .empty;
-        defer pool.deinit(a);
-
-        const foo: *Foo = try pool.create(a);
-        pool.destroy(foo);
-    }
-
-    {
-        var pool: Managed(Foo) = .init(a);
-        defer pool.deinit();
+    var pool: MemoryPool(Foo) = .empty;
+    defer pool.deinit(a);
 
-        const foo: *Foo = try pool.create();
-        pool.destroy(foo);
-    }
+    const foo: *Foo = try pool.create(a);
+    pool.destroy(foo);
 }
 
 test "greater than pointer manual alignment" {
@@ -362,19 +209,9 @@ test "greater than pointer manual alignment" {
     };
     const a = std.testing.allocator;
 
-    {
-        var pool: Aligned(Foo, .@"16") = .empty;
-        defer pool.deinit(a);
-
-        const foo: *align(16) Foo = try pool.create(a);
-        pool.destroy(foo);
-    }
+    var pool: Aligned(Foo, .@"16") = .empty;
+    defer pool.deinit(a);
 
-    {
-        var pool: AlignedManaged(Foo, .@"16") = .init(a);
-        defer pool.deinit();
-
-        const foo: *align(16) Foo = try pool.create();
-        pool.destroy(foo);
-    }
+    const foo: *align(16) Foo = try pool.create(a);
+    pool.destroy(foo);
 }

package/std/heap.zig

@@ -30,13 +30,6 @@ pub fn MemoryPool(comptime Item: type) type {
 }
 pub const memory_pool = @import("heap/memory_pool.zig");
 
-/// Deprecated; use `memory_pool.Aligned`.
-pub const MemoryPoolAligned = memory_pool.Aligned;
-/// Deprecated; use `memory_pool.Extra`.
-pub const MemoryPoolExtra = memory_pool.Extra;
-/// Deprecated; use `memory_pool.Options`.
-pub const MemoryPoolOptions = memory_pool.Options;
-
 /// comptime-known minimum page size of the target.
 ///
 /// All pointers from `mmap` or `NtAllocateVirtualMemory` are aligned to at least

package/std/http.zig

@@ -749,7 +749,7 @@ pub const BodyWriter = struct {
     /// How many zeroes to reserve for hex-encoded chunk length.
     const chunk_len_digits = 8;
     const max_chunk_len: usize = std.math.pow(u64, 16, chunk_len_digits) - 1;
-    const chunk_header_template = ("0" ** chunk_len_digits) ++ "\r\n";
+    const chunk_header_template = @as([chunk_len_digits]u8, @splat('0')) ++ "\r\n";
 
     comptime {
         assert(max_chunk_len == std.math.maxInt(u32));

package/std/json/static.zig

@@ -334,7 +334,7 @@ pub fn innerParse(
             if (.object_begin != try source.next()) return error.UnexpectedToken;
 
             var r: T = undefined;
-            var fields_seen = [_]bool{false} ** structInfo.fields.len;
+            var fields_seen: [structInfo.fields.len]bool = @splat(false);
 
             while (true) {
                 var name_token: ?Token = try source.nextAllocMax(allocator, .alloc_if_needed, options.max_value_len.?);
@@ -649,7 +649,7 @@ pub fn innerParseFromValue(
             if (source != .object) return error.UnexpectedToken;
 
             var r: T = undefined;
-            var fields_seen = [_]bool{false} ** structInfo.fields.len;
+            var fields_seen: [structInfo.fields.len]bool = @splat(false);
 
             var it = source.object.iterator();
             while (it.next()) |kv| {

package/std/math/big/int.zig

@@ -29,8 +29,8 @@ const Constants = struct {
 };
 const constants: Constants = blk: {
     @setEvalBranchQuota(2000);
-    var digits_per_limb = [_]u8{0} ** 37;
-    var bases = [_]Limb{0} ** 37;
+    var digits_per_limb: [37]u8 = @splat(0);
+    var bases: [37]Limb = @splat(0);
     for (2..37) |base| {
         digits_per_limb[base] = @intCast(math.log(Limb, base, math.maxInt(Limb)));
         bases[base] = std.math.pow(Limb, base, digits_per_limb[base]);
@@ -2391,7 +2391,7 @@ pub const Const = struct {
         var limbs: [calcToStringLimbsBufferLen(available_len, 10)]Limb = undefined;
 
         const biggest: Const = .{
-            .limbs = &([1]Limb{comptime math.maxInt(Limb)} ** available_len),
+            .limbs = &@as([available_len]Limb, @splat(comptime math.maxInt(Limb))),
             .positive = false,
         };
         var buf: [biggest.sizeInBaseUpperBound(2)]u8 = undefined;

package/std/math/nextafter.zig

@@ -23,7 +23,7 @@ pub fn nextAfter(comptime T: type, x: T, y: T) T {
 fn nextAfterInt(comptime T: type, x: T, y: T) T {
     comptime assert(@typeInfo(T) == .int or @typeInfo(T) == .comptime_int);
     return if (@typeInfo(T) == .int and @bitSizeOf(T) < 2)
-        // Special case for `i0`, `u0`, `i1`, and `u1`.
+        // Special case for `u0`, `i1`, and `u1`.
         y
     else if (y > x)
         x + 1
@@ -102,7 +102,6 @@ fn nextAfterFloat(comptime T: type, x: T, y: T) T {
 }
 
 test "int" {
-    try expect(nextAfter(i0, 0, 0) == 0);
     try expect(nextAfter(u0, 0, 0) == 0);
     try expect(nextAfter(i1, 0, 0) == 0);
     try expect(nextAfter(i1, 0, -1) == -1);

package/std/math/powi.zig

@@ -15,12 +15,12 @@ const testing = std.testing;
 ///  - Underflow: Absolute value of result smaller than 1
 ///
 /// Edge case rules ordered by precedence:
-///  - powi(T, x, 0)   = 1 unless T is i1, i0, u0
+///  - powi(T, x, 0)   = 1 unless T is i1, u0
 ///  - powi(T, 0, x)   = 0 when x > 0
 ///  - powi(T, 0, x)   = Overflow
 ///  - powi(T, 1, y)   = 1
 ///  - powi(T, -1, y)  = -1 for y an odd integer
-///  - powi(T, -1, y)  = 1 unless T is i1, i0, u0
+///  - powi(T, -1, y)  = 1 unless T is i1, u0
 ///  - powi(T, -1, y)  = Overflow
 ///  - powi(T, x, y)   = Overflow when y >= @bitSizeOf(x)
 ///  - powi(T, x, y)   = Underflow when y < 0
@@ -189,7 +189,6 @@ test "powi.special" {
 
 test "powi.narrow" {
     try testing.expectError(error.Overflow, powi(u0, 0, 0));
-    try testing.expectError(error.Overflow, powi(i0, 0, 0));
     try testing.expectError(error.Overflow, powi(i1, 0, 0));
     try testing.expectError(error.Overflow, powi(i1, -1, 0));
     try testing.expectError(error.Overflow, powi(i1, 0, -1));

package/std/math/signbit.zig

@@ -13,7 +13,6 @@ pub fn signbit(x: anytype) bool {
 }
 
 test signbit {
-    try testInts(i0);
     try testInts(u0);
     try testInts(i1);
     try testInts(u1);

package/std/math.zig

@@ -1141,13 +1141,11 @@ test isPowerOfTwo {
 pub fn ByteAlignedInt(comptime T: type) type {
     const info = @typeInfo(T).int;
     const bits = (info.bits + 7) / 8 * 8;
-    const extended_type = std.meta.Int(info.signedness, bits);
-    return extended_type;
+    return @Int(info.signedness, bits);
 }
 
 test ByteAlignedInt {
     try testing.expect(ByteAlignedInt(u0) == u0);
-    try testing.expect(ByteAlignedInt(i0) == i0);
     try testing.expect(ByteAlignedInt(u3) == u8);
     try testing.expect(ByteAlignedInt(u8) == u8);
     try testing.expect(ByteAlignedInt(i111) == i112);
@@ -1218,7 +1216,7 @@ pub fn ceilPowerOfTwoPromote(comptime T: type, value: T) std.meta.Int(@typeInfo(
     comptime assert(@typeInfo(T) == .int);
     comptime assert(@typeInfo(T).int.signedness == .unsigned);
     assert(value != 0);
-    const PromotedType = std.meta.Int(@typeInfo(T).int.signedness, @typeInfo(T).int.bits + 1);
+    const PromotedType = @Int(@typeInfo(T).int.signedness, @typeInfo(T).int.bits + 1);
     const ShiftType = std.math.Log2Int(PromotedType);
     return @as(PromotedType, 1) << @as(ShiftType, @intCast(@typeInfo(T).int.bits - @clz(value - 1)));
 }
@@ -1230,7 +1228,7 @@ pub fn ceilPowerOfTwo(comptime T: type, value: T) (error{Overflow}!T) {
     comptime assert(@typeInfo(T) == .int);
     const info = @typeInfo(T).int;
     comptime assert(info.signedness == .unsigned);
-    const PromotedType = std.meta.Int(info.signedness, info.bits + 1);
+    const PromotedType = @Int(info.signedness, info.bits + 1);
     const overflowBit = @as(PromotedType, 1) << info.bits;
     const x = ceilPowerOfTwoPromote(T, value);
     if (overflowBit & x != 0) {
@@ -1442,19 +1440,17 @@ test lerp {
 
 /// Returns the maximum value of integer type T.
 pub fn maxInt(comptime T: type) comptime_int {
-    const info = @typeInfo(T);
-    const bit_count = info.int.bits;
-    if (bit_count == 0) return 0;
-    return (1 << (bit_count - @intFromBool(info.int.signedness == .signed))) - 1;
+    const info = @typeInfo(T).int;
+    return (1 << (info.bits - @intFromBool(info.signedness == .signed))) - 1;
 }
 
 /// Returns the minimum value of integer type T.
 pub fn minInt(comptime T: type) comptime_int {
-    const info = @typeInfo(T);
-    const bit_count = info.int.bits;
-    if (info.int.signedness == .unsigned) return 0;
-    if (bit_count == 0) return 0;
-    return -(1 << (bit_count - 1));
+    const info = @typeInfo(T).int;
+    return switch (info.signedness) {
+        .unsigned => 0,
+        .signed => -(1 << (info.bits - 1)),
+    };
 }
 
 test maxInt {
@@ -1466,7 +1462,6 @@ test maxInt {
     try testing.expect(maxInt(u64) == 18446744073709551615);
     try testing.expect(maxInt(u128) == 340282366920938463463374607431768211455);
 
-    try testing.expect(maxInt(i0) == 0);
     try testing.expect(maxInt(i1) == 0);
     try testing.expect(maxInt(i8) == 127);
     try testing.expect(maxInt(i16) == 32767);
@@ -1486,7 +1481,6 @@ test minInt {
     try testing.expect(minInt(u64) == 0);
     try testing.expect(minInt(u128) == 0);
 
-    try testing.expect(minInt(i0) == 0);
     try testing.expect(minInt(i1) == -1);
     try testing.expect(minInt(i8) == -128);
     try testing.expect(minInt(i16) == -32768);
@@ -1710,8 +1704,8 @@ pub inline fn boolMask(comptime MaskInt: type, value: bool) MaskInt {
     if (@typeInfo(MaskInt) != .int)
         @compileError("boolMask requires an integer mask type.");
 
-    if (MaskInt == u0 or MaskInt == i0)
-        @compileError("boolMask cannot convert to u0 or i0, they are too small.");
+    if (MaskInt == u0)
+        @compileError("boolMask cannot convert to u0, it is too small.");
 
     // The u1 and i1 cases tend to overflow,
     // so we special case them here.

package/std/mem.zig

@@ -359,7 +359,10 @@ test zeroes {
     var a = zeroes(C_struct);
 
     // Extern structs should have padding zeroed out.
-    try testing.expectEqualSlices(u8, &[_]u8{0} ** @sizeOf(@TypeOf(a)), asBytes(&a));
+    {
+        const num_bytes = @sizeOf(@TypeOf(a));
+        try testing.expectEqualSlices(u8, &@as([num_bytes]u8, @splat(0)), @ptrCast(&a));
+    }
 
     a.y += 10;
 
@@ -370,7 +373,6 @@ test zeroes {
         comptime comptime_field: u8 = 5,
 
         integral_types: struct {
-            integer_0: i0,
             integer_8: i8,
             integer_16: i16,
             integer_32: i32,
@@ -405,7 +407,6 @@ test zeroes {
 
     const b = zeroes(ZigStruct);
     try testing.expectEqual(@as(u8, 5), b.comptime_field);
-    try testing.expectEqual(@as(i8, 0), b.integral_types.integer_0);
     try testing.expectEqual(@as(i8, 0), b.integral_types.integer_8);
     try testing.expectEqual(@as(i16, 0), b.integral_types.integer_16);
     try testing.expectEqual(@as(i32, 0), b.integral_types.integer_32);
@@ -1589,7 +1590,7 @@ test find {
 test "find multibyte" {
     {
         // make haystack and needle long enough to trigger Boyer-Moore-Horspool algorithm
-        const haystack = [1]u16{0} ** 100 ++ [_]u16{ 0xbbaa, 0xccbb, 0xddcc, 0xeedd, 0xffee, 0x00ff };
+        const haystack = @as([100]u16, @splat(0)) ++ [_]u16{ 0xbbaa, 0xccbb, 0xddcc, 0xeedd, 0xffee, 0x00ff };
         const needle = [_]u16{ 0xbbaa, 0xccbb, 0xddcc, 0xeedd, 0xffee };
         try testing.expectEqual(findPos(u16, &haystack, 0, &needle), 100);
 
@@ -1602,7 +1603,7 @@ test "find multibyte" {
 
     {
         // make haystack and needle long enough to trigger Boyer-Moore-Horspool algorithm
-        const haystack = [_]u16{ 0xbbaa, 0xccbb, 0xddcc, 0xeedd, 0xffee, 0x00ff } ++ [1]u16{0} ** 100;
+        const haystack = [_]u16{ 0xbbaa, 0xccbb, 0xddcc, 0xeedd, 0xffee, 0x00ff } ++ @as([100]u16, @splat(0));
         const needle = [_]u16{ 0xbbaa, 0xccbb, 0xddcc, 0xeedd, 0xffee };
         try testing.expectEqual(lastIndexOf(u16, &haystack, &needle), 0);
 
@@ -4647,7 +4648,7 @@ test "sliceAsBytes with sentinel slice" {
 }
 
 test "sliceAsBytes with zero-bit element type" {
-    const lots_of_nothing = [1]void{{}} ** 10_000;
+    const lots_of_nothing: [10_000]void = @splat({});
     const bytes = sliceAsBytes(&lots_of_nothing);
     try testing.expect(bytes.len == 0);
 }
@@ -4865,8 +4866,8 @@ test doNotOptimizeAway {
     doNotOptimizeAway(@as(u200, 0));
     doNotOptimizeAway(@as(f32, 0.0));
     doNotOptimizeAway(@as(f64, 0.0));
-    doNotOptimizeAway([_]u8{0} ** 4);
-    doNotOptimizeAway([_]u8{0} ** 100);
+    doNotOptimizeAway(@as([4]u8, @splat(0)));
+    doNotOptimizeAway(@as([100]u8, @splat(0)));
     doNotOptimizeAway(@as(std.builtin.Endian, .little));
 }
 

package/std/meta.zig

@@ -1067,7 +1067,7 @@ test hasUniqueRepresentation {
 
     try testing.expect(!hasUniqueRepresentation(TestUnion4));
 
-    inline for ([_]type{ i0, u8, i16, u32, i64 }) |T| {
+    inline for ([_]type{ u8, i16, u32, i64 }) |T| {
         try testing.expect(hasUniqueRepresentation(T));
         try testing.expect(hasUniqueRepresentation(enum(T) { _ }));
     }

package/std/multi_array_list.zig

@@ -133,6 +133,13 @@ pub fn MultiArrayList(comptime T: type) type {
                 };
             }
 
+            pub fn swap(self: Slice, a: usize, b: usize) void {
+                inline for (@typeInfo(Field).@"enum".fields) |field| {
+                    const its = self.items(@field(Field, field.name));
+                    std.mem.swap(@FieldType(T, field.name), &its[a], &its[b]);
+                }
+            }
+
             pub fn toMultiArrayList(self: Slice) Self {
                 if (self.ptrs.len == 0 or self.capacity == 0) {
                     return .{};
@@ -267,6 +274,10 @@ pub fn MultiArrayList(comptime T: type) type {
             return self.slice().get(index);
         }
 
+        pub fn swap(self: Self, a: usize, b: usize) void {
+            return self.slice().swap(a, b);
+        }
+
         /// Extend the list by 1 element.
         ///
         /// Allocates more memory as necessary.
@@ -771,6 +782,19 @@ test "basic usage" {
     try testing.expectEqualSlices(u32, list.items(.a), &[_]u32{ 1, 2, 3 });
     try testing.expectEqualSlices(u8, list.items(.c), &[_]u8{ 'a', 'b', 'c' });
 
+    list.swap(0, 2);
+    try testing.expectEqualSlices(u32, list.items(.a), &[_]u32{ 3, 2, 1 });
+    try testing.expectEqualSlices(u8, list.items(.c), &[_]u8{ 'c', 'b', 'a' });
+    list.swap(2, 1);
+    try testing.expectEqualSlices(u32, list.items(.a), &[_]u32{ 3, 1, 2 });
+    try testing.expectEqualSlices(u8, list.items(.c), &[_]u8{ 'c', 'a', 'b' });
+    list.swap(2, 0);
+    try testing.expectEqualSlices(u32, list.items(.a), &[_]u32{ 2, 1, 3 });
+    try testing.expectEqualSlices(u8, list.items(.c), &[_]u8{ 'b', 'a', 'c' });
+    list.swap(0, 1);
+    try testing.expectEqualSlices(u32, list.items(.a), &[_]u32{ 1, 2, 3 });
+    try testing.expectEqualSlices(u8, list.items(.c), &[_]u8{ 'a', 'b', 'c' });
+
     try testing.expectEqual(@as(usize, 3), list.items(.b).len);
     try testing.expectEqualStrings("foobar", list.items(.b)[0]);
     try testing.expectEqualStrings("zigzag", list.items(.b)[1]);

package/std/os/emscripten.zig

@@ -373,7 +373,7 @@ pub const rusage = extern struct {
     nsignals: isize,
     nvcsw: isize,
     nivcsw: isize,
-    __reserved: [16]isize = [1]isize{0} ** 16,
+    __reserved: [16]isize = @splat(0),
 
     pub const SELF = 0;
     pub const CHILDREN = -1;
@@ -481,7 +481,7 @@ pub const Sigaction = extern struct {
 
 pub const sigset_t = [1024 / 32]u32;
 pub fn sigemptyset() sigset_t {
-    return [_]u32{0} ** @typeInfo(sigset_t).array.len;
+    return @splat(0);
 }
 pub const siginfo_t = extern struct {
     signo: i32,