@zigc/lib 0.16.0-test.1 → 0.17.0-dev.27

package/std/priority_dequeue.zig

@@ -40,8 +40,9 @@ pub fn PriorityDequeue(comptime T: type, comptime Context: type, comptime compar
         }
 
         /// Free memory used by the dequeue.
-        pub fn deinit(self: Self, allocator: Allocator) void {
+        pub fn deinit(self: *Self, allocator: Allocator) void {
             allocator.free(self.items);
+            self.* = undefined;
         }
 
         /// Insert a new element, maintaining priority.
@@ -77,7 +78,7 @@ pub fn PriorityDequeue(comptime T: type, comptime Context: type, comptime compar
             return 1 == @clz(index +% 1) & 1;
         }
 
-        fn nextIsMinLayer(self: Self) bool {
+        fn nextIsMinLayer(self: *const Self) bool {
             return isMinLayer(self.len);
         }
 
@@ -86,7 +87,7 @@ pub fn PriorityDequeue(comptime T: type, comptime Context: type, comptime compar
             min_layer: bool,
         };
 
-        fn getStartForSiftUp(self: Self, child: T, index: usize) StartIndexAndLayer {
+        fn getStartForSiftUp(self: *const Self, child: T, index: usize) StartIndexAndLayer {
             const child_index = index;
             const parent_index = parentIndex(child_index);
             const parent = self.items[parent_index];
@@ -136,20 +137,20 @@ pub fn PriorityDequeue(comptime T: type, comptime Context: type, comptime compar
 
         /// Look at the smallest element in the dequeue. Returns
         /// `null` if empty.
-        pub fn peekMin(self: *Self) ?T {
+        pub fn peekMin(self: *const Self) ?T {
             return if (self.len > 0) self.items[0] else null;
         }
 
         /// Look at the largest element in the dequeue. Returns
         /// `null` if empty.
-        pub fn peekMax(self: *Self) ?T {
+        pub fn peekMax(self: *const Self) ?T {
             if (self.len == 0) return null;
             if (self.len == 1) return self.items[0];
             if (self.len == 2) return self.items[1];
             return self.bestItemAtIndices(1, 2, .gt).item;
         }
 
-        fn maxIndex(self: Self) ?usize {
+        fn maxIndex(self: *const Self) ?usize {
             if (self.len == 0) return null;
             if (self.len == 1) return 0;
             if (self.len == 2) return 1;
@@ -261,14 +262,14 @@ pub fn PriorityDequeue(comptime T: type, comptime Context: type, comptime compar
             index: usize,
         };
 
-        fn getItem(self: Self, index: usize) ItemAndIndex {
+        fn getItem(self: *const Self, index: usize) ItemAndIndex {
             return .{
                 .item = self.items[index],
                 .index = index,
             };
         }
 
-        fn bestItem(self: Self, item1: ItemAndIndex, item2: ItemAndIndex, target_order: Order) ItemAndIndex {
+        fn bestItem(self: *const Self, item1: ItemAndIndex, item2: ItemAndIndex, target_order: Order) ItemAndIndex {
             if (compareFn(self.context, item1.item, item2.item) == target_order) {
                 return item1;
             } else {
@@ -276,13 +277,13 @@ pub fn PriorityDequeue(comptime T: type, comptime Context: type, comptime compar
             }
         }
 
-        fn bestItemAtIndices(self: Self, index1: usize, index2: usize, target_order: Order) ItemAndIndex {
+        fn bestItemAtIndices(self: *const Self, index1: usize, index2: usize, target_order: Order) ItemAndIndex {
             const item1 = self.getItem(index1);
             const item2 = self.getItem(index2);
             return self.bestItem(item1, item2, target_order);
         }
 
-        fn bestDescendent(self: Self, first_child_index: usize, first_grandchild_index: usize, target_order: Order) ItemAndIndex {
+        fn bestDescendent(self: *const Self, first_child_index: usize, first_grandchild_index: usize, target_order: Order) ItemAndIndex {
             const second_child_index = first_child_index + 1;
             if (first_grandchild_index >= self.len) {
                 // No grandchildren, find the best child (second may not exist)
@@ -314,13 +315,13 @@ pub fn PriorityDequeue(comptime T: type, comptime Context: type, comptime compar
         }
 
         /// Return the number of elements remaining in the dequeue
-        pub fn count(self: Self) usize {
+        pub fn count(self: *const Self) usize {
             return self.len;
         }
 
         /// Return the number of elements that can be added to the
         /// dequeue before more memory is allocated.
-        pub fn capacity(self: Self) usize {
+        pub fn capacity(self: *const Self) usize {
             return self.items.len;
         }
 

package/std/priority_queue.zig

@@ -41,6 +41,7 @@ pub fn PriorityQueue(comptime T: type, comptime Context: type, comptime compareF
         /// Free memory used by the queue.
         pub fn deinit(self: *Self, allocator: Allocator) void {
             allocator.free(self.allocatedSlice());
+            self.* = undefined;
         }
 
         /// Insert a new element, maintaining priority.
@@ -78,7 +79,7 @@ pub fn PriorityQueue(comptime T: type, comptime Context: type, comptime compareF
 
         /// Look at the highest priority element in the queue. Returns
         /// `null` if empty.
-        pub fn peek(self: *Self) ?T {
+        pub fn peek(self: *const Self) ?T {
             return if (self.items.len > 0) self.items[0] else null;
         }
 
@@ -117,19 +118,19 @@ pub fn PriorityQueue(comptime T: type, comptime Context: type, comptime compareF
 
         /// Return the number of elements remaining in the priority
         /// queue.
-        pub fn count(self: Self) usize {
+        pub fn count(self: *const Self) usize {
             return self.items.len;
         }
 
         /// Return the number of elements that can be added to the
         /// queue before more memory is allocated.
-        pub fn capacity(self: Self) usize {
+        pub fn capacity(self: *const Self) usize {
             return self.cap;
         }
 
         /// Returns a slice of all the items plus the extra capacity, whose memory
         /// contents are `undefined`.
-        fn allocatedSlice(self: Self) []T {
+        fn allocatedSlice(self: *const Self) []T {
             // `items.len` is the length, not the capacity.
             return self.items.ptr[0..self.cap];
         }

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/process/Environ.zig

@@ -24,7 +24,7 @@ pub const empty: Environ = .{ .block = .empty };
 /// operating system `void` is also used.
 pub const Block = switch (native_os) {
     .windows => GlobalBlock,
-    .wasi => switch (builtin.link_libc) {
+    .wasi, .emscripten => switch (builtin.link_libc) {
         false => GlobalBlock,
         true => PosixBlock,
     },

package/std/start.zig

@@ -631,6 +631,7 @@ inline fn callMainWithArgs(argc: usize, argv: [*][*:0]u8, envp: [:null]?[*:0]u8)
     if (std.Options.debug_threaded_io) |t| {
         if (@sizeOf(std.Io.Threaded.Argv0) != 0) t.argv0.value = argv[0];
         t.environ = .{ .process_environ = .{ .block = env_block } };
+        t.environ_initialized = env_block.isEmpty();
     }
     std.Thread.maybeAttachSignalStack();
     std.debug.maybeEnableSegfaultHandler();
@@ -664,10 +665,22 @@ fn main(c_argc: c_int, c_argv: [*][*:0]c_char, c_envp: [*:null]?[*:0]c_char) cal
 
 fn mainWithoutEnv(c_argc: c_int, c_argv: [*][*:0]c_char) callconv(.c) c_int {
     const argv = @as([*][*:0]u8, @ptrCast(c_argv))[0..@intCast(c_argc)];
-    if (@sizeOf(std.Io.Threaded.Argv0) != 0) {
-        if (std.Options.debug_threaded_io) |t| t.argv0.value = argv[0];
+    const environ: [:null]?[*:0]u8 = switch (builtin.os.tag) {
+        .wasi, .emscripten => environ: {
+            const c_environ = std.c.environ;
+            var env_count: usize = 0;
+            while (c_environ[env_count] != null) : (env_count += 1) {}
+            break :environ c_environ[0..env_count :null];
+        },
+        else => &.{},
+    };
+    const env_block: std.process.Environ.Block = .{ .slice = environ };
+    if (std.Options.debug_threaded_io) |t| {
+        if (@sizeOf(std.Io.Threaded.Argv0) != 0) t.argv0.value = argv[0];
+        t.environ = .{ .process_environ = .{ .block = env_block } };
+        t.environ_initialized = env_block.isEmpty();
     }
-    return callMain(argv, .empty);
+    return callMain(argv, env_block);
 }
 
 /// General error message for a malformed return type
@@ -748,7 +761,7 @@ inline fn wrapMain(result: anytype) u8 {
         std.log.err("{t}", .{err});
         switch (native_os) {
             .freestanding, .other => {},
-            else => if (@errorReturnTrace()) |trace| std.debug.dumpStackTrace(trace),
+            else => if (@errorReturnTrace()) |trace| std.debug.dumpErrorReturnTrace(trace),
         }
         return 1;
     };

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.
 ///
@@ -164,6 +165,8 @@ pub const Options = struct {
     /// * `debug.dumpCurrentStackTrace`
     /// * `debug.writeStackTrace`
     /// * `debug.dumpStackTrace`
+    /// * `debug.writeErrorReturnTrace`
+    /// * `debug.dumpErrorReturnTrace`
     ///
     /// Stack traces can generally be collected and printed when debug info is stripped, but are
     /// often less useful since they usually cannot be mapped to source locations and/or have bad
@@ -177,6 +180,16 @@ pub const Options = struct {
     /// Allows disabling networking in std.Io implementations.
     networking: bool = true,
 
+    /// Whether or not `error.Unexpected` will print its value and a stack trace.
+    ///
+    /// If this happens the fix is to add the error code to the corresponding
+    /// switch expression, possibly introduce a new error in the error set, and
+    /// send a patch to Zig.
+    unexpected_error_tracing: bool = @import("builtin").mode == .Debug and switch (@import("builtin").zig_backend) {
+        .stage2_llvm, .stage2_x86_64 => true,
+        else => false,
+    },
+
     /// TODO This is a separate decl instead of a field as a workaround around
     /// compilation errors due to zig not being lazy enough.
     pub const logTerminalMode: fn () Io.Terminal.Mode = log.defaultTerminalMode;

package/std/testing/FailingAllocator.zig

@@ -65,7 +65,7 @@ fn alloc(
     if (self.alloc_index == self.fail_index) {
         if (!self.has_induced_failure) {
             const st = std.debug.captureCurrentStackTrace(.{ .first_address = return_address }, &self.stack_addresses);
-            @memset(self.stack_addresses[@min(st.index, self.stack_addresses.len)..], 0);
+            @memset(self.stack_addresses[@min(st.return_addresses.len, self.stack_addresses.len)..], 0);
             self.has_induced_failure = true;
         }
         return null;
@@ -131,15 +131,15 @@ fn free(
 }
 
 /// Only valid once `has_induced_failure == true`
-pub fn getStackTrace(self: *FailingAllocator) std.builtin.StackTrace {
+pub fn getStackTrace(self: *FailingAllocator) std.debug.StackTrace {
     std.debug.assert(self.has_induced_failure);
     var len: usize = 0;
     while (len < self.stack_addresses.len and self.stack_addresses[len] != 0) {
         len += 1;
     }
     return .{
-        .instruction_addresses = &self.stack_addresses,
-        .index = len,
+        .return_addresses = self.stack_addresses[0..len],
+        .skipped = if (len == self.stack_addresses.len) .unknown else .none,
     };
 }
 

package/std/testing/Smith.zig

@@ -205,6 +205,24 @@ pub noinline fn valueRangeLessThan(s: *Smith, T: type, at_least: T, less_than: T
     return s.valueRangeLessThanWithHash(T, at_least, less_than, firstHash());
 }
 
+/// It is asserted `len` is nonzero.
+/// It is asserted `len` fits within 64 bits.
+//
+// `noinline` to capture a unique return address
+pub noinline fn index(s: *Smith, len: usize) usize {
+    @disableInstrumentation();
+    return s.indexWithHash(len, firstHash());
+}
+
+/// It is asserted that the weight of `false` is non-zero.
+/// It is asserted that the weight of `true` is non-zero.
+//
+// `noinline` to capture a unique return address
+pub noinline fn boolWeighted(s: *Smith, false_weight: u64, true_weight: u64) bool {
+    @disableInstrumentation();
+    return s.boolWeightedWithHash(false_weight, true_weight, firstHash());
+}
+
 /// This is similar to `value(bool)` however it is gauraunteed to eventually
 /// return `true` and provides the fuzzer with an extra hint about the data.
 //
@@ -228,6 +246,7 @@ pub noinline fn eosWeighted(s: *Smith, weights: []const Weight) bool {
 /// This is similar to `value(bool)` however it is gauraunteed to eventually
 /// return `true` and provides the fuzzer with an extra hint about the data.
 ///
+/// It is asserted that the weight of `false` is non-zero.
 /// It is asserted that the weight of `true` is non-zero.
 //
 // `noinline` to capture a unique return address
@@ -463,6 +482,24 @@ pub fn valueRangeLessThanWithHash(s: *Smith, T: type, at_least: T, less_than: T,
     return s.valueWeightedWithHash(T, &.{.rangeLessThan(T, at_least, less_than, 1)}, hash);
 }
 
+/// It is asserted `len` is nonzero.
+/// It is asserted `len` fits within 64 bits.
+pub fn indexWithHash(s: *Smith, len: usize, hash: u32) usize {
+    @disableInstrumentation();
+    assert(len != 0);
+    return @intCast(s.valueWeightedWithHash(u64, &.{.rangeLessThan(u64, 0, @intCast(len), 1)}, hash));
+}
+
+/// It is asserted that the weight of `false` is non-zero.
+/// It is asserted that the weight of `true` is non-zero.
+pub fn boolWeightedWithHash(s: *Smith, false_weight: u64, true_weight: u64, hash: u32) bool {
+    @disableInstrumentation();
+    return s.valueWeightedWithHash(bool, &.{
+        .value(bool, false, false_weight),
+        .value(bool, true, true_weight),
+    }, hash);
+}
+
 /// This is similar to `value(bool)` however it is gauraunteed to eventually
 /// return `true` and provides the fuzzer with an extra hint about the data.
 pub fn eosWithHash(s: *Smith, hash: u32) bool {
@@ -504,8 +541,6 @@ pub fn eosWeightedWithHash(s: *Smith, weights: []const Weight, hash: u32) bool {
 ///
 /// It is asserted that the weight of `false` is non-zero.
 /// It is asserted that the weight of `true` is non-zero.
-//
-// `noinline` to capture a unique return address
 pub fn eosWeightedSimpleWithHash(s: *Smith, false_weight: u64, true_weight: u64, hash: u32) bool {
     @disableInstrumentation();
     return s.eosWeightedWithHash(&.{