@zigc/lib 0.17.0-dev.56 → 0.17.0-dev.607

package/std/enums.zig

@@ -166,7 +166,7 @@ pub fn directEnumArrayDefault(
     init_values: EnumFieldStruct(E, Data, default),
 ) [directEnumArrayLen(E, max_unused_slots)]Data {
     const len = comptime directEnumArrayLen(E, max_unused_slots);
-    var result: [len]Data = if (default) |d| [_]Data{d} ** len else undefined;
+    var result: [len]Data = @splat(default orelse undefined);
     inline for (@typeInfo(@TypeOf(init_values)).@"struct".fields) |f| {
         const enum_value = @field(E, f.name);
         const index = @as(usize, @intCast(@intFromEnum(enum_value)));
@@ -247,7 +247,7 @@ pub fn EnumSet(comptime E: type) type {
         /// The element type for this set.
         pub const Key = Indexer.Key;
 
-        const BitSet = std.StaticBitSet(Indexer.count);
+        const BitSet = std.bit_set.Static(Indexer.count);
 
         /// The maximum number of items in this set.
         pub const len = Indexer.count;
@@ -284,18 +284,6 @@ pub fn EnumSet(comptime E: type) type {
         /// A set containing all possible keys.
         pub const full: Self = .{ .bits = .full };
 
-        /// Deprecated: use `.empty`.
-        /// Returns a set containing no keys.
-        pub fn initEmpty() Self {
-            return .empty;
-        }
-
-        /// Deprecated: use `.full`.
-        /// Returns a set containing all possible keys.
-        pub fn initFull() Self {
-            return .full;
-        }
-
         /// Returns a set containing multiple keys.
         pub fn initMany(keys: []const Key) Self {
             var set: Self = .empty;
@@ -445,7 +433,7 @@ pub fn EnumMap(comptime E: type, comptime V: type) type {
         /// The number of possible keys in the map
         pub const len = Indexer.count;
 
-        const BitSet = std.StaticBitSet(Indexer.count);
+        const BitSet = std.bit_set.Static(Indexer.count);
 
         /// Bits determining whether items are in the map
         bits: BitSet = .empty,
@@ -1291,7 +1279,7 @@ pub fn EnumIndexer(comptime E: type) type {
             const min_value = std.math.minInt(BackingInt);
             const max_value = std.math.maxInt(BackingInt);
 
-            const RangeType = std.meta.Int(.unsigned, @bitSizeOf(BackingInt));
+            const RangeType = @Int(.unsigned, @bitSizeOf(BackingInt));
             pub const count: comptime_int = std.math.maxInt(RangeType) + 1;
 
             pub fn indexOf(e: E) usize {
@@ -1307,7 +1295,7 @@ pub fn EnumIndexer(comptime E: type) type {
                 if (backing_int_sign == .unsigned)
                     return @enumFromInt(i);
 
-                return @enumFromInt(@as(std.meta.Int(.signed, @bitSizeOf(RangeType) + 1), @intCast(i)) + min_value);
+                return @enumFromInt(@as(@Int(.signed, @bitSizeOf(RangeType) + 1), @intCast(i)) + min_value);
             }
         };
     }
@@ -1380,14 +1368,14 @@ test "EnumIndexer non-exhaustive" {
         i4,
         i8,
         i16,
-        std.meta.Int(.signed, @bitSizeOf(isize) - 1),
+        @Int(.signed, @bitSizeOf(isize) - 1),
         isize,
         u1,
         u2,
         u3,
         u4,
         u16,
-        std.meta.Int(.unsigned, @bitSizeOf(usize) - 1),
+        @Int(.unsigned, @bitSizeOf(usize) - 1),
         usize,
     };
     inline for (backing_ints) |BackingInt| {
@@ -1400,7 +1388,7 @@ test "EnumIndexer non-exhaustive" {
         const min_tag: E = @enumFromInt(std.math.minInt(BackingInt));
         const max_tag: E = @enumFromInt(std.math.maxInt(BackingInt));
 
-        const RangedType = std.meta.Int(.unsigned, @bitSizeOf(BackingInt));
+        const RangedType = @Int(.unsigned, @bitSizeOf(BackingInt));
         const max_index: comptime_int = std.math.maxInt(RangedType);
         const number_zero_tag_index: usize = switch (@typeInfo(BackingInt).int.signedness) {
             .unsigned => 0,

package/std/fmt/float.zig

@@ -1646,6 +1646,8 @@ test "format f64" {
 }
 
 test "format f80" {
+    if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest;
+
     try check(f80, 0.0, "0e0");
     try check(f80, -0.0, "-0e0");
     try check(f80, 1.0, "1e0");

package/std/fmt/parse_float/decimal.zig

@@ -80,7 +80,7 @@ pub fn Decimal(comptime T: type) type {
                 .num_digits = 0,
                 .decimal_point = 0,
                 .truncated = false,
-                .digits = [_]u8{0} ** max_digits,
+                .digits = @splat(0),
             };
         }
 

package/std/fmt/parse_float.zig

@@ -128,7 +128,7 @@ test parseFloat {
 
 test "nan and inf" {
     inline for ([_]type{ f16, f32, f64, f80, f128 }) |T| {
-        const Z = std.meta.Int(.unsigned, @typeInfo(T).float.bits);
+        const Z = @Int(.unsigned, @typeInfo(T).float.bits);
 
         try expectEqual(@as(Z, @bitCast(try parseFloat(T, "nAn"))), @as(Z, @bitCast(std.math.nan(T))));
         try expectEqual(try parseFloat(T, "inF"), std.math.inf(T));

package/std/fmt.zig

@@ -433,7 +433,7 @@ fn parseIntWithSign(
     // accumulate into Accumulate which is always 8 bits or larger.  this prevents
     // `buf_base` from overflowing Result.
     const info = @typeInfo(Result);
-    const Accumulate = std.meta.Int(info.int.signedness, @max(8, info.int.bits));
+    const Accumulate = @Int(info.int.signedness, @max(8, info.int.bits));
     var accumulate: Accumulate = 0;
 
     if (buf_start[0] == '_' or buf_start[buf_start.len - 1] == '_') return error.InvalidCharacter;
@@ -542,7 +542,7 @@ pub fn parseIntSizeSuffix(buf: []const u8, digit_base: u8) ParseIntError!usize {
     }
     const multiplier = math.powi(usize, magnitude_base, orders_of_magnitude) catch |err| switch (err) {
         error.Underflow => unreachable,
-        error.Overflow => return error.Overflow,
+        error.Overflow => |e| return e,
     };
     const number = try std.fmt.parseInt(usize, without_suffix, digit_base);
     return math.mul(usize, number, multiplier);
@@ -602,11 +602,6 @@ pub fn bufPrint(buf: []u8, comptime fmt: []const u8, args: anytype) BufPrintErro
     return w.buffered();
 }
 
-/// Deprecated in favor of `bufPrintSentinel`
-pub fn bufPrintZ(buf: []u8, comptime fmt: []const u8, args: anytype) BufPrintError![:0]u8 {
-    return try bufPrintSentinel(buf, fmt, args, 0);
-}
-
 pub fn bufPrintSentinel(
     buf: []u8,
     comptime fmt: []const u8,
@@ -1194,8 +1189,12 @@ test bytesToHex {
 }
 
 test hexToBytes {
+    const repeated: []const u8 = repeated: {
+        const buf: [32][2]u8 = @splat("90".*);
+        break :repeated @ptrCast(&buf);
+    };
     var buf: [32]u8 = undefined;
-    try expectFmt("90" ** 32, "{X}", .{try hexToBytes(&buf, "90" ** 32)});
+    try expectFmt(repeated, "{X}", .{try hexToBytes(&buf, repeated)});
     try expectFmt("ABCD", "{X}", .{try hexToBytes(&buf, "ABCD")});
     try expectFmt("", "{X}", .{try hexToBytes(&buf, "")});
     try std.testing.expectError(error.InvalidCharacter, hexToBytes(&buf, "012Z"));

package/std/fs/path.zig

@@ -894,9 +894,10 @@ pub fn resolve(allocator: Allocator, paths: []const []const u8) Allocator.Error!
 pub fn resolveWindows(allocator: Allocator, paths: []const []const u8) Allocator.Error![]u8 {
     // Avoid heap allocation when paths.len is <= @bitSizeOf(usize) * 2
     // (we use `* 3` because stackFallback uses 1 usize as a length)
-    var bit_set_allocator_state = std.heap.stackFallback(@sizeOf(usize) * 3, allocator);
-    const bit_set_allocator = bit_set_allocator_state.get();
-    var relevant_paths = try std.bit_set.DynamicBitSetUnmanaged.initEmpty(bit_set_allocator, paths.len);
+    var buf: [3]usize = undefined;
+    var bit_set_allocator_state: std.heap.BufferFirstAllocator = .init(@ptrCast(&buf), allocator);
+    const bit_set_allocator = bit_set_allocator_state.allocator();
+    var relevant_paths: std.bit_set.Dynamic = try .initEmpty(bit_set_allocator, paths.len);
     defer relevant_paths.deinit(bit_set_allocator);
 
     // Iterate the paths backwards, marking the relevant paths along the way.
@@ -1642,7 +1643,8 @@ fn windowsResolveAgainstCwd(
     parsed: WindowsPath2(u8),
 ) ![]u8 {
     // Space for 256 WTF-16 code units; potentially 3 WTF-8 bytes per WTF-16 code unit
-    var temp_allocator_state = std.heap.stackFallback(256 * 3, gpa);
+    var buf: [256 * 3]u8 = undefined;
+    var temp_allocator_state: std.heap.BufferFirstAllocator = .init(&buf, gpa);
     return switch (parsed.kind) {
         .drive_absolute,
         .unc_absolute,
@@ -1668,7 +1670,7 @@ fn windowsResolveAgainstCwd(
             }
         },
         .drive_relative => blk: {
-            const temp_allocator = temp_allocator_state.get();
+            const temp_allocator = temp_allocator_state.allocator();
             const drive_cwd = drive_cwd: {
                 const parsed_cwd = parsePathWindows(u8, cwd);
 

package/std/hash/Adler32.zig

@@ -88,15 +88,15 @@ test "sanity" {
 }
 
 test "long" {
-    const long1 = [_]u8{1} ** 1024;
+    const long1: [1024]u8 = @splat(1);
     try testing.expectEqual(@as(u32, 0x06780401), hash(long1[0..]));
 
-    const long2 = [_]u8{1} ** 1025;
+    const long2: [1025]u8 = @splat(1);
     try testing.expectEqual(@as(u32, 0x0a7a0402), hash(long2[0..]));
 }
 
 test "very long" {
-    const long = [_]u8{1} ** 5553;
+    const long: [5553]u8 = @splat(1);
     try testing.expectEqual(@as(u32, 0x707f15b2), hash(long[0..]));
 }
 

package/std/hash/benchmark.zig

@@ -93,13 +93,13 @@ const hashes = [_]Hash{
         .ty = hash.SipHash64(1, 3),
         .name = "siphash64",
         .has_crypto_api = true,
-        .init_u8s = &[_]u8{0} ** 16,
+        .init_u8s = &@as([16]u8, @splat(0)),
     },
     Hash{
         .ty = hash.SipHash128(1, 3),
         .name = "siphash128",
         .has_crypto_api = true,
-        .init_u8s = &[_]u8{0} ** 16,
+        .init_u8s = &@as([16]u8, @splat(0)),
     },
 };
 

package/std/hash/wyhash.zig

@@ -130,7 +130,7 @@ pub const Wyhash = struct {
 
     inline fn read(comptime bytes: usize, data: []const u8) u64 {
         std.debug.assert(bytes <= 8);
-        const T = std.meta.Int(.unsigned, 8 * bytes);
+        const T = @Int(.unsigned, 8 * bytes);
         return @as(u64, std.mem.readInt(T, data[0..bytes], .little));
     }
 
@@ -253,7 +253,7 @@ test "iterative api" {
 }
 
 test "iterative maintains last sixteen" {
-    const input = "Z" ** 48 ++ "01234567890abcdefg";
+    const input = &@as([48]u8, @splat('Z')) ++ "01234567890abcdefg";
     const seed = 0;
 
     for (0..17) |i| {

package/std/hash/xxhash.zig

@@ -780,8 +780,6 @@ fn testExpect(comptime H: type, seed: anytype, input: []const u8, expected: u64)
 }
 
 test "xxhash3" {
-    if (builtin.cpu.arch.isMIPS64()) return error.SkipZigTest; // https://github.com/ziglang/zig/issues/23807
-
     const H = XxHash3;
     // Non-Seeded Tests
     try testExpect(H, 0, "", 0x2d06800538d394c2);
@@ -813,8 +811,6 @@ test "xxhash3" {
 }
 
 test "xxhash3 smhasher" {
-    if (builtin.cpu.arch.isMIPS64()) return error.SkipZigTest; // https://github.com/ziglang/zig/issues/23807
-
     const Test = struct {
         fn do() !void {
             try expectEqual(verify.smhasher(XxHash3.hash), 0x9a636405);
@@ -826,8 +822,6 @@ test "xxhash3 smhasher" {
 }
 
 test "xxhash3 iterative api" {
-    if (builtin.cpu.arch.isMIPS64()) return error.SkipZigTest; // https://github.com/ziglang/zig/issues/23807
-
     const Test = struct {
         fn do() !void {
             try verify.iterativeApi(XxHash3);

package/std/hash_map.zig

@@ -502,7 +502,8 @@ pub fn HashMap(
 /// Deletions are achieved with tombstones.
 ///
 /// Default initialization of this struct is deprecated; use `.empty` instead.
-pub fn HashMapUnmanaged(
+pub const HashMapUnmanaged = Custom;
+fn Custom(
     comptime K: type,
     comptime V: type,
     comptime Context: type,
@@ -1271,7 +1272,7 @@ pub fn HashMapUnmanaged(
             // map, which is assumed to exist as key_ptr must be valid.  This
             // item must be at index 0.
             const idx = if (@sizeOf(K) > 0)
-                (key_ptr - self.keys())
+                @as([*]K, @ptrCast(key_ptr)) - self.keys()
             else
                 0;
 
@@ -2175,3 +2176,22 @@ test "rehash" {
         }
     }
 }
+
+test "removeByPtr, key is array" {
+    const gpa = testing.allocator;
+
+    var map: AutoHashMapUnmanaged([2]u32, u32) = .empty;
+    defer map.deinit(gpa);
+
+    const key: [2]u32 = .{ 1, 2 };
+    try map.put(gpa, key, 3);
+
+    try expectEqual(1, map.count());
+    try expectEqual(3, map.get(key));
+
+    const key_ptr = map.getKeyPtr(key).?;
+    map.removeByPtr(key_ptr);
+
+    try expectEqual(0, map.count());
+    try expectEqual(null, map.get(key));
+}

package/std/heap/ArenaAllocator.zig

@@ -671,12 +671,10 @@ test "reset while retaining a buffer" {
 
     // Create two internal buffers
     _ = try a.alloc(u8, 1);
-    _ = try a.alloc(u8, 1000);
-
     try std.testing.expect(arena_allocator.state.used_list != null);
-
-    // Check that we have at least two buffers
-    try std.testing.expect(arena_allocator.state.used_list.?.next != null);
+    while (arena_allocator.state.used_list.?.next == null) {
+        _ = try a.alloc(u8, 1000);
+    }
 
     // This retains the first allocated buffer
     try std.testing.expect(arena_allocator.reset(.{ .retain_with_limit = 2 }));

package/std/heap/BufferFirstAllocator.zig

@@ -0,0 +1,165 @@
+//! An allocator that attempts to allocate from the given buffer, falling back to
+//! `fallback_allocator` if this fails.
+
+const std = @import("../std.zig");
+const heap = std.heap;
+const testing = std.testing;
+
+const Alignment = std.mem.Alignment;
+const Allocator = std.mem.Allocator;
+const FixedBufferAllocator = std.heap.FixedBufferAllocator;
+
+const BufferFirstAllocator = @This();
+
+fallback_allocator: Allocator,
+fixed_buffer_allocator: FixedBufferAllocator,
+
+pub fn init(buffer: []u8, fallback_allocator: Allocator) BufferFirstAllocator {
+    return .{
+        .fallback_allocator = fallback_allocator,
+        .fixed_buffer_allocator = .init(buffer),
+    };
+}
+
+pub fn allocator(self: *BufferFirstAllocator) Allocator {
+    return .{
+        .ptr = self,
+        .vtable = &.{
+            .alloc = alloc,
+            .resize = resize,
+            .remap = remap,
+            .free = free,
+        },
+    };
+}
+
+fn alloc(
+    ctx: *anyopaque,
+    len: usize,
+    alignment: Alignment,
+    ra: usize,
+) ?[*]u8 {
+    const self: *BufferFirstAllocator = @ptrCast(@alignCast(ctx));
+    return FixedBufferAllocator.alloc(&self.fixed_buffer_allocator, len, alignment, ra) orelse
+        return self.fallback_allocator.rawAlloc(len, alignment, ra);
+}
+
+fn resize(
+    ctx: *anyopaque,
+    buf: []u8,
+    alignment: Alignment,
+    new_len: usize,
+    ra: usize,
+) bool {
+    const self: *BufferFirstAllocator = @ptrCast(@alignCast(ctx));
+    if (self.fixed_buffer_allocator.ownsPtr(buf.ptr)) {
+        return FixedBufferAllocator.resize(&self.fixed_buffer_allocator, buf, alignment, new_len, ra);
+    } else {
+        return self.fallback_allocator.rawResize(buf, alignment, new_len, ra);
+    }
+}
+
+fn remap(
+    context: *anyopaque,
+    memory: []u8,
+    alignment: Alignment,
+    new_len: usize,
+    return_address: usize,
+) ?[*]u8 {
+    const self: *BufferFirstAllocator = @ptrCast(@alignCast(context));
+    if (self.fixed_buffer_allocator.ownsPtr(memory.ptr)) {
+        return FixedBufferAllocator.remap(&self.fixed_buffer_allocator, memory, alignment, new_len, return_address);
+    } else {
+        return self.fallback_allocator.rawRemap(memory, alignment, new_len, return_address);
+    }
+}
+
+fn free(
+    ctx: *anyopaque,
+    buf: []u8,
+    alignment: Alignment,
+    ra: usize,
+) void {
+    const self: *BufferFirstAllocator = @ptrCast(@alignCast(ctx));
+    if (self.fixed_buffer_allocator.ownsPtr(buf.ptr)) {
+        return FixedBufferAllocator.free(&self.fixed_buffer_allocator, buf, alignment, ra);
+    } else {
+        return self.fallback_allocator.rawFree(buf, alignment, ra);
+    }
+}
+
+test "BufferFirstAllocator" {
+    // Buffer first specific tests
+    {
+        var buffer: [10]u8 = undefined;
+        var bfa_state: BufferFirstAllocator = .init(&buffer, std.testing.allocator);
+        const bfa = bfa_state.allocator();
+
+        // We're under the limit, so we should be allocated in the buffer
+        const txt0 = "hellowrld";
+        const buf0 = try bfa.create(@TypeOf(txt0.*));
+        buf0.* = txt0.*;
+        try testing.expect(bfa_state.fixed_buffer_allocator.ownsPtr(buf0.ptr));
+
+        // We're now over the limit, so we should be allocated from the fallback
+        const txt1 = "test!";
+        const buf1 = try bfa.create(@TypeOf(txt1.*));
+        buf1.* = txt1.*;
+        try testing.expect(!bfa_state.fixed_buffer_allocator.ownsPtr(buf1.ptr));
+
+        // Free the allocation that took up space in the buffer
+        try testing.expectEqualStrings(txt0, buf0);
+        bfa.destroy(buf0);
+
+        // The next allocation would go in the buffer, but it's too big so it doesn't
+        const txt2 = "qwertyqwerty";
+        const buf2 = try bfa.create(@TypeOf(txt2.*));
+        buf2.* = txt2.*;
+        try testing.expect(!bfa_state.fixed_buffer_allocator.ownsPtr(buf2.ptr));
+
+        // The next allocation is smaller and fits in the buffer
+        const txt3 = "dvorak";
+        const buf3 = try bfa.create(@TypeOf(txt3.*));
+        buf3.* = txt3.*;
+        try testing.expect(bfa_state.fixed_buffer_allocator.ownsPtr(buf3.ptr));
+
+        // The remainder in the buffer is too small for the following allocation so it falls back
+        const txt4 = "moretext";
+        const buf4 = try bfa.create(@TypeOf(txt4.*));
+        buf4.* = txt4.*;
+        try testing.expect(!bfa_state.fixed_buffer_allocator.ownsPtr(buf4.ptr));
+
+        // Check equality on the remaining buffers and free them
+        try testing.expectEqualStrings(txt1, buf1);
+        bfa.destroy(buf1);
+        try testing.expectEqualStrings(txt2, buf2);
+        bfa.destroy(buf2);
+        try testing.expectEqualStrings(txt3, buf3);
+        bfa.destroy(buf3);
+        try testing.expectEqualStrings(txt4, buf4);
+        bfa.destroy(buf4);
+
+        try testing.expectEqual(0, bfa_state.fixed_buffer_allocator.end_index);
+    }
+
+    // Standard allocator tests
+    {
+        var buf: [4096]u8 = undefined;
+        {
+            var bfa: BufferFirstAllocator = .init(&buf, std.testing.allocator);
+            try heap.testAllocator(bfa.allocator());
+        }
+        {
+            var bfa: BufferFirstAllocator = .init(&buf, std.testing.allocator);
+            try heap.testAllocatorAligned(bfa.allocator());
+        }
+        {
+            var bfa: BufferFirstAllocator = .init(&buf, std.testing.allocator);
+            try heap.testAllocatorLargeAlignment(bfa.allocator());
+        }
+        {
+            var bfa: BufferFirstAllocator = .init(&buf, std.testing.allocator);
+            try heap.testAllocatorAlignedShrink(bfa.allocator());
+        }
+    }
+}