@zigc/lib 0.15.1 → 0.15.2-test.99

package/LICENSE

@@ -0,0 +1,19 @@
+Copyright (c) 2026 Nurul Huda (Apon).
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

package/build-web/fuzz.zig

@@ -101,22 +101,22 @@ const SourceLocationIndex = enum(u32) {
 
     fn sourceLocationLinkHtml(
         sli: SourceLocationIndex,
-        out: *std.ArrayListUnmanaged(u8),
+        out: *std.ArrayList(u8),
         focused: bool,
-    ) Allocator.Error!void {
+    ) error{OutOfMemory}!void {
         const sl = sli.ptr();
-        try out.writer(gpa).print("<code{s}>", .{
+        try out.print(gpa, "<code{s}>", .{
             @as([]const u8, if (focused) " class=\"status-running\"" else ""),
         });
         try sli.appendPath(out);
-        try out.writer(gpa).print(":{d}:{d} </code><button class=\"linkish\" onclick=\"wasm_exports.fuzzSelectSli({d});\">View</button>", .{
+        try out.print(gpa, ":{d}:{d} </code><button class=\"linkish\" onclick=\"wasm_exports.fuzzSelectSli({d});\">View</button>", .{
             sl.line,
             sl.column,
             @intFromEnum(sli),
         });
     }
 
-    fn appendPath(sli: SourceLocationIndex, out: *std.ArrayListUnmanaged(u8)) Allocator.Error!void {
+    fn appendPath(sli: SourceLocationIndex, out: *std.ArrayList(u8)) error{OutOfMemory}!void {
         const sl = sli.ptr();
         const file = coverage.fileAt(sl.file);
         const file_name = coverage.stringAt(file.basename);
@@ -294,7 +294,7 @@ fn updateStats() error{OutOfMemory}!void {
 }
 
 fn updateEntryPoints() error{OutOfMemory}!void {
-    var html: std.ArrayListUnmanaged(u8) = .empty;
+    var html: std.ArrayList(u8) = .empty;
     defer html.deinit(gpa);
     for (entry_points.items) |sli| {
         try html.appendSlice(gpa, "<li>");

package/build-web/time_report.zig

@@ -44,7 +44,7 @@ pub fn genericResultMessage(msg_bytes: []u8) error{OutOfMemory}!void {
     js.updateGeneric(msg.step_idx, inner_html.ptr, inner_html.len);
 }
 
-pub fn compileResultMessage(msg_bytes: []u8) error{OutOfMemory}!void {
+pub fn compileResultMessage(msg_bytes: []u8) error{ OutOfMemory, WriteFailed }!void {
     const max_table_rows = 500;
 
     if (msg_bytes.len < @sizeOf(abi.CompileResult)) @panic("malformed CompileResult message");
@@ -166,10 +166,11 @@ pub fn compileResultMessage(msg_bytes: []u8) error{OutOfMemory}!void {
     });
     defer gpa.free(inner_html);
 
-    var file_table_html: std.ArrayListUnmanaged(u8) = .empty;
-    defer file_table_html.deinit(gpa);
+    var file_table_html: std.Io.Writer.Allocating = .init(gpa);
+    defer file_table_html.deinit();
+
     for (slowest_files[0..@min(max_table_rows, slowest_files.len)]) |file| {
-        try file_table_html.writer(gpa).print(
+        try file_table_html.writer.print(
             \\<tr>
             \\  <th scope="row"><code>{f}</code></th>
             \\  <td>{D}</td>
@@ -187,17 +188,17 @@ pub fn compileResultMessage(msg_bytes: []u8) error{OutOfMemory}!void {
         });
     }
     if (slowest_files.len > max_table_rows) {
-        try file_table_html.writer(gpa).print(
+        try file_table_html.writer.print(
             \\<tr><td colspan="4">{d} more rows omitted</td></tr>
             \\
         , .{slowest_files.len - max_table_rows});
     }
 
-    var decl_table_html: std.ArrayListUnmanaged(u8) = .empty;
-    defer decl_table_html.deinit(gpa);
+    var decl_table_html: std.Io.Writer.Allocating = .init(gpa);
+    defer decl_table_html.deinit();
 
     for (slowest_decls[0..@min(max_table_rows, slowest_decls.len)]) |decl| {
-        try decl_table_html.writer(gpa).print(
+        try decl_table_html.writer.print(
             \\<tr>
             \\  <th scope="row"><code>{f}</code></th>
             \\  <th scope="row"><code>{f}</code></th>
@@ -219,7 +220,7 @@ pub fn compileResultMessage(msg_bytes: []u8) error{OutOfMemory}!void {
         });
     }
     if (slowest_decls.len > max_table_rows) {
-        try decl_table_html.writer(gpa).print(
+        try decl_table_html.writer.print(
             \\<tr><td colspan="6">{d} more rows omitted</td></tr>
             \\
         , .{slowest_decls.len - max_table_rows});
@@ -229,10 +230,10 @@ pub fn compileResultMessage(msg_bytes: []u8) error{OutOfMemory}!void {
         hdr.step_idx,
         inner_html.ptr,
         inner_html.len,
-        file_table_html.items.ptr,
-        file_table_html.items.len,
-        decl_table_html.items.ptr,
-        decl_table_html.items.len,
+        file_table_html.written().ptr,
+        file_table_html.written().len,
+        decl_table_html.written().ptr,
+        decl_table_html.written().len,
         hdr.flags.use_llvm,
     );
 }

package/compiler/reduce/Walk.zig

@@ -501,6 +501,10 @@ fn walkExpression(w: *Walk, node: Ast.Node.Index) Error!void {
         .@"asm",
         => return walkAsm(w, ast.fullAsm(node).?),
 
+        .asm_legacy => {
+            return walkAsmLegacy(w, ast.legacyAsm(node).?);
+        },
+
         .enum_literal => {
             return walkIdentifier(w, ast.nodeMainToken(node)); // name
         },
@@ -665,7 +669,7 @@ fn walkStructInit(
 
 fn walkCall(w: *Walk, call: Ast.full.Call) Error!void {
     try walkExpression(w, call.ast.fn_expr);
-    try walkParamList(w, call.ast.params);
+    try walkExpressions(w, call.ast.params);
 }
 
 fn walkSlice(
@@ -830,7 +834,7 @@ fn walkWhile(w: *Walk, node_index: Ast.Node.Index, while_node: Ast.full.While) E
 }
 
 fn walkFor(w: *Walk, for_node: Ast.full.For) Error!void {
-    try walkParamList(w, for_node.ast.inputs);
+    try walkExpressions(w, for_node.ast.inputs);
     try walkExpression(w, for_node.ast.then_expr);
     if (for_node.ast.else_expr.unwrap()) |else_expr| {
         try walkExpression(w, else_expr);
@@ -874,15 +878,12 @@ fn walkIf(w: *Walk, node_index: Ast.Node.Index, if_node: Ast.full.If) Error!void
 
 fn walkAsm(w: *Walk, asm_node: Ast.full.Asm) Error!void {
     try walkExpression(w, asm_node.ast.template);
-    for (asm_node.ast.items) |item| {
-        try walkExpression(w, item);
-    }
+    try walkExpressions(w, asm_node.ast.items);
 }
 
-fn walkParamList(w: *Walk, params: []const Ast.Node.Index) Error!void {
-    for (params) |param_node| {
-        try walkExpression(w, param_node);
-    }
+fn walkAsmLegacy(w: *Walk, asm_node: Ast.full.AsmLegacy) Error!void {
+    try walkExpression(w, asm_node.ast.template);
+    try walkExpressions(w, asm_node.ast.items);
 }
 
 /// Check if it is already gutted (i.e. its body replaced with `@trap()`).

package/compiler/reduce.zig

@@ -114,10 +114,10 @@ pub fn main() !void {
     interestingness_argv.appendAssumeCapacity(checker_path);
     interestingness_argv.appendSliceAssumeCapacity(argv);
 
-    var rendered = std.array_list.Managed(u8).init(gpa);
+    var rendered: std.Io.Writer.Allocating = .init(gpa);
     defer rendered.deinit();
 
-    var astgen_input = std.array_list.Managed(u8).init(gpa);
+    var astgen_input: std.Io.Writer.Allocating = .init(gpa);
     defer astgen_input.deinit();
 
     var tree = try parse(gpa, root_source_file_path);
@@ -138,10 +138,10 @@ pub fn main() !void {
         }
     }
 
-    var fixups: Ast.Fixups = .{};
+    var fixups: Ast.Render.Fixups = .{};
     defer fixups.deinit(gpa);
 
-    var more_fixups: Ast.Fixups = .{};
+    var more_fixups: Ast.Render.Fixups = .{};
     defer more_fixups.deinit(gpa);
 
     var rng = std.Random.DefaultPrng.init(seed);
@@ -188,15 +188,14 @@ pub fn main() !void {
             try transformationsToFixups(gpa, arena, root_source_file_path, this_set, &fixups);
 
             rendered.clearRetainingCapacity();
-            try tree.renderToArrayList(&rendered, fixups);
+            try tree.render(gpa, &rendered.writer, fixups);
 
             // The transformations we applied may have resulted in unused locals,
             // in which case we would like to add the respective discards.
             {
-                try astgen_input.resize(rendered.items.len);
-                @memcpy(astgen_input.items, rendered.items);
-                try astgen_input.append(0);
-                const source_with_null = astgen_input.items[0 .. astgen_input.items.len - 1 :0];
+                try astgen_input.writer.writeAll(rendered.written());
+                try astgen_input.writer.writeByte(0);
+                const source_with_null = astgen_input.written()[0..(astgen_input.written().len - 1) :0];
                 var astgen_tree = try Ast.parse(gpa, source_with_null, .zig);
                 defer astgen_tree.deinit(gpa);
                 if (astgen_tree.errors.len != 0) {
@@ -228,12 +227,12 @@ pub fn main() !void {
                     }
                     if (more_fixups.count() != 0) {
                         rendered.clearRetainingCapacity();
-                        try astgen_tree.renderToArrayList(&rendered, more_fixups);
+                        try astgen_tree.render(gpa, &rendered.writer, more_fixups);
                     }
                 }
             }
 
-            try std.fs.cwd().writeFile(.{ .sub_path = root_source_file_path, .data = rendered.items });
+            try std.fs.cwd().writeFile(.{ .sub_path = root_source_file_path, .data = rendered.written() });
             // std.debug.print("trying this code:\n{s}\n", .{rendered.items});
 
             const interestingness = try runCheck(arena, interestingness_argv.items);
@@ -273,8 +272,8 @@ pub fn main() !void {
         // Revert the source back to not be transformed.
         fixups.clearRetainingCapacity();
         rendered.clearRetainingCapacity();
-        try tree.renderToArrayList(&rendered, fixups);
-        try std.fs.cwd().writeFile(.{ .sub_path = root_source_file_path, .data = rendered.items });
+        try tree.render(gpa, &rendered.writer, fixups);
+        try std.fs.cwd().writeFile(.{ .sub_path = root_source_file_path, .data = rendered.written() });
 
         return std.process.cleanExit();
     }
@@ -318,7 +317,7 @@ fn transformationsToFixups(
     arena: Allocator,
     root_source_file_path: []const u8,
     transforms: []const Walk.Transformation,
-    fixups: *Ast.Fixups,
+    fixups: *Ast.Render.Fixups,
 ) !void {
     fixups.clearRetainingCapacity();
 
@@ -359,7 +358,7 @@ fn transformationsToFixups(
                 other_file_ast.deinit(gpa);
             }
 
-            var inlined_fixups: Ast.Fixups = .{};
+            var inlined_fixups: Ast.Render.Fixups = .{};
             defer inlined_fixups.deinit(gpa);
             if (std.fs.path.dirname(inline_imported_file.imported_string)) |dirname| {
                 inlined_fixups.rebase_imported_paths = dirname;
@@ -382,16 +381,16 @@ fn transformationsToFixups(
                 }
             }
 
-            var other_source = std.array_list.Managed(u8).init(gpa);
+            var other_source: std.io.Writer.Allocating = .init(gpa);
             defer other_source.deinit();
-            try other_source.appendSlice("struct {\n");
-            try other_file_ast.renderToArrayList(&other_source, inlined_fixups);
-            try other_source.appendSlice("}");
+            try other_source.writer.writeAll("struct {\n");
+            try other_file_ast.render(gpa, &other_source.writer, inlined_fixups);
+            try other_source.writer.writeAll("}");
 
             try fixups.replace_nodes_with_string.put(
                 gpa,
                 inline_imported_file.builtin_call_node,
-                try arena.dupe(u8, other_source.items),
+                try arena.dupe(u8, other_source.written()),
             );
         },
     };

package/compiler/resinator/compile.zig

@@ -674,7 +674,7 @@ pub const Compiler = struct {
                         }
 
                         try file_reader.seekTo(entry.data_offset_from_start_of_file);
-                        var header_bytes = (file_reader.interface.takeArray(16) catch {
+                        var header_bytes: [16]u8 align(@alignOf(ico.BitmapHeader)) = (file_reader.interface.takeArray(16) catch {
                             return self.iconReadError(
                                 error.UnexpectedEOF,
                                 filename_utf8,

package/compiler_rt/arm.zig

@@ -37,7 +37,7 @@ comptime {
             @export(&__aeabi_memclr4, .{ .name = "__aeabi_memclr4", .linkage = common.linkage, .visibility = common.visibility });
             @export(&__aeabi_memclr8, .{ .name = "__aeabi_memclr8", .linkage = common.linkage, .visibility = common.visibility });
 
-            if (builtin.os.tag == .linux) {
+            if (builtin.os.tag == .linux or builtin.os.tag == .freebsd) {
                 @export(&__aeabi_read_tp, .{ .name = "__aeabi_read_tp", .linkage = common.linkage, .visibility = common.visibility });
             }
 

package/init/build.zig

@@ -44,7 +44,7 @@ pub fn build(b: *std.Build) void {
     // Here we define an executable. An executable needs to have a root module
     // which needs to expose a `main` function. While we could add a main function
     // to the module defined above, it's sometimes preferable to split business
-    // business logic and the CLI into two separate modules.
+    // logic and the CLI into two separate modules.
     //
     // If your goal is to create a Zig library for others to use, consider if
     // it might benefit from also exposing a CLI tool. A parser library for a

package/libc/include/generic-glibc/arpa/inet.h

@@ -101,10 +101,13 @@ extern char *inet_nsap_ntoa (int __len, const unsigned char *__cp,
 			     char *__buf) __THROW;
 #endif
 
+// zig patch: inet was fortified in glibc 2.42
+#if (__GLIBC__ == 2 && __GLIBC_MINOR__ >= 42) || __GLIBC__ > 2
 #if __USE_FORTIFY_LEVEL > 0 && defined __fortify_function
 /* Include functions with security checks.  */
 #  include <bits/inet-fortified.h>
 #endif
+#endif
 
 __END_DECLS
 

package/libc/musl/src/fenv/loongarch64/fenv-sf.c

@@ -0,0 +1,3 @@
+#ifdef __loongarch_soft_float
+#include "../fenv.c"
+#endif

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zigc/lib",
-  "version": "0.15.1",
+  "version": "0.15.2-test.99",
   "description": "Zig standard library and libc headers (shared across all platforms)",
   "repository": {
     "type": "git",

package/std/Build/Step/Compile.zig

@@ -1827,7 +1827,26 @@ fn getZigArgs(compile: *Compile, fuzz: bool) ![][]const u8 {
         _ = try std.fmt.bufPrint(&args_hex_hash, "{x}", .{&args_hash});
 
         const args_file = "args" ++ fs.path.sep_str ++ args_hex_hash;
-        try b.cache_root.handle.writeFile(.{ .sub_path = args_file, .data = args });
+        if (b.cache_root.handle.access(args_file, .{})) |_| {
+            // The args file is already present from a previous run.
+        } else |err| switch (err) {
+            error.FileNotFound => {
+                try b.cache_root.handle.makePath("tmp");
+                const rand_int = std.crypto.random.int(u64);
+                const tmp_path = "tmp" ++ fs.path.sep_str ++ std.fmt.hex(rand_int);
+                try b.cache_root.handle.writeFile(.{ .sub_path = tmp_path, .data = args });
+                defer b.cache_root.handle.deleteFile(tmp_path) catch {
+                    // It's fine if the temporary file can't be cleaned up.
+                };
+                b.cache_root.handle.rename(tmp_path, args_file) catch |rename_err| switch (rename_err) {
+                    error.PathAlreadyExists => {
+                        // The args file was created by another concurrent build process.
+                    },
+                    else => |other_err| return other_err,
+                };
+            },
+            else => |other_err| return other_err,
+        }
 
         const resolved_args_file = try mem.concat(arena, u8, &.{
             "@",

package/std/Build/Step/TranslateC.zig

@@ -163,6 +163,12 @@ fn make(step: *Step, options: Step.MakeOptions) !void {
         try argv_list.append("-fno-clang");
     }
 
+    try argv_list.append("--cache-dir");
+    try argv_list.append(b.cache_root.path orelse ".");
+
+    try argv_list.append("--global-cache-dir");
+    try argv_list.append(b.graph.global_cache_root.path orelse ".");
+
     try argv_list.append("--listen=-");
 
     if (!translate_c.target.query.isNative()) {

package/std/Build/WebServer.zig

@@ -323,7 +323,7 @@ fn serveWebSocket(ws: *WebServer, sock: *http.Server.WebSocket) !noreturn {
                 // Temporarily unlock, then re-lock after the message is sent.
                 ws.time_report_mutex.unlock();
                 defer ws.time_report_mutex.lock();
-                try sock.writeMessage(msg, .binary);
+                try sock.writeMessage(owned_msg, .binary);
             }
         }
 

package/std/Build.zig

@@ -2524,7 +2524,10 @@ pub const LazyPath = union(enum) {
                 .up = gen.up,
                 .sub_path = dupePathInner(allocator, gen.sub_path),
             } },
-            .dependency => |dep| .{ .dependency = dep },
+            .dependency => |dep| .{ .dependency = .{
+                .dependency = dep.dependency,
+                .sub_path = dupePathInner(allocator, dep.sub_path),
+            } },
         };
     }
 };

package/std/Io/Reader/Limited.zig

@@ -27,6 +27,7 @@ pub fn init(reader: *Reader, limit: Limit, buffer: []u8) Limited {
 
 fn stream(r: *Reader, w: *Writer, limit: Limit) Reader.StreamError!usize {
     const l: *Limited = @fieldParentPtr("interface", r);
+    if (l.remaining == .nothing) return error.EndOfStream;
     const combined_limit = limit.min(l.remaining);
     const n = try l.unlimited.stream(w, combined_limit);
     l.remaining = l.remaining.subtract(n).?;
@@ -51,8 +52,51 @@ test stream {
 
 fn discard(r: *Reader, limit: Limit) Reader.Error!usize {
     const l: *Limited = @fieldParentPtr("interface", r);
+    if (l.remaining == .nothing) return error.EndOfStream;
     const combined_limit = limit.min(l.remaining);
     const n = try l.unlimited.discard(combined_limit);
     l.remaining = l.remaining.subtract(n).?;
     return n;
 }
+
+test "end of stream, read, hit limit exactly" {
+    var f: Reader = .fixed("i'm dying");
+    var l = f.limited(.limited(4), &.{});
+    const r = &l.interface;
+
+    var buf: [2]u8 = undefined;
+    try r.readSliceAll(&buf);
+    try r.readSliceAll(&buf);
+    try std.testing.expectError(error.EndOfStream, l.interface.readSliceAll(&buf));
+}
+
+test "end of stream, read, hit limit after partial read" {
+    var f: Reader = .fixed("i'm dying");
+    var l = f.limited(.limited(5), &.{});
+    const r = &l.interface;
+
+    var buf: [2]u8 = undefined;
+    try r.readSliceAll(&buf);
+    try r.readSliceAll(&buf);
+    try std.testing.expectError(error.EndOfStream, l.interface.readSliceAll(&buf));
+}
+
+test "end of stream, discard, hit limit exactly" {
+    var f: Reader = .fixed("i'm dying");
+    var l = f.limited(.limited(4), &.{});
+    const r = &l.interface;
+
+    try r.discardAll(2);
+    try r.discardAll(2);
+    try std.testing.expectError(error.EndOfStream, l.interface.discardAll(2));
+}
+
+test "end of stream, discard, hit limit after partial read" {
+    var f: Reader = .fixed("i'm dying");
+    var l = f.limited(.limited(5), &.{});
+    const r = &l.interface;
+
+    try r.discardAll(2);
+    try r.discardAll(2);
+    try std.testing.expectError(error.EndOfStream, l.interface.discardAll(2));
+}