@zigc/lib 0.17.0-dev.256 → 0.17.0-dev.269

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zigc/lib",
-  "version": "0.17.0-dev.256",
+  "version": "0.17.0-dev.269",
   "description": "Zig standard library and libc headers (shared across all platforms)",
   "repository": {
     "type": "git",

package/std/Build/Cache/Path.zig

@@ -59,7 +59,7 @@ pub fn joinStringZ(p: Path, gpa: Allocator, sub_path: []const u8) Allocator.Erro
     return p.root_dir.joinZ(gpa, parts);
 }
 
-pub fn openFile(p: Path, io: Io, sub_path: []const u8, flags: Io.File.OpenFlags) !Io.File {
+pub fn openFile(p: Path, io: Io, sub_path: []const u8, flags: Io.Dir.OpenFileOptions) !Io.File {
     var buf: [fs.max_path_bytes]u8 = undefined;
     const joined_path = if (p.sub_path.len == 0) sub_path else p: {
         break :p std.fmt.bufPrint(&buf, "{s}" ++ fs.path.sep_str ++ "{s}", .{

package/std/Io/Dispatch.zig

@@ -2468,7 +2468,7 @@ fn dirCreateFile(
     userdata: ?*anyopaque,
     dir: Dir,
     sub_path: []const u8,
-    flags: File.CreateFlags,
+    flags: Dir.CreateFileOptions,
 ) File.OpenError!File {
     const ev: *Evented = @ptrCast(@alignCast(userdata));
     _ = ev;
@@ -2601,7 +2601,7 @@ fn dirOpenFile(
     userdata: ?*anyopaque,
     dir: Dir,
     sub_path: []const u8,
-    flags: File.OpenFlags,
+    flags: Dir.OpenFileOptions,
 ) File.OpenError!File {
     const ev: *Evented = @ptrCast(@alignCast(userdata));
 
@@ -3936,7 +3936,7 @@ fn fileMemoryMapWrite(userdata: ?*anyopaque, mm: *File.MemoryMap) File.WritePosi
 
 fn processExecutableOpen(
     userdata: ?*anyopaque,
-    flags: File.OpenFlags,
+    flags: Dir.OpenFileOptions,
 ) process.OpenExecutableError!File {
     const ev: *Evented = @ptrCast(@alignCast(userdata));
     // _NSGetExecutablePath() returns a path that might be a symlink to

package/std/Io/File.zig

@@ -142,21 +142,12 @@ pub fn stat(file: File, io: Io) StatError!Stat {
     return io.vtable.fileStat(io.userdata, file);
 }
 
-/// Deprecated, renamed to `Dir.OpenFileOptions.Mode`.
-pub const OpenMode = Dir.OpenFileOptions.Mode;
-
 pub const Lock = enum {
     none,
     shared,
     exclusive,
 };
 
-/// Deprecated, renamed to `Dir.OpenFileOptions`
-pub const OpenFlags = Dir.OpenFileOptions;
-
-/// Deprecated, renamed to `Dir.CreateFileOptions`.
-pub const CreateFlags = Dir.CreateFileOptions;
-
 pub const OpenError = error{
     PipeBusy,
     NoDevice,

package/std/Io/Kqueue.zig

@@ -877,7 +877,7 @@ fn dirAccess(userdata: ?*anyopaque, dir: Dir, sub_path: []const u8, options: Dir
     _ = options;
     @panic("TODO");
 }
-fn dirCreateFile(userdata: ?*anyopaque, dir: Dir, sub_path: []const u8, flags: File.CreateFlags) File.OpenError!File {
+fn dirCreateFile(userdata: ?*anyopaque, dir: Dir, sub_path: []const u8, flags: Dir.CreateFileOptions) File.OpenError!File {
     const k: *Kqueue = @ptrCast(@alignCast(userdata));
     _ = k;
     _ = dir;
@@ -885,7 +885,7 @@ fn dirCreateFile(userdata: ?*anyopaque, dir: Dir, sub_path: []const u8, flags: F
     _ = flags;
     @panic("TODO");
 }
-fn dirOpenFile(userdata: ?*anyopaque, dir: Dir, sub_path: []const u8, flags: File.OpenFlags) File.OpenError!File {
+fn dirOpenFile(userdata: ?*anyopaque, dir: Dir, sub_path: []const u8, flags: Dir.OpenFileOptions) File.OpenError!File {
     const k: *Kqueue = @ptrCast(@alignCast(userdata));
     _ = k;
     _ = dir;

package/std/Io/Uring.zig

@@ -2812,7 +2812,7 @@ fn dirCreateFile(
     userdata: ?*anyopaque,
     dir: Dir,
     sub_path: []const u8,
-    flags: File.CreateFlags,
+    flags: Dir.CreateFileOptions,
 ) File.OpenError!File {
     const ev: *Evented = @ptrCast(@alignCast(userdata));
 
@@ -2996,7 +2996,7 @@ fn dirOpenFile(
     userdata: ?*anyopaque,
     dir: Dir,
     sub_path: []const u8,
-    flags: File.OpenFlags,
+    flags: Dir.OpenFileOptions,
 ) File.OpenError!File {
     const ev: *Evented = @ptrCast(@alignCast(userdata));
 
@@ -4104,7 +4104,7 @@ fn fileMemoryMapWrite(userdata: ?*anyopaque, mm: *File.MemoryMap) File.WritePosi
 
 fn processExecutableOpen(
     userdata: ?*anyopaque,
-    flags: File.OpenFlags,
+    flags: Dir.OpenFileOptions,
 ) process.OpenExecutableError!File {
     const ev: *Evented = @ptrCast(@alignCast(userdata));
     return dirOpenFile(ev, .{ .handle = linux.AT.FDCWD }, "/proc/self/exe", flags);

package/std/Io.zig

@@ -54,9 +54,6 @@ pub const VTable = struct {
     /// If it returns `null` it means `result` has been already populated and
     /// `await` will be a no-op.
     ///
-    /// When this function returns non-null, the implementation guarantees that
-    /// a unit of concurrency has been assigned to the returned task.
-    ///
     /// Thread-safe.
     async: *const fn (
         /// Corresponds to `Io.userdata`.
@@ -111,10 +108,6 @@ pub const VTable = struct {
         result_alignment: std.mem.Alignment,
     ) void,
 
-    /// When this function returns, implementation guarantees that `start` has
-    /// either already been called, or a unit of concurrency has been assigned
-    /// to the task of calling the function.
-    ///
     /// Thread-safe.
     groupAsync: *const fn (
         /// Corresponds to `Io.userdata`.
@@ -1251,8 +1244,11 @@ pub const Group = struct {
     /// cancelation propagation boundary.
     ///
     /// Once this function is called, there are resources associated with the
-    /// group. To release those resources, `Group.await` or `Group.cancel` must
-    /// eventually be called.
+    /// group. To release those resources, `await` or `cancel` must eventually
+    /// be called.
+    ///
+    /// `function` is not guaranteed to have been called until `await` or
+    /// `cancel` is called.
     pub fn async(g: *Group, io: Io, function: anytype, args: std.meta.ArgsTuple(@TypeOf(function))) void {
         const Args = @TypeOf(args);
         const TypeErased = struct {
@@ -1290,6 +1286,9 @@ pub const Group = struct {
     /// will also cause `error.Canceled` to be returned when the group
     /// does ultimately finish.
     ///
+    /// After this function returns, all tasks of the `Group` created with
+    /// `async` or `concurrent` are guaranteed to have run.
+    ///
     /// Idempotent. Not threadsafe.
     ///
     /// It is safe to call this function concurrently with `Group.async` or
@@ -1304,6 +1303,9 @@ pub const Group = struct {
     /// Equivalent to `await` but immediately requests cancelation on all
     /// members of the group.
     ///
+    /// After this function returns, all tasks of the `Group` created with
+    /// `async` or `concurrent` are guaranteed to have run.
+    ///
     /// For a description of cancelation and cancelation points, see `Future.cancel`.
     ///
     /// Idempotent. Not threadsafe.
@@ -2922,7 +2924,7 @@ pub fn failingDirAccess(userdata: ?*anyopaque, dir: Dir, sub_path: []const u8, o
     return error.FileNotFound;
 }
 
-pub fn failingDirCreateFile(userdata: ?*anyopaque, dir: Dir, sub_path: []const u8, options: File.CreateFlags) File.OpenError!File {
+pub fn failingDirCreateFile(userdata: ?*anyopaque, dir: Dir, sub_path: []const u8, options: Dir.CreateFileOptions) File.OpenError!File {
     _ = userdata;
     _ = dir;
     _ = sub_path;
@@ -2938,7 +2940,7 @@ pub fn failingDirCreateFileAtomic(userdata: ?*anyopaque, dir: Dir, sub_path: []c
     return error.NoSpaceLeft;
 }
 
-pub fn failingDirOpenFile(userdata: ?*anyopaque, dir: Dir, sub_path: []const u8, flags: File.OpenFlags) File.OpenError!File {
+pub fn failingDirOpenFile(userdata: ?*anyopaque, dir: Dir, sub_path: []const u8, flags: Dir.OpenFileOptions) File.OpenError!File {
     _ = userdata;
     _ = dir;
     _ = sub_path;
@@ -3275,7 +3277,7 @@ pub fn unreachableFileMemoryMapWrite(userdata: ?*anyopaque, mm: *File.MemoryMap)
     unreachable;
 }
 
-pub fn failingProcessExecutableOpen(userdata: ?*anyopaque, flags: File.OpenFlags) std.process.OpenExecutableError!File {
+pub fn failingProcessExecutableOpen(userdata: ?*anyopaque, flags: Dir.OpenFileOptions) std.process.OpenExecutableError!File {
     _ = userdata;
     _ = flags;
     return error.FileNotFound;

package/std/Thread.zig

@@ -695,6 +695,9 @@ const PosixThreadImpl = struct {
             .linux => {
                 return LinuxThreadImpl.getCpuCount();
             },
+            .emscripten => {
+                return @as(usize, @intCast(std.os.emscripten.emscripten_num_logical_cores()));
+            },
             .openbsd => {
                 var count: c_int = undefined;
                 var count_size: usize = @sizeOf(c_int);

package/std/array_hash_map.zig

@@ -887,17 +887,25 @@ pub fn Custom(
         }
 
         /// Modify an entry's key without reordering any entries.
-        pub fn setKey(self: *Self, gpa: Allocator, index: usize, new_key: K) Oom!void {
+        pub fn setKey(self: *Self, index: usize, new_key: K) void {
             if (@sizeOf(ByIndexContext) != 0)
                 @compileError("Cannot infer context " ++ @typeName(Context) ++ ", call setKeyContext instead.");
-            return setKeyContext(self, gpa, index, new_key, undefined);
+            return setKeyContext(self, index, new_key, undefined);
         }
 
-        pub fn setKeyContext(self: *Self, gpa: Allocator, index: usize, new_key: K, ctx: Context) Oom!void {
-            const key_ptr = &self.entries.items(.key)[index];
-            key_ptr.* = new_key;
-            if (store_hash) self.entries.items(.hash)[index] = checkedHash(ctx, key_ptr.*);
-            try rebuildIndex(self, gpa, undefined);
+        pub fn setKeyContext(self: *Self, index: usize, new_key: K, ctx: Context) void {
+            if (self.index_header) |header| {
+                self.removeFromIndexByIndex(index, if (store_hash) {} else ctx, header);
+
+                self.entries.items(.key)[index] = new_key;
+                const h = checkedHash(ctx, new_key);
+                if (store_hash) self.entries.items(.hash)[index] = h;
+
+                insertEntryIntoNewHeader(header, h, index);
+            } else {
+                self.entries.items(.key)[index] = new_key;
+                if (store_hash) self.entries.items(.hash)[index] = checkedHash(ctx, new_key);
+            }
         }
 
         fn rebuildIndex(self: *Self, gpa: Allocator, ctx: Context) Oom!void {
@@ -1420,39 +1428,50 @@ pub fn Custom(
         fn insertAllEntriesIntoNewHeaderGeneric(self: *Self, ctx: ByIndexContext, header: *IndexHeader, comptime I: type) void {
             const slice = self.entries.slice();
             const items = if (store_hash) slice.items(.hash) else slice.items(.key);
-            const indexes = header.indexes(I);
 
-            entry_loop: for (items, 0..) |key, i| {
-                const h = if (store_hash) key else checkedHash(ctx, key);
-                const start_index = safeTruncate(usize, h);
-                const end_index = start_index +% indexes.len;
-                var index = start_index;
-                var entry_index = @as(I, @intCast(i));
-                var distance_from_start_index: I = 0;
-                while (index != end_index) : ({
-                    index +%= 1;
-                    distance_from_start_index += 1;
-                }) {
-                    const slot = header.constrainIndex(index);
-                    const next_index = indexes[slot];
-                    if (next_index.isEmpty()) {
-                        indexes[slot] = .{
-                            .distance_from_start_index = distance_from_start_index,
-                            .entry_index = entry_index,
-                        };
-                        continue :entry_loop;
-                    }
-                    if (next_index.distance_from_start_index < distance_from_start_index) {
-                        indexes[slot] = .{
-                            .distance_from_start_index = distance_from_start_index,
-                            .entry_index = entry_index,
-                        };
-                        distance_from_start_index = next_index.distance_from_start_index;
-                        entry_index = next_index.entry_index;
-                    }
+            for (items, 0..) |hash_or_key, i| {
+                const h = if (store_hash) hash_or_key else checkedHash(ctx, hash_or_key);
+                insertEntryIntoNewHeaderGeneric(header, h, i, I);
+            }
+        }
+
+        fn insertEntryIntoNewHeader(header: *IndexHeader, h: u32, i: usize) void {
+            switch (header.capacityIndexType()) {
+                .u8 => insertEntryIntoNewHeaderGeneric(header, h, i, u8),
+                .u16 => insertEntryIntoNewHeaderGeneric(header, h, i, u16),
+                .u32 => insertEntryIntoNewHeaderGeneric(header, h, i, u32),
+            }
+        }
+        fn insertEntryIntoNewHeaderGeneric(header: *IndexHeader, h: u32, i: usize, comptime I: type) void {
+            const indexes = header.indexes(I);
+            const start_index = safeTruncate(usize, h);
+            const end_index = start_index +% indexes.len;
+            var index = start_index;
+            var entry_index: I = @intCast(i);
+            var distance_from_start_index: I = 0;
+            while (index != end_index) : ({
+                index +%= 1;
+                distance_from_start_index += 1;
+            }) {
+                const slot = header.constrainIndex(index);
+                const next_index = indexes[slot];
+                if (next_index.isEmpty()) {
+                    indexes[slot] = .{
+                        .distance_from_start_index = distance_from_start_index,
+                        .entry_index = entry_index,
+                    };
+                    return;
+                }
+                if (next_index.distance_from_start_index < distance_from_start_index) {
+                    indexes[slot] = .{
+                        .distance_from_start_index = distance_from_start_index,
+                        .entry_index = entry_index,
+                    };
+                    distance_from_start_index = next_index.distance_from_start_index;
+                    entry_index = next_index.entry_index;
                 }
-                unreachable;
             }
+            unreachable;
         }
 
         fn checkedHash(ctx: anytype, key: anytype) u32 {
@@ -2118,7 +2137,7 @@ test "setKey storehash true" {
     try map.put(gpa, 12, 34);
     try map.put(gpa, 56, 78);
 
-    try map.setKey(gpa, 0, 42);
+    map.setKey(0, 42);
     try testing.expectEqual(2, map.count());
     try testing.expectEqual(false, map.contains(12));
     try testing.expectEqual(34, map.get(42));
@@ -2134,13 +2153,49 @@ test "setKey storehash false" {
     try map.put(gpa, 12, 34);
     try map.put(gpa, 56, 78);
 
-    try map.setKey(gpa, 0, 42);
+    map.setKey(0, 42);
     try testing.expectEqual(2, map.count());
     try testing.expectEqual(false, map.contains(12));
     try testing.expectEqual(34, map.get(42));
     try testing.expectEqual(78, map.get(56));
 }
 
+test "setKey storehash false with index" {
+    const gpa = std.testing.allocator;
+
+    const T = ArrayHashMap(usize, usize, AutoContext(usize), false);
+
+    var map: T = .empty;
+    defer map.deinit(gpa);
+
+    for (0..T.linear_scan_max + 1) |i| try map.put(gpa, i, i);
+
+    map.setKey(0, 42);
+    try testing.expectEqual(T.linear_scan_max + 1, map.count());
+    try testing.expectEqual(false, map.contains(0));
+    try testing.expectEqual(0, map.get(42));
+
+    for (1..T.linear_scan_max + 1) |i| try testing.expectEqual(i, map.get(i));
+}
+
+test "setKey storehash true with index" {
+    const gpa = std.testing.allocator;
+
+    const T = ArrayHashMap(usize, usize, AutoContext(usize), false);
+
+    var map: ArrayHashMap(usize, usize, AutoContext(usize), true) = .empty;
+    defer map.deinit(gpa);
+
+    for (0..T.linear_scan_max + 1) |i| try map.put(gpa, i, i);
+
+    map.setKey(0, 42);
+    try testing.expectEqual(T.linear_scan_max + 1, map.count());
+    try testing.expectEqual(false, map.contains(0));
+    try testing.expectEqual(0, map.get(42));
+
+    for (1..T.linear_scan_max + 1) |i| try testing.expectEqual(i, map.get(i));
+}
+
 pub fn getHashPtrAddrFn(comptime K: type, comptime Context: type) (fn (Context, K) u32) {
     return struct {
         fn hash(ctx: Context, key: K) u32 {

package/std/c.zig

@@ -11619,6 +11619,7 @@ const private = struct {
     extern "c" fn @"fstatat$INODE64"(dirfd: fd_t, path: [*:0]const u8, buf: *Stat, flag: u32) c_int;
     extern "c" fn @"readdir$INODE64"(dir: *DIR) ?*dirent;
     extern "c" fn @"stat$INODE64"(noalias path: [*:0]const u8, noalias buf: *Stat) c_int;
+    extern "c" fn stat(noalias path: [*:0]const u8, noalias buf: *Stat) c_int;
 
     /// macos modernized symbols.
     extern "c" fn @"realpath$DARWIN_EXTSN"(noalias file_name: [*:0]const u8, noalias resolved_name: [*]u8) ?[*:0]u8;

package/std/os/emscripten.zig

@@ -882,6 +882,7 @@ pub extern "c" fn emscripten_hide_mouse() void;
 pub extern "c" fn emscripten_set_canvas_size(width: c_int, height: c_int) void;
 pub extern "c" fn emscripten_get_canvas_size(width: *c_int, height: *c_int, isFullscreen: *c_int) void;
 pub extern "c" fn emscripten_get_now() f64;
+pub extern "c" fn emscripten_num_logical_cores() c_int;
 pub extern "c" fn emscripten_random() f32;
 pub const em_idb_onload_func = ?*const fn (?*anyopaque, ?*anyopaque, c_int) callconv(.c) void;
 pub extern "c" fn emscripten_idb_async_load(db_name: [*:0]const u8, file_id: [*:0]const u8, arg: ?*anyopaque, onload: em_idb_onload_func, onerror: em_arg_callback_func) void;

package/std/process.zig

@@ -3,6 +3,7 @@ const native_os = builtin.os.tag;
 
 const std = @import("std.zig");
 const Io = std.Io;
+const Dir = std.Io.Dir;
 const File = std.Io.File;
 const fs = std.fs;
 const mem = std.mem;
@@ -784,7 +785,7 @@ pub fn executableDirPathAlloc(io: Io, allocator: Allocator) ExecutablePathAllocE
 
 pub const OpenExecutableError = File.OpenError || ExecutablePathError || File.LockError;
 
-pub fn openExecutable(io: Io, flags: File.OpenFlags) OpenExecutableError!File {
+pub fn openExecutable(io: Io, flags: Dir.OpenFileOptions) OpenExecutableError!File {
     return io.vtable.processExecutableOpen(io.userdata, flags);
 }
 

package/std/zig/LibCInstallation.zig

@@ -5,6 +5,7 @@ const builtin = @import("builtin");
 const is_darwin = builtin.target.os.tag.isDarwin();
 const is_windows = builtin.target.os.tag == .windows;
 const is_haiku = builtin.target.os.tag == .haiku;
+const is_serenity = builtin.target.os.tag == .serenity;
 
 const std = @import("std");
 const Io = std.Io;
@@ -112,7 +113,7 @@ pub fn parse(allocator: Allocator, io: Io, libc_file: []const u8, target: *const
         return error.ParseError;
     }
 
-    if (self.gcc_dir == null and os_tag == .haiku) {
+    if (self.gcc_dir == null and (os_tag == .haiku or os_tag == .serenity)) {
         log.err("gcc_dir may not be empty for {s}", .{@tagName(os_tag)});
         return error.ParseError;
     }
@@ -207,8 +208,12 @@ pub fn findNative(gpa: Allocator, io: Io, args: FindNativeOptions) FindError!Lib
         try self.findNativeCrtDirWindows(gpa, io, args.target, sdk);
     } else if (is_haiku) {
         try self.findNativeIncludeDirPosix(gpa, io, args);
-        try self.findNativeGccDirHaiku(gpa, io, args);
+        try self.findNativeGccDirPosix(gpa, io, args);
         self.crt_dir = try gpa.dupe(u8, "/system/develop/lib");
+    } else if (is_serenity) {
+        try self.findNativeIncludeDirPosix(gpa, io, args);
+        try self.findNativeGccDirPosix(gpa, io, args);
+        self.crt_dir = try gpa.dupe(u8, "/usr/lib");
     } else if (builtin.target.os.tag == .illumos) {
         // There is only one libc, and its headers/libraries are always in the same spot.
         self.include_dir = try gpa.dupe(u8, "/usr/include");
@@ -314,7 +319,7 @@ fn findNativeIncludeDirPosix(self: *LibCInstallation, gpa: Allocator, io: Io, ar
     const include_dir_example_file = if (is_haiku) "posix/stdlib.h" else "stdlib.h";
     const sys_include_dir_example_file = if (is_windows)
         "sys\\types.h"
-    else if (is_haiku)
+    else if (is_haiku or is_serenity)
         "errno.h"
     else
         "sys/errno.h";
@@ -457,7 +462,7 @@ fn findNativeCrtDirPosix(self: *LibCInstallation, gpa: Allocator, io: Io, args:
     });
 }
 
-fn findNativeGccDirHaiku(self: *LibCInstallation, gpa: Allocator, io: Io, args: FindNativeOptions) FindError!void {
+fn findNativeGccDirPosix(self: *LibCInstallation, gpa: Allocator, io: Io, args: FindNativeOptions) FindError!void {
     self.gcc_dir = try ccPrintFileName(gpa, io, .{
         .environ_map = args.environ_map,
         .search_basename = "crtbeginS.o",
@@ -949,6 +954,22 @@ pub const CrtBasenames = struct {
                 },
                 .static_exe, .static_pie => .{},
             },
+            .serenity => switch (mode) {
+                .dynamic_lib => .{
+                    .crtbegin = "crtbeginS.o",
+                    .crtend = "crtendS.o",
+                },
+                .dynamic_exe, .static_exe => .{
+                    .crt0 = "crt0.o",
+                    .crtbegin = "crtbegin.o",
+                    .crtend = "crtend.o",
+                },
+                .dynamic_pie, .static_pie => .{
+                    .crt0 = "crt0.o",
+                    .crtbegin = "crtbeginS.o",
+                    .crtend = "crtendS.o",
+                },
+            },
             else => .{},
         };
     }
@@ -993,7 +1014,7 @@ pub fn resolveCrtPaths(
                 .crtn = if (crt_basenames.crtn) |basename| try crt_dir_path.join(arena, basename) else null,
             };
         },
-        .haiku => {
+        .haiku, .serenity => {
             const gcc_dir_path: Path = .{
                 .root_dir = std.Build.Cache.Directory.cwd(),
                 .sub_path = lci.gcc_dir orelse return error.LibCInstallationMissingCrtDir,