@zigc/lib 0.16.0-dev.3144 → 0.16.0-dev.3153

package/compiler/reduce.zig

@@ -291,7 +291,11 @@ fn termToInteresting(term: std.process.Child.Term) Interestingness {
             std.debug.print("interestingness check terminated with signal {t}\n", .{sig});
             return .boring;
         },
-        else => {
+        .stopped => |sig| {
+            std.debug.print("interestingness check stopped with signal {t}\n", .{sig});
+            return .boring;
+        },
+        .unknown => {
             std.debug.print("interestingness check aborted unexpectedly\n", .{});
             return .boring;
         },

package/compiler/std-docs.zig

@@ -423,7 +423,14 @@ fn buildWasmBinary(
             );
             return error.WasmCompilationFailed;
         },
-        .stopped, .unknown => {
+        .stopped => |sig| {
+            std.log.err(
+                "the following command stopped unexpectedly with signal {t}:\n{s}",
+                .{ sig, try std.Build.Step.allocPrintCmd(arena, .inherit, null, argv.items) },
+            );
+            return error.WasmCompilationFailed;
+        },
+        .unknown => {
             std.log.err(
                 "the following command terminated unexpectedly:\n{s}",
                 .{try std.Build.Step.allocPrintCmd(arena, .inherit, null, argv.items)},

package/package.json

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

package/std/Build/Step/CheckObject.zig

@@ -1814,16 +1814,16 @@ const ElfDumper = struct {
                 files.putAssumeCapacityNoClobber(object.off - @sizeOf(elf.ar_hdr), object.name);
             }
 
-            var symbols = std.AutoArrayHashMap(usize, std.array_list.Managed([]const u8)).init(ctx.gpa);
+            var symbols: std.array_hash_map.Auto(usize, std.array_list.Managed([]const u8)) = .empty;
             defer {
                 for (symbols.values()) |*value| {
                     value.deinit();
                 }
-                symbols.deinit();
+                symbols.deinit(ctx.gpa);
             }
 
             for (ctx.symtab.items) |entry| {
-                const gop = try symbols.getOrPut(@intCast(entry.off));
+                const gop = try symbols.getOrPut(ctx.gpa, @intCast(entry.off));
                 if (!gop.found_existing) {
                     gop.value_ptr.* = std.array_list.Managed([]const u8).init(ctx.gpa);
                 }

package/std/Build/Step/ConfigHeader.zig

@@ -38,7 +38,7 @@ pub const Value = union(enum) {
 };
 
 step: Step,
-values: std.StringArrayHashMap(Value),
+values: std.array_hash_map.String(Value),
 /// This directory contains the generated file under the name `include_path`.
 generated_dir: std.Build.GeneratedFile,
 
@@ -95,7 +95,7 @@ pub fn create(owner: *std.Build, options: Options) *ConfigHeader {
             .first_ret_addr = options.first_ret_addr orelse @returnAddress(),
         }),
         .style = options.style,
-        .values = .init(owner.allocator),
+        .values = .empty,
 
         .max_bytes = options.max_bytes,
         .include_path = include_path,
@@ -110,7 +110,8 @@ pub fn create(owner: *std.Build, options: Options) *ConfigHeader {
 }
 
 pub fn addIdent(config_header: *ConfigHeader, name: []const u8, value: []const u8) void {
-    config_header.values.put(name, .{ .ident = value }) catch @panic("OOM");
+    const arena = config_header.step.owner.allocator;
+    config_header.values.put(arena, name, .{ .ident = value }) catch @panic("OOM");
 }
 
 pub fn addValue(config_header: *ConfigHeader, name: []const u8, comptime T: type, value: T) void {
@@ -131,43 +132,44 @@ pub fn getOutputFile(ch: *ConfigHeader) std.Build.LazyPath {
 }
 
 fn addValueInner(config_header: *ConfigHeader, name: []const u8, comptime T: type, value: T) !void {
+    const arena = config_header.step.owner.allocator;
     switch (@typeInfo(T)) {
         .null => {
-            try config_header.values.put(name, .undef);
+            try config_header.values.put(arena, name, .undef);
         },
         .void => {
-            try config_header.values.put(name, .defined);
+            try config_header.values.put(arena, name, .defined);
         },
         .bool => {
-            try config_header.values.put(name, .{ .boolean = value });
+            try config_header.values.put(arena, name, .{ .boolean = value });
         },
         .int => {
-            try config_header.values.put(name, .{ .int = value });
+            try config_header.values.put(arena, name, .{ .int = value });
         },
         .comptime_int => {
-            try config_header.values.put(name, .{ .int = value });
+            try config_header.values.put(arena, name, .{ .int = value });
         },
         .@"enum", .enum_literal => {
-            try config_header.values.put(name, .{ .ident = @tagName(value) });
+            try config_header.values.put(arena, name, .{ .ident = @tagName(value) });
         },
         .optional => {
             if (value) |x| {
                 return addValueInner(config_header, name, @TypeOf(x), x);
             } else {
-                try config_header.values.put(name, .undef);
+                try config_header.values.put(arena, name, .undef);
             }
         },
         .pointer => |ptr| {
             switch (@typeInfo(ptr.child)) {
                 .array => |array| {
                     if (ptr.size == .one and array.child == u8) {
-                        try config_header.values.put(name, .{ .string = value });
+                        try config_header.values.put(arena, name, .{ .string = value });
                         return;
                     }
                 },
                 .int => {
                     if (ptr.size == .slice and ptr.child == u8) {
-                        try config_header.values.put(name, .{ .string = value });
+                        try config_header.values.put(arena, name, .{ .string = value });
                         return;
                     }
                 },
@@ -218,8 +220,8 @@ fn make(step: *Step, options: Step.MakeOptions) !void {
                 });
             };
             switch (config_header.style) {
-                .autoconf_undef => try render_autoconf_undef(step, contents, bw, config_header.values, src_path),
-                .autoconf_at => try render_autoconf_at(step, contents, &aw, config_header.values, src_path),
+                .autoconf_undef => try render_autoconf_undef(step, contents, bw, &config_header.values, src_path),
+                .autoconf_at => try render_autoconf_at(step, contents, &aw, &config_header.values, src_path),
                 else => unreachable,
             }
         },
@@ -282,7 +284,7 @@ fn render_autoconf_undef(
     step: *Step,
     contents: []const u8,
     bw: *Writer,
-    values: std.StringArrayHashMap(Value),
+    values: *const std.array_hash_map.String(Value),
     src_path: []const u8,
 ) !void {
     const build = step.owner;
@@ -334,7 +336,7 @@ fn render_autoconf_at(
     step: *Step,
     contents: []const u8,
     aw: *Writer.Allocating,
-    values: std.StringArrayHashMap(Value),
+    values: *const std.array_hash_map.String(Value),
     src_path: []const u8,
 ) !void {
     const build = step.owner;
@@ -373,7 +375,7 @@ fn render_autoconf_at(
         if (!last_line) try bw.writeByte('\n');
     }
 
-    for (values.unmanaged.entries.slice().items(.key), used) |name, u| {
+    for (values.entries.slice().items(.key), used) |name, u| {
         if (!u) {
             try step.addError("{s}: error: config header value unused: '{s}'", .{ src_path, name });
             any_errors = true;
@@ -387,14 +389,14 @@ fn render_cmake(
     step: *Step,
     contents: []const u8,
     bw: *Writer,
-    values: std.StringArrayHashMap(Value),
+    values: std.array_hash_map.String(Value),
     src_path: []const u8,
 ) !void {
     const build = step.owner;
     const allocator = build.allocator;
 
-    var values_copy = try values.clone();
-    defer values_copy.deinit();
+    var values_copy = try values.clone(allocator);
+    defer values_copy.deinit(allocator);
 
     var any_errors = false;
     var line_index: u32 = 0;
@@ -523,7 +525,7 @@ fn render_cmake(
 fn render_blank(
     gpa: std.mem.Allocator,
     bw: *Writer,
-    defines: std.StringArrayHashMap(Value),
+    defines: std.array_hash_map.String(Value),
     include_path: []const u8,
     include_guard_override: ?[]const u8,
 ) !void {
@@ -555,7 +557,7 @@ fn render_blank(
     , .{include_guard_name});
 }
 
-fn render_nasm(bw: *Writer, defines: std.StringArrayHashMap(Value)) !void {
+fn render_nasm(bw: *Writer, defines: std.array_hash_map.String(Value)) !void {
     for (defines.keys(), defines.values()) |name, value| try renderValueNasm(bw, name, value);
 }
 
@@ -586,7 +588,7 @@ fn renderValueNasm(bw: *Writer, name: []const u8, value: Value) !void {
 fn expand_variables_autoconf_at(
     bw: *Writer,
     contents: []const u8,
-    values: std.StringArrayHashMap(Value),
+    values: *const std.array_hash_map.String(Value),
     used: []bool,
 ) !void {
     const valid_varname_chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789_";
@@ -612,7 +614,7 @@ fn expand_variables_autoconf_at(
                 try bw.writeAll(key);
                 return error.MissingValue;
             };
-            const value = values.unmanaged.entries.slice().items(.value)[index];
+            const value = values.entries.slice().items(.value)[index];
             used[index] = true;
             try bw.writeAll(contents[source_offset..curr]);
             switch (value) {
@@ -633,7 +635,7 @@ fn expand_variables_autoconf_at(
 fn expand_variables_cmake(
     allocator: Allocator,
     contents: []const u8,
-    values: std.StringArrayHashMap(Value),
+    values: std.array_hash_map.String(Value),
 ) ![]const u8 {
     var result: std.array_list.Managed(u8) = .init(allocator);
     errdefer result.deinit();
@@ -765,7 +767,7 @@ fn testReplaceVariablesAutoconfAt(
     allocator: Allocator,
     contents: []const u8,
     expected: []const u8,
-    values: std.StringArrayHashMap(Value),
+    values: std.array_hash_map.String(Value),
 ) !void {
     var aw: Writer.Allocating = .init(allocator);
     defer aw.deinit();
@@ -784,7 +786,7 @@ fn testReplaceVariablesCMake(
     allocator: Allocator,
     contents: []const u8,
     expected: []const u8,
-    values: std.StringArrayHashMap(Value),
+    values: std.array_hash_map.String(Value),
 ) !void {
     const actual = try expand_variables_cmake(allocator, contents, values);
     defer allocator.free(actual);
@@ -794,7 +796,7 @@ fn testReplaceVariablesCMake(
 
 test "expand_variables_autoconf_at simple cases" {
     const allocator = std.testing.allocator;
-    var values: std.StringArrayHashMap(Value) = .init(allocator);
+    var values: std.array_hash_map.String(Value) = .init(allocator);
     defer values.deinit();
 
     // empty strings are preserved
@@ -890,7 +892,7 @@ test "expand_variables_autoconf_at simple cases" {
 
 test "expand_variables_autoconf_at edge cases" {
     const allocator = std.testing.allocator;
-    var values: std.StringArrayHashMap(Value) = .init(allocator);
+    var values: std.array_hash_map.String(Value) = .init(allocator);
     defer values.deinit();
 
     // @-vars resolved only when they wrap valid characters, otherwise considered literals
@@ -906,7 +908,7 @@ test "expand_variables_autoconf_at edge cases" {
 
 test "expand_variables_cmake simple cases" {
     const allocator = std.testing.allocator;
-    var values: std.StringArrayHashMap(Value) = .init(allocator);
+    var values: std.array_hash_map.String(Value) = .init(allocator);
     defer values.deinit();
 
     try values.putNoClobber("undef", .undef);
@@ -994,7 +996,7 @@ test "expand_variables_cmake simple cases" {
 
 test "expand_variables_cmake edge cases" {
     const allocator = std.testing.allocator;
-    var values: std.StringArrayHashMap(Value) = .init(allocator);
+    var values: std.array_hash_map.String(Value) = .init(allocator);
     defer values.deinit();
 
     // special symbols
@@ -1055,7 +1057,7 @@ test "expand_variables_cmake edge cases" {
 
 test "expand_variables_cmake escaped characters" {
     const allocator = std.testing.allocator;
-    var values: std.StringArrayHashMap(Value) = .init(allocator);
+    var values: std.array_hash_map.String(Value) = .init(allocator);
     defer values.deinit();
 
     try values.putNoClobber("string", Value{ .string = "text" });

package/std/Build/Step/Run.zig

@@ -1173,7 +1173,7 @@ fn formatTerm(term: ?process.Child.Term, w: *std.Io.Writer) std.Io.Writer.Error!
     if (term) |t| switch (t) {
         .exited => |code| try w.print("exited with code {d}", .{code}),
         .signal => |sig| try w.print("terminated with signal {t}", .{sig}),
-        .stopped => |sig| try w.print("stopped with signal {d}", .{sig}),
+        .stopped => |sig| try w.print("stopped with signal {t}", .{sig}),
         .unknown => |code| try w.print("terminated for unknown reason with code {d}", .{code}),
     } else {
         try w.writeAll("exited with any code");
@@ -2804,8 +2804,8 @@ fn hashStdIo(hh: *std.Build.Cache.HashHelper, stdio: StdIo) void {
                 .expect_term => |term| {
                     hh.add(@as(std.meta.Tag(process.Child.Term), term));
                     switch (term) {
-                        inline .exited, .signal => |x| hh.add(x),
-                        .stopped, .unknown => |x| hh.add(x),
+                        inline .exited, .signal, .stopped => |x| hh.add(x),
+                        .unknown => |x| hh.add(x),
                     }
                 },
             }

package/std/Build/Step/TranslateC.zig

@@ -18,14 +18,12 @@ target: std.Build.ResolvedTarget,
 optimize: std.builtin.OptimizeMode,
 output_file: std.Build.GeneratedFile,
 link_libc: bool,
-use_clang: bool,
 
 pub const Options = struct {
     root_source_file: std.Build.LazyPath,
     target: std.Build.ResolvedTarget,
     optimize: std.builtin.OptimizeMode,
     link_libc: bool = true,
-    use_clang: bool = true,
 };
 
 pub fn create(owner: *std.Build, options: Options) *TranslateC {
@@ -46,7 +44,6 @@ pub fn create(owner: *std.Build, options: Options) *TranslateC {
         .optimize = options.optimize,
         .output_file = .{ .step = &translate_c.step },
         .link_libc = options.link_libc,
-        .use_clang = options.use_clang,
         .system_libs = .empty,
     };
     source.addStepDependencies(&translate_c.step);
@@ -175,9 +172,6 @@ fn make(step: *Step, options: Step.MakeOptions) !void {
     if (translate_c.link_libc) {
         try argv_list.append("-lc");
     }
-    if (!translate_c.use_clang) {
-        try argv_list.append("-fno-clang");
-    }
 
     try argv_list.append("--cache-dir");
     try argv_list.append(b.cache_root.path orelse ".");

package/std/Build/Step.zig

@@ -725,19 +725,12 @@ pub inline fn handleChildProcUnsupported(s: *Step) error{ OutOfMemory, MakeFaile
 /// Asserts that the caller has already populated `s.result_failed_command`.
 pub fn handleChildProcessTerm(s: *Step, term: std.process.Child.Term) error{ MakeFailed, OutOfMemory }!void {
     assert(s.result_failed_command != null);
-    switch (term) {
-        .exited => |code| {
-            if (code != 0) {
-                return s.fail("process exited with error code {d}", .{code});
-            }
-        },
-        .signal => |sig| {
-            return s.fail("process terminated with signal {t}", .{sig});
-        },
-        .stopped, .unknown => {
-            return s.fail("process terminated unexpectedly", .{});
-        },
-    }
+    return switch (term) {
+        .exited => |code| if (code != 0) s.fail("process exited with error code {d}", .{code}),
+        .signal => |sig| s.fail("process terminated with signal {t}", .{sig}),
+        .stopped => |sig| s.fail("process stopped with signal {t}", .{sig}),
+        .unknown => s.fail("process terminated unexpectedly", .{}),
+    };
 }
 
 pub fn allocPrintCmd(

package/std/Build/WebServer.zig

@@ -681,7 +681,14 @@ fn buildClientWasm(ws: *WebServer, arena: Allocator, optimize: std.builtin.Optim
             );
             return error.WasmCompilationFailed;
         },
-        .stopped, .unknown => {
+        .stopped => |sig| {
+            log.err(
+                "the following command stopped unexpectedly with signal {t}:\n{s}",
+                .{ sig, try Build.Step.allocPrintCmd(arena, .inherit, null, argv.items) },
+            );
+            return error.WasmCompilationFailed;
+        },
+        .unknown => {
             log.err(
                 "the following command terminated unexpectedly:\n{s}",
                 .{try Build.Step.allocPrintCmd(arena, .inherit, null, argv.items)},

package/std/Build.zig

@@ -86,10 +86,10 @@ libc_runtimes_dir: ?[]const u8 = null,
 
 dep_prefix: []const u8 = "",
 
-modules: std.StringArrayHashMap(*Module),
+modules: std.array_hash_map.String(*Module),
 
-named_writefiles: std.StringArrayHashMap(*Step.WriteFile),
-named_lazy_paths: std.StringArrayHashMap(LazyPath),
+named_writefiles: std.array_hash_map.String(*Step.WriteFile),
+named_lazy_paths: std.array_hash_map.String(LazyPath),
 /// The hash of this instance's package. `""` means that this is the root package.
 pkg_hash: []const u8,
 /// A mapping from dependency names to package hashes.
@@ -312,9 +312,9 @@ pub fn create(
         },
         .install_path = undefined,
         .args = null,
-        .modules = .init(arena),
-        .named_writefiles = .init(arena),
-        .named_lazy_paths = .init(arena),
+        .modules = .empty,
+        .named_writefiles = .empty,
+        .named_lazy_paths = .empty,
         .pkg_hash = "",
         .available_deps = available_deps,
         .release_mode = .off,
@@ -405,9 +405,9 @@ fn createChildOnly(
         .enable_wine = parent.enable_wine,
         .libc_runtimes_dir = parent.libc_runtimes_dir,
         .dep_prefix = parent.fmt("{s}{s}.", .{ parent.dep_prefix, dep_name }),
-        .modules = .init(allocator),
-        .named_writefiles = .init(allocator),
-        .named_lazy_paths = .init(allocator),
+        .modules = .empty,
+        .named_writefiles = .empty,
+        .named_lazy_paths = .empty,
         .pkg_hash = pkg_hash,
         .available_deps = pkg_deps,
         .release_mode = parent.release_mode,
@@ -908,7 +908,7 @@ pub const AssemblyOptions = struct {
 /// `createModule` can be used instead to create a private module.
 pub fn addModule(b: *Build, name: []const u8, options: Module.CreateOptions) *Module {
     const module = Module.create(b, options);
-    b.modules.put(b.dupe(name), module) catch @panic("OOM");
+    b.modules.put(b.graph.arena, b.dupe(name), module) catch @panic("OOM");
     return module;
 }
 
@@ -1056,12 +1056,12 @@ pub fn addWriteFile(b: *Build, file_path: []const u8, data: []const u8) *Step.Wr
 
 pub fn addNamedWriteFiles(b: *Build, name: []const u8) *Step.WriteFile {
     const wf = Step.WriteFile.create(b);
-    b.named_writefiles.put(b.dupe(name), wf) catch @panic("OOM");
+    b.named_writefiles.put(b.graph.arena, b.dupe(name), wf) catch @panic("OOM");
     return wf;
 }
 
 pub fn addNamedLazyPath(b: *Build, name: []const u8, lp: LazyPath) void {
-    b.named_lazy_paths.put(b.dupe(name), lp.dupe(b)) catch @panic("OOM");
+    b.named_lazy_paths.put(b.graph.arena, b.dupe(name), lp.dupe(b)) catch @panic("OOM");
 }
 
 /// Creates a step for mutating files inside a temporary directory created lazily
@@ -1899,11 +1899,11 @@ pub fn runAllowFail(
             }
             return stdout;
         },
-        .signal => |sig| {
+        .signal, .stopped => |sig| {
             out_code.* = @as(u8, @truncate(@intFromEnum(sig)));
             return error.ProcessTerminated;
         },
-        .stopped, .unknown => |code| {
+        .unknown => |code| {
             out_code.* = @as(u8, @truncate(code));
             return error.ProcessTerminated;
         },

package/std/Io/Threaded.zig

@@ -15281,7 +15281,7 @@ fn childWaitPosix(child: *process.Child) process.Child.WaitError!process.Child.T
                 return switch (code) {
                     .EXITED => .{ .exited = @truncate(status) },
                     .KILLED, .DUMPED => .{ .signal = @enumFromInt(status) },
-                    .TRAPPED, .STOPPED => .{ .stopped = status },
+                    .TRAPPED, .STOPPED => .{ .stopped = @enumFromInt(status) },
                     _, .CONTINUED => .{ .unknown = status },
                 };
             },

package/std/Io/Uring.zig

@@ -4729,7 +4729,7 @@ fn childWait(userdata: ?*anyopaque, child: *process.Child) process.Child.WaitErr
                 return switch (code) {
                     .EXITED => .{ .exited = @truncate(status) },
                     .KILLED, .DUMPED => .{ .signal = @enumFromInt(status) },
-                    .TRAPPED, .STOPPED => .{ .stopped = status },
+                    .TRAPPED, .STOPPED => .{ .stopped = @enumFromInt(status) },
                     _, .CONTINUED => .{ .unknown = status },
                 };
             },