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

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.256",
   "description": "Zig standard library and libc headers (shared across all platforms)",
   "repository": {
     "type": "git",

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/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/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/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 });