@zigc/lib 0.17.0-dev.633 → 0.17.0-dev.644

package/compiler/Maker/PkgConfig.zig

@@ -104,6 +104,7 @@ fn getPkgs(
         else => |e| return e,
     };
 
+    step.clearFailedCommand(maker.gpa);
     pc.pkgs = result;
     return result;
 }

package/compiler/Maker/Step/Compile.zig

@@ -1291,11 +1291,9 @@ fn appendModuleFlags(
 
     if (m.resolved_target.get(conf)) |resolved_target| {
         // Communicate the query via CLI since it's more compact.
-        if (resolved_target.query.get(conf)) |compact_query| {
+        if (resolved_target.unwrapQuery(conf)) |query| {
             try zig_args.ensureUnusedCapacity(gpa, 6);
 
-            const query = compact_query.unwrap(conf);
-
             zig_args.appendAssumeCapacity("-target");
             zig_args.appendAssumeCapacity(try query.zigTriple(arena));
 

package/compiler/Maker/Step/Run.zig

@@ -332,6 +332,12 @@ pub fn make(
 
     try populateGeneratedStdIo(maker, &conf_run, cache_root, &digest);
     try populateGeneratedPaths(maker, output_placeholders.items, cache_root, &digest);
+
+    // The utility functions that spawn the child process must unconditionally allocate
+    // the failed command because at that point it is not known whether the step will
+    // pass or fail based on the process termination. Here we free the memory since
+    // the step has succeeded.
+    step.clearFailedCommand(gpa);
 }
 
 /// Reads stdout of a Zig test process until a termination condition is reached:
@@ -1823,8 +1829,7 @@ fn runCommand(
                 }
                 const root_module = producer.root_module.get(conf);
                 const root_module_target = root_module.resolved_target.get(conf).?.result.get(conf);
-                const other_target_query = root_module_target.unwrap(conf);
-                const root_target = std.zig.system.resolveTargetQuery(io, other_target_query) catch unreachable;
+                const root_target = root_module_target.unwrapTarget(conf);
                 const link_libc = maker.stepByIndex(producer_index).extended.compile.is_linking_libc;
 
                 const host: std.Target = std.zig.system.resolveTargetQuery(io, .{}) catch |he| switch (he) {
@@ -1908,6 +1913,12 @@ fn runCommand(
                             // by default. '-S inherit-env' was added in Wasmtime version 20.
                             interp_argv.appendAssumeCapacity("-Sinherit-env");
                             interp_argv.appendSliceAssumeCapacity(argv);
+
+                            // Enable more detailed backtraces by default, but allow the user to override this (e.g.
+                            // with `WASMTIME_BACKTRACE_DETAILS=0`) if desired.
+                            if (environ_map.get("WASMTIME_BACKTRACE_DETAILS") == null) {
+                                try environ_map.put("WASMTIME_BACKTRACE_DETAILS", "1");
+                            }
                         } else {
                             return failForeign(arena, &conf_run, maker, run_index, "-fwasmtime", argv[0], &root_target, &host);
                         }
@@ -2143,7 +2154,11 @@ fn spawnChildAndCollect(
         .dir => unreachable,
         .inherit => null,
     };
-    errdefer step.setFailedCommand(gpa, argv, .{
+    // We have to set the failed command here regardless of whether this
+    // function returns an error because only after this function returns
+    // does the logic determine whether the child process termination was
+    // success or failure.
+    step.setFailedCommand(gpa, argv, .{
         .cwd = cwd_string,
         .child_env = environ_map,
         .parent_env = &graph.environ_map,

package/compiler/Maker/Step/TranslateC.zig

@@ -40,10 +40,11 @@ pub fn make(
     argv.appendAssumeCapacity("--global-cache-dir");
     argv.appendAssumeCapacity(graph.global_cache_root.path orelse ".");
 
-    if (conf_tc.target.get(conf).?.query.unwrap()) |compact_query| {
-        const query = compact_query.get(conf).unwrap(conf);
-        argv.appendAssumeCapacity("-target");
-        argv.appendAssumeCapacity(try query.zigTriple(arena));
+    if (conf_tc.target.get(conf)) |resolved_target| {
+        if (resolved_target.unwrapQuery(conf)) |query| {
+            argv.appendAssumeCapacity("-target");
+            argv.appendAssumeCapacity(try query.zigTriple(arena));
+        }
     }
 
     switch (conf_tc.flags.optimize) {

package/package.json

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

package/std/Build/Configuration.zig

@@ -2144,6 +2144,33 @@ pub const ResolvedTarget = struct {
             return (unwrap(this) orelse return null).get(c);
         }
     };
+
+    pub fn unwrapQuery(rt: *const ResolvedTarget, c: *const Configuration) ?std.Target.Query {
+        const tq = rt.query.get(c) orelse return null;
+        const cpu_arch = tq.flags.cpu_arch.unwrap() orelse rt.result.get(c).flags.cpu_arch.unwrap().?;
+        return .{
+            .cpu_arch = cpu_arch,
+            .cpu_model = switch (tq.flags.cpu_model) {
+                .native => .native,
+                .baseline => .baseline,
+                .determined_by_arch_os => .determined_by_arch_os,
+                .explicit => .{ .explicit = cpu_arch.parseCpuModel(tq.cpu_name.value.?.slice(c)).? },
+            },
+            .cpu_features_add = tq.cpu_features_add.value orelse .empty,
+            .cpu_features_sub = tq.cpu_features_sub.value orelse .empty,
+            .os_tag = tq.flags.os_tag.unwrap(),
+            .os_version_min = tq.os_version_min.u.unwrap(c),
+            .os_version_max = tq.os_version_max.u.unwrap(c),
+            .glibc_version = if (tq.glibc_version.value) |s|
+                std.SemanticVersion.parse(s.slice(c)) catch unreachable
+            else
+                null,
+            .android_api_level = tq.android_api_level.value,
+            .abi = tq.flags.abi.unwrap(),
+            .dynamic_linker = if (tq.dynamic_linker.value) |s| .init(s.slice(c)) else null,
+            .ofmt = tq.flags.object_format.unwrap(),
+        };
+    }
 };
 
 pub const TargetQuery = struct {
@@ -2731,29 +2758,50 @@ pub const TargetQuery = struct {
         dynamic_linker: bool,
     };
 
-    pub fn unwrap(tq: *const TargetQuery, c: *const Configuration) std.Target.Query {
-        const cpu_arch = tq.flags.cpu_arch.unwrap();
+    pub fn unwrapTarget(tq: *const TargetQuery, c: *const Configuration) std.Target {
+        const cpu_arch = tq.flags.cpu_arch.unwrap().?;
+        const os_tag = tq.flags.os_tag.unwrap().?;
         return .{
-            .cpu_arch = cpu_arch,
-            .cpu_model = switch (tq.flags.cpu_model) {
-                .native => .native,
-                .baseline => .baseline,
-                .determined_by_arch_os => .determined_by_arch_os,
-                .explicit => .{ .explicit = cpu_arch.?.parseCpuModel(tq.cpu_name.value.?.slice(c)).? },
+            .cpu = .{
+                .arch = cpu_arch,
+                .model = cpu_arch.parseCpuModel(tq.cpu_name.value.?.slice(c)).?,
+                .features = tq.cpu_features_add.value.?,
             },
-            .cpu_features_add = tq.cpu_features_add.value orelse .empty,
-            .cpu_features_sub = tq.cpu_features_sub.value orelse .empty,
-            .os_tag = tq.flags.os_tag.unwrap(),
-            .os_version_min = tq.os_version_min.u.unwrap(c),
-            .os_version_max = tq.os_version_max.u.unwrap(c),
-            .glibc_version = if (tq.glibc_version.value) |s|
-                std.SemanticVersion.parse(s.slice(c)) catch unreachable
-            else
-                null,
-            .android_api_level = tq.android_api_level.value,
-            .abi = tq.flags.abi.unwrap(),
-            .dynamic_linker = if (tq.dynamic_linker.value) |s| .init(s.slice(c)) else null,
-            .ofmt = tq.flags.object_format.unwrap(),
+            .os = .{
+                .tag = os_tag,
+                .version_range = switch (os_tag) {
+                    .linux => .{ .linux = .{
+                        .range = .{
+                            .min = tq.os_version_min.u.unwrap(c).?.semver,
+                            .max = tq.os_version_max.u.unwrap(c).?.semver,
+                        },
+                        .glibc = std.SemanticVersion.parse(tq.glibc_version.value.?.slice(c)) catch unreachable,
+                        .android = tq.android_api_level.value.?,
+                    } },
+                    .hurd => .{ .hurd = .{
+                        .range = .{
+                            .min = tq.os_version_min.u.unwrap(c).?.semver,
+                            .max = tq.os_version_max.u.unwrap(c).?.semver,
+                        },
+                        .glibc = std.SemanticVersion.parse(tq.glibc_version.value.?.slice(c)) catch unreachable,
+                    } },
+                    .windows => .{ .windows = .{
+                        .min = tq.os_version_min.u.unwrap(c).?.windows,
+                        .max = tq.os_version_max.u.unwrap(c).?.windows,
+                    } },
+                    else => switch (tq.os_version_min.u.unwrap(c).?) {
+                        .none => .{ .none = {} },
+                        .semver => |min| .{ .semver = .{
+                            .min = min,
+                            .max = tq.os_version_max.u.unwrap(c).?.semver,
+                        } },
+                        .windows => unreachable,
+                    },
+                },
+            },
+            .abi = tq.flags.abi.unwrap().?,
+            .ofmt = tq.flags.object_format.unwrap().?,
+            .dynamic_linker = .init(if (tq.dynamic_linker.value) |s| s.slice(c) else null),
         };
     }
 };

package/std/Build.zig

@@ -830,7 +830,17 @@ pub fn addModule(b: *Build, name: []const u8, options: Module.CreateOptions) *Mo
     const graph = b.graph;
     const arena = graph.arena;
     const module = Module.create(b, options);
-    b.modules.put(arena, graph.dupeString(name), module) catch @panic("OOM");
+    const gop = b.modules.getOrPutValue(
+        arena,
+        graph.dupeString(name),
+        module,
+    ) catch @panic("OOM");
+    if (gop.found_existing) {
+        panic(
+            "A module with the name '{s}' has already been added to the package. Consider creating a private module with std.Build.createModule",
+            .{name},
+        );
+    }
     return module;
 }
 
@@ -992,13 +1002,33 @@ 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 graph = b.graph;
     const wf = Step.WriteFile.create(b);
-    b.named_writefiles.put(graph.arena, graph.dupeString(name), wf) catch @panic("OOM");
+    const gop = b.named_writefiles.getOrPutValue(
+        graph.arena,
+        graph.dupeString(name),
+        wf,
+    ) catch @panic("OOM");
+    if (gop.found_existing) {
+        panic(
+            "A WriteFile step with the name '{s}' has already been added to the package. Consider creating a private WriteFile step with std.Build.addWriteFiles",
+            .{name},
+        );
+    }
     return wf;
 }
 
 pub fn addNamedLazyPath(b: *Build, name: []const u8, lp: LazyPath) void {
     const graph = b.graph;
-    b.named_lazy_paths.put(graph.arena, graph.dupeString(name), lp.dupe(graph)) catch @panic("OOM");
+    const gop = b.named_lazy_paths.getOrPutValue(
+        graph.arena,
+        graph.dupeString(name),
+        lp.dupe(graph),
+    ) catch @panic("OOM");
+    if (gop.found_existing) {
+        panic(
+            "A LazyPath with the name '{s}' has already been added to the package.",
+            .{name},
+        );
+    }
 }
 
 /// Creates a step for mutating files inside a temporary directory created lazily

package/std/Io/Kqueue.zig

@@ -1403,7 +1403,7 @@ fn openSocketPosix(
 
     if (options.ip6_only) {
         if (posix.IPV6 == void) return error.OptionUnsupported;
-        try setSocketOption(k, socket_fd, posix.IPPROTO.IPV6, posix.IPV6.V6ONLY, 0);
+        try setSocketOption(k, socket_fd, posix.IPPROTO.IPV6, posix.IPV6.V6ONLY, 1);
     }
 
     return socket_fd;

package/std/Io/Threaded.zig

@@ -12409,7 +12409,7 @@ fn openSocketPosix(
 
     if (options.ip6_only) {
         if (posix.IPV6 == void) return error.OptionUnsupported;
-        try setSocketOptionPosix(socket_fd, posix.IPPROTO.IPV6, posix.IPV6.V6ONLY, 0);
+        try setSocketOptionPosix(socket_fd, posix.IPPROTO.IPV6, posix.IPV6.V6ONLY, 1);
     }
 
     return socket_fd;

package/std/Io/Uring.zig

@@ -2739,6 +2739,7 @@ fn dirOpenDir(
             error.FileBusy => return errnoBug(.TXTBSY),
             error.PathAlreadyExists => return errnoBug(.EXIST), // Not creating.
             error.OperationUnsupported => return errnoBug(.OPNOTSUPP), // No TMPFILE, no locks.
+            error.ReadOnlyFileSystem => return errnoBug(.ROFS), // Not creating.
             else => |e| return e,
         },
     };
@@ -3164,6 +3165,7 @@ fn dirRealPathFile(
     }, 0) catch |err| switch (err) {
         error.WouldBlock => return errnoBug(.AGAIN),
         error.OperationUnsupported => return errnoBug(.OPNOTSUPP), // Not asking for locks.
+        error.ReadOnlyFileSystem => return errnoBug(.ROFS), // Not creating.
         else => |e| return e,
     };
     defer ev.closeAsync(fd);
@@ -5984,7 +5986,7 @@ fn socket(
 
     if (options.ip6_only) {
         if (linux.IPV6 == void) return error.OptionUnsupported;
-        try ev.setsockopt(cancel_region, socket_fd, linux.IPPROTO.IPV6, linux.IPV6.V6ONLY, 0);
+        try ev.setsockopt(cancel_region, socket_fd, linux.IPPROTO.IPV6, linux.IPV6.V6ONLY, 1);
     }
 
     return socket_fd;