@zigc/lib 0.16.0-test.0 → 0.16.0

package/std/math/big/int.zig

@@ -628,12 +628,12 @@ pub const Mutable = struct {
 
         // Slice of the upper bits if they exist, these will be ignored and allows us to use addCarry to determine
         // if an overflow occurred.
-        const x = Const{
+        const x: Const = .{
             .positive = a.positive,
             .limbs = a.limbs[0..@min(req_limbs, a.limbs.len)],
         };
 
-        const y = Const{
+        const y: Const = .{
             .positive = b.positive,
             .limbs = b.limbs[0..@min(req_limbs, b.limbs.len)],
         };
@@ -647,9 +647,8 @@ pub const Mutable = struct {
             //   Note: after this we still might need to wrap.
             const msl = @max(a.limbs.len, b.limbs.len);
             if (msl < req_limbs) {
+                r.len = msl + 1;
                 r.limbs[msl] = 1;
-                r.len = req_limbs;
-                @memset(r.limbs[msl + 1 .. req_limbs], 0);
             } else {
                 carry_truncated = true;
             }
@@ -673,12 +672,12 @@ pub const Mutable = struct {
 
         // Slice of the upper bits if they exist, these will be ignored and allows us to use addCarry to determine
         // if an overflow occurred.
-        const x = Const{
+        const x: Const = .{
             .positive = a.positive,
             .limbs = a.limbs[0..@min(req_limbs, a.limbs.len)],
         };
 
-        const y = Const{
+        const y: Const = .{
             .positive = b.positive,
             .limbs = b.limbs[0..@min(req_limbs, b.limbs.len)],
         };
@@ -690,12 +689,12 @@ pub const Mutable = struct {
             //   Note: In this case, might _also_ need to saturate.
             const msl = @max(a.limbs.len, b.limbs.len);
             if (msl < req_limbs) {
+                r.len = msl + 1;
                 r.limbs[msl] = 1;
-                r.len = req_limbs;
                 // Note: Saturation may still be required if msl == req_limbs - 1
             } else {
                 // Overflowed req_limbs, definitely saturate.
-                r.setTwosCompIntLimit(if (r.positive) .max else .min, signedness, bit_count);
+                return r.setTwosCompIntLimit(if (r.positive) .max else .min, signedness, bit_count);
             }
         }
 
@@ -1374,7 +1373,7 @@ pub const Mutable = struct {
     /// r is `calcTwosCompLimbCount(bit_count)`.
     pub fn bitNotWrap(r: *Mutable, a: Const, signedness: Signedness, bit_count: usize) void {
         r.copy(a.negate());
-        const negative_one = Const{ .limbs = &.{1}, .positive = false };
+        const negative_one: Const = .{ .limbs = &.{1}, .positive = false };
         _ = r.addWrap(r.toConst(), negative_one, signedness, bit_count);
     }
 
@@ -1740,13 +1739,13 @@ pub const Mutable = struct {
             r.positive = r_positive;
         } else {
             // Shrink x, y such that the trailing zero limbs shared between are removed.
-            var x0 = Mutable{
+            var x0: Mutable = .{
                 .limbs = x.limbs[xy_trailing..],
                 .len = x.len - xy_trailing,
                 .positive = true,
             };
 
-            var y0 = Mutable{
+            var y0: Mutable = .{
                 .limbs = y.limbs[xy_trailing..],
                 .len = y.len - xy_trailing,
                 .positive = true,
@@ -1809,7 +1808,7 @@ pub const Mutable = struct {
             // x >= y * b^(n - t) can be replaced by x/b^(n - t) >= y.
 
             // 'divide' x by b^(n - t)
-            var tmp = Mutable{
+            var tmp: Mutable = .{
                 .limbs = x.limbs[shift..],
                 .len = x.len - shift,
                 .positive = true,
@@ -2108,7 +2107,7 @@ pub const Const = struct {
     pub fn toManaged(self: Const, allocator: Allocator) Allocator.Error!Managed {
         const limbs = try allocator.alloc(Limb, @max(Managed.default_capacity, self.limbs.len));
         @memcpy(limbs[0..self.limbs.len], self.limbs);
-        return Managed{
+        return .{
             .allocator = allocator,
             .limbs = limbs,
             .metadata = if (self.positive)
@@ -2802,7 +2801,7 @@ pub const Managed = struct {
     /// default capacity will be used instead.
     /// The integer value after initializing is `0`.
     pub fn initCapacity(allocator: Allocator, capacity: usize) !Managed {
-        return Managed{
+        return .{
             .allocator = allocator,
             .metadata = 1,
             .limbs = block: {
@@ -2868,7 +2867,7 @@ pub const Managed = struct {
     }
 
     pub fn cloneWithDifferentAllocator(other: Managed, allocator: Allocator) !Managed {
-        return Managed{
+        return .{
             .allocator = allocator,
             .metadata = other.metadata,
             .limbs = block: {
@@ -3454,7 +3453,7 @@ pub const Managed = struct {
             const tmp = try rma.allocator.alloc(Limb, a_len);
             defer rma.allocator.free(tmp);
             @memcpy(tmp[0..a_len], a.limbs[0..a_len]);
-            const a_const = Const{ .limbs = tmp[0..a_len], .positive = a.isPositive() };
+            const a_const: Const = .{ .limbs = tmp[0..a_len], .positive = a.isPositive() };
             var rma_mut = rma.toMutable();
             rma_mut.sqrNoAlias(a_const, rma.allocator);
             rma.setMetadata(rma_mut.positive, rma_mut.len);
@@ -3479,7 +3478,7 @@ pub const Managed = struct {
             const tmp = try rma.allocator.alloc(Limb, a_len);
             defer rma.allocator.free(tmp);
             @memcpy(tmp[0..a_len], a.limbs[0..a_len]);
-            const a_const = Const{ .limbs = tmp[0..a_len], .positive = a.isPositive() };
+            const a_const: Const = .{ .limbs = tmp[0..a_len], .positive = a.isPositive() };
             var rma_mut = rma.toMutable();
             rma_mut.pow(a_const, b, limbs_buffer);
             rma.setMetadata(rma_mut.positive, rma_mut.len);

package/std/mem/Allocator.zig

@@ -322,7 +322,7 @@ pub fn resize(self: Allocator, allocation: anytype, new_len: usize) bool {
     if (allocation.len == 0) {
         return false;
     }
-    const old_memory = mem.sliceAsBytes(allocation);
+    const old_memory: []u8 = @ptrCast(@constCast(mem.absorbSentinel(allocation)));
     // I would like to use saturating multiplication here, but LLVM cannot lower it
     // on WebAssembly: https://github.com/ziglang/zig/issues/9660
     //const new_len_bytes = new_len *| @sizeOf(T);
@@ -368,7 +368,7 @@ pub fn remap(self: Allocator, allocation: anytype, new_len: usize) ?@TypeOf(allo
         new_memory.len = new_len;
         return new_memory;
     }
-    const old_memory = mem.sliceAsBytes(allocation);
+    const old_memory: []u8 = @ptrCast(@constCast(mem.absorbSentinel(allocation)));
     // I would like to use saturating multiplication here, but LLVM cannot lower it
     // on WebAssembly: https://github.com/ziglang/zig/issues/9660
     //const new_len_bytes = new_len *| @sizeOf(T);
@@ -420,7 +420,7 @@ pub fn reallocAdvanced(
         return ptr;
     }
 
-    const old_byte_slice = mem.sliceAsBytes(old_mem);
+    const old_byte_slice: []u8 = @ptrCast(@constCast(mem.absorbSentinel(old_mem)));
     const byte_count = math.mul(usize, @sizeOf(T), new_n) catch return error.OutOfMemory;
     // Note: can't set shrunk memory to undefined as memory shouldn't be modified on realloc failure
     if (self.rawRemap(old_byte_slice, .fromByteUnits(slice_info.alignment orelse @alignOf(T)), byte_count, return_address)) |p| {
@@ -443,8 +443,7 @@ pub fn reallocAdvanced(
 pub fn free(self: Allocator, memory: anytype) void {
     const slice_info = @typeInfo(@TypeOf(memory)).pointer;
     comptime assert(slice_info.size == .slice);
-    const mem_with_sent = memory[0 .. memory.len + @intFromBool(slice_info.sentinel() != null)];
-    const bytes: []u8 = @ptrCast(@constCast(mem_with_sent));
+    const bytes: []u8 = @ptrCast(@constCast(mem.absorbSentinel(memory)));
     if (bytes.len == 0) return;
     @memset(bytes, undefined);
     self.rawFree(bytes, .fromByteUnits(slice_info.alignment orelse @alignOf(slice_info.child)), @returnAddress());

package/std/mem.zig

@@ -4709,6 +4709,54 @@ test "sliceAsBytes preserves pointer attributes" {
     try testing.expectEqual(in.alignment, out.alignment);
 }
 
+fn AbsorbSentinelReturnType(comptime Slice: type) type {
+    const info = @typeInfo(Slice).pointer;
+    assert(info.size == .slice);
+    return @Pointer(.slice, .{
+        .@"const" = info.is_const,
+        .@"volatile" = info.is_volatile,
+        .@"allowzero" = info.is_allowzero,
+        .@"addrspace" = info.address_space,
+        .@"align" = info.alignment,
+    }, info.child, null);
+}
+
+/// If the provided slice is not sentinel terminated, do nothing and return that slice.
+/// If it is sentinel-terminated, return a non-sentinel-terminated slice with the
+/// length increased by one to include the absorbed sentinel element.
+pub fn absorbSentinel(slice: anytype) AbsorbSentinelReturnType(@TypeOf(slice)) {
+    const info = @typeInfo(@TypeOf(slice)).pointer;
+    comptime assert(info.size == .slice);
+    if (info.sentinel_ptr == null) {
+        return slice;
+    } else {
+        return slice.ptr[0 .. slice.len + 1];
+    }
+}
+
+test absorbSentinel {
+    {
+        var buffer: [3:0]u8 = .{ 1, 2, 3 };
+        const foo: [:0]const u8 = &buffer;
+        const bar: []const u8 = &buffer;
+        try testing.expectEqual([]const u8, @TypeOf(absorbSentinel(foo)));
+        try testing.expectEqual([]const u8, @TypeOf(absorbSentinel(bar)));
+        try testing.expectEqualSlices(u8, &.{ 1, 2, 3, 0 }, absorbSentinel(foo));
+        try testing.expectEqualSlices(u8, &.{ 1, 2, 3 }, absorbSentinel(bar));
+    }
+    {
+        var buffer: [3:0]u8 = .{ 1, 2, 3 };
+        const foo: [:0]u8 = &buffer;
+        const bar: []u8 = &buffer;
+        try testing.expectEqual([]u8, @TypeOf(absorbSentinel(foo)));
+        try testing.expectEqual([]u8, @TypeOf(absorbSentinel(bar)));
+        var expected_foo = [_]u8{ 1, 2, 3, 0 };
+        try testing.expectEqualSlices(u8, &expected_foo, absorbSentinel(foo));
+        var expected_bar = [_]u8{ 1, 2, 3 };
+        try testing.expectEqualSlices(u8, &expected_bar, absorbSentinel(bar));
+    }
+}
+
 /// Round an address down to the next (or current) aligned address.
 /// Unlike `alignForward`, `alignment` can be any positive number, not just a power of 2.
 pub fn alignForwardAnyAlign(comptime T: type, addr: T, alignment: T) T {

package/std/os/emscripten.zig

@@ -11,22 +11,6 @@ const c = std.c;
 
 pub const FILE = c.FILE;
 
-var __stack_chk_guard: usize = 0;
-fn __stack_chk_fail() callconv(.c) void {
-    std.debug.print("stack smashing detected: terminated\n", .{});
-    emscripten_force_exit(127);
-}
-
-comptime {
-    if (builtin.os.tag == .emscripten) {
-        if (builtin.mode == .Debug or builtin.mode == .ReleaseSafe) {
-            // Emscripten does not provide these symbols, so we must export our own
-            @export(&__stack_chk_guard, .{ .name = "__stack_chk_guard", .linkage = .strong });
-            @export(&__stack_chk_fail, .{ .name = "__stack_chk_fail", .linkage = .strong });
-        }
-    }
-}
-
 pub const PF = linux.PF;
 pub const AF = linux.AF;
 pub const CLOCK = linux.CLOCK;
@@ -228,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

@@ -1584,6 +1584,11 @@ pub fn clone2(flags: u32, child_stack_ptr: usize) usize {
     return syscall2(.clone, flags, child_stack_ptr);
 }
 
+/// This call cannot fail, and the return value is the caller's thread id
+pub fn set_tid_address(tidptr: ?*pid_t) pid_t {
+    return @intCast(@as(u32, @truncate(syscall1(.set_tid_address, @intFromPtr(tidptr)))));
+}
+
 pub fn close(fd: fd_t) usize {
     return syscall1(.close, @as(usize, @bitCast(@as(isize, fd))));
 }
@@ -3878,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/os/windows.zig

@@ -3952,7 +3952,7 @@ inline fn MAKELANGID(p: c_ushort, s: c_ushort) LANGID {
 /// and you get an unexpected error.
 pub fn unexpectedError(err: Win32Error) UnexpectedError {
     @branchHint(.cold);
-    if (std.posix.unexpected_error_tracing) {
+    if (std.options.unexpected_error_tracing) {
         std.debug.print("error.Unexpected: GetLastError({d}): {t}\n", .{ err, err });
         std.debug.dumpCurrentStackTrace(.{ .first_address = @returnAddress() });
     }
@@ -3962,7 +3962,7 @@ pub fn unexpectedError(err: Win32Error) UnexpectedError {
 /// Call this when you made a windows NtDll call
 /// and you get an unexpected status.
 pub fn unexpectedStatus(status: NTSTATUS) UnexpectedError {
-    if (std.posix.unexpected_error_tracing) {
+    if (std.options.unexpected_error_tracing) {
         std.debug.print("error.Unexpected NTSTATUS=0x{x} ({s})\n", .{
             @intFromEnum(status),
             std.enums.tagName(NTSTATUS, status) orelse "<unnamed>",

package/std/pdb.zig

@@ -314,11 +314,9 @@ pub const SymbolKind = enum(u16) {
 
 pub const TypeIndex = u32;
 
-// TODO According to this header:
-// https://github.com/microsoft/microsoft-pdb/blob/082c5290e5aff028ae84e43affa8be717aa7af73/include/cvinfo.h#L3722
-// we should define RecordPrefix as part of the ProcSym structure.
-// This might be important when we start generating PDB in self-hosted with our own PE linker.
 pub const ProcSym = extern struct {
+    record_len: u16,
+    record_kind: SymbolKind,
     parent: u32,
     end: u32,
     next: u32,
@@ -508,3 +506,144 @@ pub const SuperBlock = extern struct {
     // implement it so we're kind of safe making this assumption for now.
     block_map_addr: u32,
 };
+
+pub const IpiStreamVersion = enum(u32) {
+    v40 = 19950410,
+    v41 = 19951122,
+    v50 = 19961031,
+    v70 = 19990903,
+    v80 = 20040203,
+    _,
+};
+
+pub const IpiStreamHeader = extern struct {
+    version: IpiStreamVersion,
+    header_size: u32,
+    type_index_begin: u32,
+    type_index_end: u32,
+    type_record_bytes: u32,
+    hash_stream_index: u16,
+    hash_aux_stream_index: u16,
+    hash_key_size: u32,
+    num_hash_buckets: u32,
+    hash_value_buffer_offset: i32,
+    hash_value_buffer_length: u32,
+    index_offset_buffer_offset: i32,
+    index_offset_buffer_length: u32,
+    hash_adj_buffer_offset: i32,
+    hash_adj_buffer_length: u32,
+};
+
+pub const LfRecordPrefix = extern struct {
+    len: u16,
+    kind: LfRecordKind,
+};
+
+pub const LfRecordKind = enum(u16) {
+    pointer = 0x1002,
+    modifier = 0x1001,
+    procedure = 0x1008,
+    mfunction = 0x1009,
+    label = 0x000e,
+    arglist = 0x1201,
+    fieldlist = 0x1203,
+    array = 0x1503,
+    class = 0x1504,
+    structure = 0x1505,
+    interface = 0x1519,
+    @"union" = 0x1506,
+    @"enum" = 0x1507,
+    typeserver2 = 0x1515,
+    vftable = 0x151d,
+    vtshape = 0x000a,
+    bitfield = 0x1205,
+    func_id = 0x1601,
+    mfunc_id = 0x1602,
+    buildinfo = 0x1603,
+    substr_list = 0x1604,
+    string_id = 0x1605,
+    udt_src_line = 0x1606,
+    udt_mod_src_line = 0x1607,
+    methodlist = 0x1206,
+    precomp = 0x1509,
+    endprecomp = 0x0014,
+    bclass = 0x1400,
+    binterface = 0x151a,
+    vbclass = 0x1401,
+    ivbclass = 0x1402,
+    vfunctab = 0x1409,
+    stmember = 0x150e,
+    method = 0x150f,
+    member = 0x150d,
+    nesttype = 0x1510,
+    onemethod = 0x1511,
+    enumerate = 0x1502,
+    index = 0x1404,
+    pad0 = 0xf0,
+    _,
+};
+
+pub const LfFuncId = extern struct {
+    len: u16,
+    kind: LfRecordKind,
+    scope_id: u32,
+    type: u32,
+    name: [1]u8, // null-terminated
+};
+
+pub const LfMFuncId = extern struct {
+    len: u16,
+    kind: LfRecordKind,
+    parent_type: u32,
+    type: u32,
+    name: [1]u8, // null-terminated
+};
+
+pub const InlineSiteSym = extern struct {
+    record_len: u16,
+    record_kind: SymbolKind,
+    parent: u32,
+    end: u32,
+    inlinee: u32,
+};
+
+pub const InlineSiteSym2 = extern struct {
+    record_len: u16,
+    record_kind: SymbolKind,
+    parent: u32,
+    end: u32,
+    inlinee: u32,
+    invocations: u32,
+};
+
+pub const InlineeSourceLineSignature = enum(u32) { normal = 0, ex = 1, _ };
+
+pub const InlineeSourceLine = extern struct {
+    inlinee: u32,
+    file_id: u32,
+    source_line_num: u32,
+};
+
+pub const InlineeSourceLineEx = extern struct {
+    inlinee: u32,
+    file_id: u32,
+    source_line_num: u32,
+    count_of_extra_files: u32,
+};
+
+pub const BinaryAnnotationOpcode = enum(u8) {
+    invalid = 0,
+    code_offset = 1,
+    change_code_offset_base = 2,
+    change_code_offset = 3,
+    change_code_length = 4,
+    change_file = 5,
+    change_line_offset = 6,
+    change_line_end_delta = 7,
+    change_range_kind = 8,
+    change_column_start = 9,
+    change_column_end_delta = 10,
+    change_code_offset_and_line_offset = 11,
+    change_code_length_and_code_offset = 12,
+    change_column_end = 13,
+};

package/std/posix.zig

@@ -513,6 +513,9 @@ pub const GetSockNameError = error{
     SocketNotBound,
 
     FileDescriptorNotASocket,
+
+    /// The socket is not connected (connection-oriented sockets only).
+    SocketUnconnected,
 } || UnexpectedError;
 
 pub fn getpeername(sock: socket_t, addr: *sockaddr, addrlen: *socklen_t) GetSockNameError!void {
@@ -529,6 +532,7 @@ pub fn getpeername(sock: socket_t, addr: *sockaddr, addrlen: *socklen_t) GetSock
             .INVAL => unreachable, // invalid parameters
             .NOTSOCK => return error.FileDescriptorNotASocket,
             .NOBUFS => return error.SystemResources,
+            .NOTCONN => return error.SocketUnconnected,
         }
     }
 }
@@ -682,7 +686,7 @@ pub fn munmap(memory: []align(page_size_min) const u8) void {
         .SUCCESS => return,
         .INVAL => unreachable, // Invalid parameters.
         .NOMEM => unreachable, // Attempted to unmap a region in the middle of an existing mapping.
-        else => |e| if (unexpected_error_tracing) {
+        else => |e| if (std.options.unexpected_error_tracing) {
             std.debug.panic("unexpected errno: {d} ({t})", .{ @intFromEnum(e), e });
         } else unreachable,
     }
@@ -1658,22 +1662,12 @@ pub fn name_to_handle_atZ(
 
 pub const lfs64_abi = native_os == .linux and builtin.link_libc and (builtin.abi.isGnu() or builtin.abi.isAndroid());
 
-/// 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.
-pub const unexpected_error_tracing = builtin.mode == .Debug and switch (builtin.zig_backend) {
-    .stage2_llvm, .stage2_x86_64 => true,
-    else => false,
-};
-
 pub const UnexpectedError = std.Io.UnexpectedError;
 
 /// Call this when you made a syscall or something that sets errno
 /// and you get an unexpected error.
 pub fn unexpectedErrno(err: E) UnexpectedError {
-    if (unexpected_error_tracing) {
+    if (std.options.unexpected_error_tracing) {
         std.debug.print("unexpected errno: {d}\n", .{@intFromEnum(err)});
         std.debug.dumpCurrentStackTrace(.{});
     }

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,
     },