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

package/compiler/build_runner.zig

@@ -1397,7 +1397,7 @@ fn makeStep(
             defer run.max_rss_mutex.unlock(io);
             run.available_rss += s.max_rss;
             dispatch_set.ensureUnusedCapacity(gpa, run.memory_blocked_steps.items.len) catch @panic("OOM");
-            while (run.memory_blocked_steps.getLastOrNull()) |candidate| {
+            while (run.memory_blocked_steps.getLast()) |candidate| {
                 if (run.available_rss < candidate.max_rss) break;
                 assert(run.memory_blocked_steps.pop() == candidate);
                 dispatch_set.appendAssumeCapacity(candidate);

package/compiler/translate-c/MacroTranslator.zig

@@ -361,7 +361,7 @@ fn parseCNumLit(mt: *MacroTranslator) ParseError!ZigNode {
                 return error.ParseError;
             },
         });
-        if (bytes.getLast() == '.') {
+        if (bytes.getLast().? == '.') {
             bytes.appendAssumeCapacity('0');
         } else if (mem.findAny(u8, bytes.items, ".eEpP") == null) {
             bytes.appendSliceAssumeCapacity(".0");

package/docs/wasm/markdown/Parser.zig

@@ -209,7 +209,7 @@ pub fn feedLine(p: *Parser, line: []const u8) Allocator.Error!void {
     } else p.pending_blocks.items.len;
 
     const in_code_block = p.pending_blocks.items.len > 0 and
-        p.pending_blocks.getLast().tag == .code_block;
+        p.pending_blocks.getLast().?.tag == .code_block;
     const code_block_end = in_code_block and
         first_unmatched + 1 == p.pending_blocks.items.len;
     // New blocks cannot be started if we are actively inside a code block or
@@ -225,7 +225,7 @@ pub fn feedLine(p: *Parser, line: []const u8) Allocator.Error!void {
     if (maybe_block_start == null and
         !isBlank(rest_line) and
         p.pending_blocks.items.len > 0 and
-        p.pending_blocks.getLast().tag == .paragraph)
+        p.pending_blocks.getLast().?.tag == .paragraph)
     {
         try p.addScratchStringLine(mem.trimStart(u8, rest_line, " \t"));
         return;
@@ -236,7 +236,7 @@ pub fn feedLine(p: *Parser, line: []const u8) Allocator.Error!void {
     // paragraphs.
     if (maybe_block_start != null and
         p.pending_blocks.items.len > 0 and
-        p.pending_blocks.getLast().tag == .paragraph)
+        p.pending_blocks.getLast().?.tag == .paragraph)
     {
         try p.closeLastBlock();
     }
@@ -259,7 +259,7 @@ pub fn feedLine(p: *Parser, line: []const u8) Allocator.Error!void {
     // Do not append the end of a code block (```) as textual content.
     if (code_block_end) return;
 
-    const can_accept = if (p.pending_blocks.getLastOrNull()) |last_pending_block|
+    const can_accept = if (p.pending_blocks.getLast()) |last_pending_block|
         last_pending_block.canAccept()
     else
         .blocks;
@@ -273,7 +273,7 @@ pub fn feedLine(p: *Parser, line: []const u8) Allocator.Error!void {
             // loose, since we might just be looking at a blank line after the
             // end of the last item in the list. The final determination will be
             // made when appending the next child of the list or list item.
-            const maybe_containing_list_index = if (p.pending_blocks.items.len > 0 and p.pending_blocks.getLast().tag == .list_item)
+            const maybe_containing_list_index = if (p.pending_blocks.items.len > 0 and p.pending_blocks.getLast().?.tag == .list_item)
                 p.pending_blocks.items.len - 2
             else
                 null;
@@ -368,7 +368,7 @@ const BlockStart = struct {
 };
 
 fn appendBlockStart(p: *Parser, block_start: BlockStart) !void {
-    if (p.pending_blocks.getLastOrNull()) |last_pending_block| {
+    if (p.pending_blocks.getLast()) |last_pending_block| {
         // Close the last block if it is a list and the new block is not a list item
         // or not of the same marker type.
         const should_close_list = last_pending_block.tag == .list and
@@ -383,7 +383,7 @@ fn appendBlockStart(p: *Parser, block_start: BlockStart) !void {
         }
     }
 
-    if (p.pending_blocks.getLastOrNull()) |last_pending_block| {
+    if (p.pending_blocks.getLast()) |last_pending_block| {
         // If the last block is a list or list item, check for tightness based
         // on the last line.
         const maybe_containing_list = switch (last_pending_block.tag) {
@@ -401,7 +401,7 @@ fn appendBlockStart(p: *Parser, block_start: BlockStart) !void {
     // Start a new list if the new block is a list item and there is no
     // containing list yet.
     if (block_start.tag == .list_item and
-        (p.pending_blocks.items.len == 0 or p.pending_blocks.getLast().tag != .list))
+        (p.pending_blocks.items.len == 0 or p.pending_blocks.getLast().?.tag != .list))
     {
         try p.pending_blocks.append(p.allocator, .{
             .tag = .list,
@@ -417,7 +417,7 @@ fn appendBlockStart(p: *Parser, block_start: BlockStart) !void {
 
     if (block_start.tag == .table_row) {
         // Likewise, table rows start a table implicitly.
-        if (p.pending_blocks.items.len == 0 or p.pending_blocks.getLast().tag != .table) {
+        if (p.pending_blocks.items.len == 0 or p.pending_blocks.getLast().?.tag != .table) {
             try p.pending_blocks.append(p.allocator, .{
                 .tag = .table,
                 .data = .{ .table = .{
@@ -429,7 +429,7 @@ fn appendBlockStart(p: *Parser, block_start: BlockStart) !void {
             });
         }
 
-        const current_row = p.scratch_extra.items.len - p.pending_blocks.getLast().extra_start;
+        const current_row = p.scratch_extra.items.len - p.pending_blocks.getLast().?.extra_start;
         if (current_row <= 1) {
             var buffer: [max_table_columns]Node.TableCellAlignment = undefined;
             const table_row = &block_start.data.table_row;
@@ -441,7 +441,7 @@ fn appendBlockStart(p: *Parser, block_start: BlockStart) !void {
                     // We need to go back and mark the header row and its column
                     // alignments.
                     const datas = p.nodes.items(.data);
-                    const header_data = datas[p.scratch_extra.getLast()];
+                    const header_data = datas[p.scratch_extra.getLast().?];
                     for (p.extraChildren(header_data.container.children), 0..) |header_cell, i| {
                         const alignment = if (i < alignments.len) alignments[i] else .unset;
                         const cell_data = &datas[@intFromEnum(header_cell)].table_cell;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zigc/lib",
-  "version": "0.17.0-dev.248",
+  "version": "0.17.0-dev.263",
   "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

@@ -2922,7 +2922,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 +2938,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 +3275,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/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/array_list.zig

@@ -544,16 +544,13 @@ pub fn AlignedManaged(comptime T: type, comptime alignment: ?mem.Alignment) type
             return self.allocatedSlice()[self.items.len..];
         }
 
-        /// Returns the last element from the list.
-        /// Asserts that the list is not empty.
-        pub fn getLast(self: Self) T {
-            return self.items[self.items.len - 1];
-        }
+        /// Deprecated in favor of `getLast`
+        pub const getLastOrNull = getLast;
 
-        /// Returns the last element from the list, or `null` if list is empty.
-        pub fn getLastOrNull(self: Self) ?T {
+        /// Returns the last element from the list, or `null` if the list is empty.
+        pub fn getLast(self: Self) ?T {
             if (self.items.len == 0) return null;
-            return self.getLast();
+            return self.items[self.items.len - 1];
         }
     };
 }
@@ -1394,17 +1391,10 @@ pub fn Aligned(comptime T: type, comptime alignment: ?mem.Alignment) type {
             return self.allocatedSlice()[self.items.len..];
         }
 
-        /// Return the last element from the list.
-        /// Asserts that the list is not empty.
-        pub fn getLast(self: Self) T {
-            return self.items[self.items.len - 1];
-        }
-
-        /// Return the last element from the list, or
-        /// return `null` if list is empty.
-        pub fn getLastOrNull(self: Self) ?T {
+        /// Returns the last element from the list, or `null` if the list is empty.
+        pub fn getLast(self: Self) ?T {
             if (self.items.len == 0) return null;
-            return self.getLast();
+            return self.items[self.items.len - 1];
         }
 
         /// Called when memory growth is necessary. Returns a capacity larger than
@@ -2394,22 +2384,11 @@ test "Managed(u32).getLast()" {
     var list = Managed(u32).init(a);
     defer list.deinit();
 
-    try list.append(2);
-    const const_list = list;
-    try testing.expectEqual(const_list.getLast(), 2);
-}
-
-test "Managed(u32).getLastOrNull()" {
-    const a = testing.allocator;
-
-    var list = Managed(u32).init(a);
-    defer list.deinit();
-
-    try testing.expectEqual(list.getLastOrNull(), null);
+    try testing.expectEqual(list.getLast(), null);
 
     try list.append(2);
     const const_list = list;
-    try testing.expectEqual(const_list.getLastOrNull().?, 2);
+    try testing.expectEqual(const_list.getLast().?, 2);
 }
 
 test "return OutOfMemory when capacity would exceed maximum usize integer value" {

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/deque.zig

@@ -696,7 +696,7 @@ fn fuzzAgainstArrayList(_: void, smith: *std.testing.Smith) anyerror!void {
                 try q.ensureTotalCapacityPrecise(q_gpa, q.len + growth);
             },
         }
-        try testing.expectEqual(l.getLastOrNull(), q.back());
+        try testing.expectEqual(l.getLast(), q.back());
         try testing.expectEqual(
             if (l.items.len > 0) l.items[0] else null,
             q.front(),

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/start.zig

@@ -23,6 +23,10 @@ comptime {
         const dll_main_crt_startup = if (builtin.abi.isGnu()) "DllMainCRTStartup" else "_DllMainCRTStartup";
         if (native_os == .windows and !builtin.link_libc and !@hasDecl(root, dll_main_crt_startup)) {
             @export(&DllMainCRTStartup, .{ .name = dll_main_crt_startup });
+        } else if (native_os == .windows and builtin.link_libc and @hasDecl(root, "DllMain")) {
+            if (!@typeInfo(@TypeOf(root.DllMain)).@"fn".calling_convention.eql(.winapi)) {
+                @export(&DllMain, .{ .name = "DllMain" });
+            }
         }
     } else if (builtin.output_mode == .Exe or @hasDecl(root, "main")) {
         if (builtin.link_libc and @hasDecl(root, "main")) {
@@ -82,12 +86,20 @@ fn DllMainCRTStartup(
     }
 
     if (@hasDecl(root, "DllMain")) {
-        return root.DllMain(hinstDLL, fdwReason, lpReserved);
+        return root.DllMain(@ptrCast(hinstDLL), fdwReason, lpReserved);
     }
 
     return .TRUE;
 }
 
+fn DllMain(
+    hinstDLL: std.os.windows.HINSTANCE,
+    fdwReason: std.os.windows.DWORD,
+    lpReserved: std.os.windows.LPVOID,
+) callconv(.winapi) std.os.windows.BOOL {
+    return root.DllMain(@ptrCast(hinstDLL), fdwReason, lpReserved);
+}
+
 fn wasm_freestanding_start() callconv(.c) void {
     // This is marked inline because for some reason LLVM in
     // release mode fails to inline it, and we want fewer call frames in stack traces.

package/std/std.zig

@@ -65,7 +65,8 @@ pub const array_hash_map = @import("array_hash_map.zig");
 pub const atomic = @import("atomic.zig");
 pub const base64 = @import("base64.zig");
 pub const bit_set = @import("bit_set.zig");
-pub const builtin = @import("builtin.zig");
+pub const builtin = lang;
+pub const lang = @import("builtin.zig");
 pub const c = @import("c.zig");
 pub const coff = @import("coff.zig");
 pub const compress = @import("compress.zig");

package/std/zig/Ast/Render.zig

@@ -3442,7 +3442,7 @@ const AutoIndentingStream = struct {
     /// Sets current indentation level to be the same as that of the last pushSpace.
     pub fn enableSpaceMode(ais: *AutoIndentingStream, space: Space) void {
         if (ais.space_stack.items.len == 0) return;
-        const curr = ais.space_stack.getLast();
+        const curr = ais.space_stack.getLast().?;
         if (curr.space != space) return;
         ais.space_mode = curr.indent_count;
     }
@@ -3453,7 +3453,7 @@ const AutoIndentingStream = struct {
 
     pub fn lastSpaceModeIndent(ais: *AutoIndentingStream) usize {
         if (ais.space_stack.items.len == 0) return 0;
-        return ais.space_stack.getLast().indent_count * ais.indent_delta;
+        return ais.space_stack.getLast().?.indent_count * ais.indent_delta;
     }
 
     /// Push default indentation

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,

package/std/zig/WindowsSdk.zig

@@ -891,7 +891,7 @@ const MsvcLibDir = struct {
 
         lib_dir_buf.appendSliceAssumeCapacity(installation_path);
 
-        if (!Dir.path.isSep(lib_dir_buf.getLast())) {
+        if (!Dir.path.isSep(lib_dir_buf.getLast().?)) {
             try lib_dir_buf.append('\\');
         }
         const installation_path_with_trailing_sep_len = lib_dir_buf.items.len;
@@ -1064,7 +1064,7 @@ const MsvcLibDir = struct {
             errdefer msvc_dir.deinit();
 
             // String might contain trailing slash, so trim it here
-            if (msvc_dir.items.len > "C:\\".len and msvc_dir.getLast() == '\\') _ = msvc_dir.pop();
+            if (msvc_dir.items.len > "C:\\".len and msvc_dir.getLast().? == '\\') _ = msvc_dir.pop();
 
             // Remove `\include` at the end of path
             if (std.mem.endsWith(u8, msvc_dir.items, "\\include")) {
@@ -1108,7 +1108,7 @@ const MsvcLibDir = struct {
 
                     try list.appendSlice(VS140COMNTOOLS); // C:\Program Files (x86)\Microsoft Visual Studio 14.0\Common7\Tools
                     // String might contain trailing slash, so trim it here
-                    if (list.items.len > "C:\\".len and list.getLast() == '\\') _ = list.pop();
+                    if (list.items.len > "C:\\".len and list.getLast().? == '\\') _ = list.pop();
                     list.shrinkRetainingCapacity(list.items.len - "\\Common7\\Tools".len); // C:\Program Files (x86)\Microsoft Visual Studio 14.0
                     break :base_path list;
                 }
@@ -1131,7 +1131,7 @@ const MsvcLibDir = struct {
                 errdefer path.deinit();
 
                 // String might contain trailing slash, so trim it here
-                if (path.items.len > "C:\\".len and path.getLast() == '\\') _ = path.pop();
+                if (path.items.len > "C:\\".len and path.getLast().? == '\\') _ = path.pop();
                 break :base_path path;
             }
             return error.PathNotFound;

package/std/zig/llvm/Builder.zig

@@ -2310,7 +2310,7 @@ pub fn trailingStrtabString(self: *Builder) Allocator.Error!StrtabString {
 }
 
 pub fn trailingStrtabStringAssumeCapacity(self: *Builder) StrtabString {
-    const start = self.strtab_string_indices.getLast();
+    const start = self.strtab_string_indices.getLast().?;
     const bytes: []const u8 = self.strtab_string_bytes.items[start..];
     const gop = self.strtab_string_map.getOrPutAssumeCapacityAdapted(bytes, StrtabString.Adapter{ .builder = self });
     if (gop.found_existing) {
@@ -8905,7 +8905,7 @@ pub fn deinit(self: *Builder) void {
 
 pub fn finishModuleAsm(self: *Builder, aw: *Writer.Allocating) Allocator.Error!void {
     self.module_asm = aw.toArrayList();
-    if (self.module_asm.getLastOrNull()) |last| if (last != '\n')
+    if (self.module_asm.getLast()) |last| if (last != '\n')
         try self.module_asm.append(self.gpa, '\n');
 }
 
@@ -8951,7 +8951,7 @@ pub fn trailingString(self: *Builder) Allocator.Error!String {
 }
 
 pub fn trailingStringAssumeCapacity(self: *Builder) String {
-    const start = self.string_indices.getLast();
+    const start = self.string_indices.getLast().?;
     const bytes: []const u8 = self.string_bytes.items[start..];
     const gop = self.string_map.getOrPutAssumeCapacityAdapted(bytes, String.Adapter{ .builder = self });
     if (gop.found_existing) {
@@ -12150,7 +12150,7 @@ pub fn trailingMetadataString(self: *Builder) Allocator.Error!Metadata.String {
 }
 
 pub fn trailingMetadataStringAssumeCapacity(self: *Builder) Metadata.String {
-    const start = self.metadata_string_indices.getLast();
+    const start = self.metadata_string_indices.getLast().?;
     const bytes: []const u8 = self.metadata_string_bytes.items[start..];
     assert(bytes.len > 0);
     const gop = self.metadata_string_map.getOrPutAssumeCapacityAdapted(bytes, Metadata.String.Adapter{ .builder = self });