@zigc/lib 0.16.0-test.1 → 0.16.0

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(&.{