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

package/std/c.zig

@@ -3721,14 +3721,14 @@ pub const W = switch (native_os) {
         pub fn TERMSIG(x: u32) SIG {
             return @enumFromInt(status(x));
         }
-        pub fn STOPSIG(x: u32) u32 {
-            return x >> 8;
+        pub fn STOPSIG(x: u32) SIG {
+            return @enumFromInt(x >> 8);
         }
         pub fn IFEXITED(x: u32) bool {
             return status(x) == 0;
         }
         pub fn IFSTOPPED(x: u32) bool {
-            return status(x) == stopped and STOPSIG(x) != 0x13;
+            return status(x) == stopped and @as(u32, @intFromEnum(STOPSIG(x))) != 0x13;
         }
         pub fn IFSIGNALED(x: u32) bool {
             return status(x) != stopped and status(x) != 0;
@@ -3754,8 +3754,8 @@ pub const W = switch (native_os) {
         pub fn TERMSIG(s: u32) SIG {
             return @enumFromInt(s & 0x7f);
         }
-        pub fn STOPSIG(s: u32) u32 {
-            return EXITSTATUS(s);
+        pub fn STOPSIG(s: u32) SIG {
+            return @enumFromInt(EXITSTATUS(s));
         }
         pub fn IFEXITED(s: u32) bool {
             return (s & 0x7f) == 0;
@@ -3782,8 +3782,8 @@ pub const W = switch (native_os) {
         pub fn TERMSIG(s: u32) SIG {
             return @enumFromInt(s & 0x7f);
         }
-        pub fn STOPSIG(s: u32) u32 {
-            return EXITSTATUS(s);
+        pub fn STOPSIG(s: u32) SIG {
+            return @enumFromInt(EXITSTATUS(s));
         }
         pub fn IFEXITED(s: u32) bool {
             return (s & 0x7f) == 0;
@@ -3816,8 +3816,8 @@ pub const W = switch (native_os) {
         pub fn TERMSIG(s: u32) SIG {
             return @enumFromInt(s & 0x7f);
         }
-        pub fn STOPSIG(s: u32) u32 {
-            return EXITSTATUS(s);
+        pub fn STOPSIG(s: u32) SIG {
+            return @enumFromInt(EXITSTATUS(s));
         }
         pub fn IFEXITED(s: u32) bool {
             return (s & 0x7f) == 0;
@@ -3850,8 +3850,8 @@ pub const W = switch (native_os) {
         pub fn TERMSIG(s: u32) SIG {
             return @enumFromInt(s & 0x7f);
         }
-        pub fn STOPSIG(s: u32) u32 {
-            return EXITSTATUS(s);
+        pub fn STOPSIG(s: u32) SIG {
+            return @enumFromInt(EXITSTATUS(s));
         }
         pub fn IFEXITED(s: u32) bool {
             return (s & 0x7f) == 0;
@@ -3879,8 +3879,8 @@ pub const W = switch (native_os) {
             return @enumFromInt((s >> 8) & 0xff);
         }
 
-        pub fn STOPSIG(s: u32) u32 {
-            return (s >> 16) & 0xff;
+        pub fn STOPSIG(s: u32) SIG {
+            return @enumFromInt((s >> 16) & 0xff);
         }
 
         pub fn IFEXITED(s: u32) bool {
@@ -3906,8 +3906,8 @@ pub const W = switch (native_os) {
         pub fn TERMSIG(s: u32) SIG {
             return @enumFromInt(s & 0x7f);
         }
-        pub fn STOPSIG(s: u32) u32 {
-            return EXITSTATUS(s);
+        pub fn STOPSIG(s: u32) SIG {
+            return @enumFromInt(EXITSTATUS(s));
         }
         pub fn IFEXITED(s: u32) bool {
             return (s & 0x7f) == 0;
@@ -3938,8 +3938,8 @@ pub const W = switch (native_os) {
             return @intCast((s & 0xff00) >> 8);
         }
 
-        pub fn STOPSIG(s: u32) u32 {
-            return EXITSTATUS(s);
+        pub fn STOPSIG(s: u32) SIG {
+            return @enumFromInt(EXITSTATUS(s));
         }
 
         pub fn TERMSIG(s: u32) SIG {

package/std/json/Stringify.zig

@@ -770,9 +770,9 @@ fn testBasicWriteStream(w: *Stringify) !void {
 }
 
 fn getJsonObject(allocator: std.mem.Allocator) !std.json.Value {
-    var v: std.json.Value = .{ .object = std.json.ObjectMap.init(allocator) };
-    try v.object.put("one", std.json.Value{ .integer = @as(i64, @intCast(1)) });
-    try v.object.put("two", std.json.Value{ .float = 2.0 });
+    var v: std.json.Value = .{ .object = .empty };
+    try v.object.put(allocator, "one", std.json.Value{ .integer = @as(i64, @intCast(1)) });
+    try v.object.put(allocator, "two", std.json.Value{ .float = 2.0 });
     return v;
 }
 

package/std/json/dynamic.zig

@@ -1,7 +1,7 @@
 const std = @import("std");
 const debug = std.debug;
 const ArenaAllocator = std.heap.ArenaAllocator;
-const StringArrayHashMap = std.StringArrayHashMap;
+const StringArrayHashMap = std.array_hash_map.String;
 const Allocator = std.mem.Allocator;
 const json = std.json;
 
@@ -103,10 +103,10 @@ pub const Value = union(enum) {
 
                 .object_begin => {
                     switch (try source.nextAllocMax(allocator, .alloc_always, options.max_value_len.?)) {
-                        .object_end => return try handleCompleteValue(&stack, allocator, source, Value{ .object = ObjectMap.init(allocator) }, options) orelse continue,
+                        .object_end => return try handleCompleteValue(&stack, allocator, source, Value{ .object = .empty }, options) orelse continue,
                         .allocated_string => |key| {
                             try stack.appendSlice(&[_]Value{
-                                Value{ .object = ObjectMap.init(allocator) },
+                                Value{ .object = .empty },
                                 Value{ .string = key },
                             });
                         },
@@ -145,7 +145,7 @@ fn handleCompleteValue(stack: *Array, allocator: Allocator, source: anytype, val
                 // stack: [..., .object]
                 var object = &stack.items[stack.items.len - 1].object;
 
-                const gop = try object.getOrPut(key);
+                const gop = try object.getOrPut(allocator, key);
                 if (gop.found_existing) {
                     switch (options.duplicate_field_behavior) {
                         .use_first => {},

package/std/os/emscripten.zig

@@ -212,7 +212,7 @@ pub const W = struct {
         return @enumFromInt(s & 0x7f);
     }
     pub fn STOPSIG(s: u32) u32 {
-        return EXITSTATUS(s);
+        return @enumFromInt(EXITSTATUS(s));
     }
     pub fn IFEXITED(s: u32) bool {
         return (s & 0x7f) == 0;

package/std/os/linux.zig

@@ -3883,8 +3883,8 @@ pub const W = struct {
     pub fn TERMSIG(s: u32) SIG {
         return @enumFromInt(s & 0x7f);
     }
-    pub fn STOPSIG(s: u32) u32 {
-        return EXITSTATUS(s);
+    pub fn STOPSIG(s: u32) SIG {
+        return @enumFromInt(EXITSTATUS(s));
     }
     pub fn IFEXITED(s: u32) bool {
         return (s & 0x7f) == 0;

package/std/process/Child.zig

@@ -94,7 +94,7 @@ pub const ResourceUsageStatistics = struct {
 pub const Term = union(enum) {
     exited: u8,
     signal: std.posix.SIG,
-    stopped: u32,
+    stopped: std.posix.SIG,
     unknown: u32,
 };
 

package/std/std.zig

@@ -1,7 +1,3 @@
-pub const ArrayHashMap = array_hash_map.ArrayHashMap;
-pub const ArrayHashMapUnmanaged = array_hash_map.ArrayHashMapUnmanaged;
-pub const AutoArrayHashMap = array_hash_map.AutoArrayHashMap;
-pub const AutoArrayHashMapUnmanaged = array_hash_map.AutoArrayHashMapUnmanaged;
 pub const AutoHashMap = hash_map.AutoHashMap;
 pub const AutoHashMapUnmanaged = hash_map.AutoHashMapUnmanaged;
 pub const BitStack = @import("BitStack.zig");
@@ -31,14 +27,19 @@ pub const SinglyLinkedList = @import("SinglyLinkedList.zig");
 pub const StaticBitSet = bit_set.StaticBitSet;
 pub const StringHashMap = hash_map.StringHashMap;
 pub const StringHashMapUnmanaged = hash_map.StringHashMapUnmanaged;
-pub const StringArrayHashMap = array_hash_map.StringArrayHashMap;
-pub const StringArrayHashMapUnmanaged = array_hash_map.StringArrayHashMapUnmanaged;
 pub const Target = @import("Target.zig");
 pub const Thread = @import("Thread.zig");
 pub const Treap = @import("treap.zig").Treap;
 pub const Tz = tz.Tz;
 pub const Uri = @import("Uri.zig");
 
+/// Deprecated; use `array_hash_map.Custom`.
+pub const ArrayHashMapUnmanaged = array_hash_map.Custom;
+/// Deprecated; use `array_hash_map.Auto`.
+pub const AutoArrayHashMapUnmanaged = array_hash_map.Auto;
+/// Deprecated; use `array_hash_map.String`.
+pub const StringArrayHashMapUnmanaged = array_hash_map.String;
+
 /// A contiguous, growable list of items in memory. This is a wrapper around a
 /// slice of `T` values.
 ///

package/std/zig/AstGen.zig

@@ -1779,8 +1779,8 @@ fn structInitExpr(
         var sfba = std.heap.stackFallback(256, astgen.arena);
         const sfba_allocator = sfba.get();
 
-        var duplicate_names = std.AutoArrayHashMap(Zir.NullTerminatedString, ArrayList(Ast.TokenIndex)).init(sfba_allocator);
-        try duplicate_names.ensureTotalCapacity(@intCast(struct_init.ast.fields.len));
+        var duplicate_names: std.array_hash_map.Auto(Zir.NullTerminatedString, ArrayList(Ast.TokenIndex)) = .empty;
+        try duplicate_names.ensureTotalCapacity(sfba_allocator, @intCast(struct_init.ast.fields.len));
 
         // When there aren't errors, use this to avoid a second iteration.
         var any_duplicate = false;
@@ -1789,7 +1789,7 @@ fn structInitExpr(
             const name_token = tree.firstToken(field) - 2;
             const name_index = try astgen.identAsString(name_token);
 
-            const gop = try duplicate_names.getOrPut(name_index);
+            const gop = try duplicate_names.getOrPut(sfba_allocator, name_index);
 
             if (gop.found_existing) {
                 try gop.value_ptr.append(sfba_allocator, name_token);

package/std/zig/system.zig

@@ -1185,11 +1185,25 @@ fn detectAndroidApiLevel(io: Io) !u32 {
         return error.ApiLevelQueryFailed;
     };
 
-    const term = try child.wait(io);
-    if (term != .exited or term.exited != 0) {
-        std.log.err("getprop terminated abnormally: {}", .{term});
-        return error.ApiLevelQueryFailed;
+    switch (try child.wait(io)) {
+        .exited => |code| if (code != 0) {
+            std.log.err("getprop terminated abnormally with exit code: {d}", .{code});
+            return error.ApiLevelQueryFailed;
+        },
+        .signal => |sig| {
+            std.log.err("getprop terminated abnormally with signal: {t}", .{sig});
+            return error.ApiLevelQueryFailed;
+        },
+        .stopped => |sig| {
+            std.log.err("getprop stopped abnormally with signal: {t}", .{sig});
+            return error.ApiLevelQueryFailed;
+        },
+        .unknown => {
+            std.log.err("getprop terminated abnormally", .{});
+            return error.ApiLevelQueryFailed;
+        },
     }
+
     return api_level;
 }