@zigc/lib 0.17.0-dev.269 → 0.17.0-dev.292

package/std/math/nextafter.zig

@@ -90,7 +90,7 @@ fn nextAfterFloat(comptime T: type, x: T, y: T) T {
 
         return x_parts.toFloat();
     } else {
-        const Bits = std.meta.Int(.unsigned, @bitSizeOf(T));
+        const Bits = @Int(.unsigned, @bitSizeOf(T));
         var x_bits: Bits = @bitCast(x);
         if ((x > 0.0) == (y > x)) {
             x_bits += 1;
@@ -320,6 +320,6 @@ test "float" {
 /// Helps ensure that 0.0 doesn't compare equal to -0.0.
 fn bitwiseEqual(comptime T: type, x: T, y: T) bool {
     comptime assert(@typeInfo(T) == .float);
-    const Bits = std.meta.Int(.unsigned, @bitSizeOf(T));
+    const Bits = @Int(.unsigned, @bitSizeOf(T));
     return @as(Bits, @bitCast(x)) == @as(Bits, @bitCast(y));
 }

package/std/math/pow.zig

@@ -147,7 +147,7 @@ pub fn pow(comptime T: type, x: T, y: T) T {
     var xe = r2.exponent;
     var x1 = r2.significand;
 
-    var i = @as(std.meta.Int(.signed, @typeInfo(T).float.bits), @intFromFloat(yi));
+    var i = @as(@Int(.signed, @typeInfo(T).float.bits), @intFromFloat(yi));
     while (i != 0) : (i >>= 1) {
         const overflow_shift = math.floatExponentBits(T) + 1;
         if (xe < -(1 << overflow_shift) or (1 << overflow_shift) < xe) {

package/std/math.zig

@@ -779,7 +779,7 @@ pub fn Log2Int(comptime T: type) type {
     if (T == comptime_int) return comptime_int;
     const bits: u16 = @typeInfo(T).int.bits;
     const log2_bits = 16 - @clz(bits - 1);
-    return std.meta.Int(.unsigned, log2_bits);
+    return @Int(.unsigned, log2_bits);
 }
 
 /// Returns an unsigned int type that can hold the number of bits in T.
@@ -788,7 +788,7 @@ pub fn Log2IntCeil(comptime T: type) type {
     if (T == comptime_int) return comptime_int;
     const bits: u16 = @typeInfo(T).int.bits;
     const log2_bits = 16 - @clz(bits);
-    return std.meta.Int(.unsigned, log2_bits);
+    return @Int(.unsigned, log2_bits);
 }
 
 /// Returns the smallest integer type that can hold both from and to.
@@ -1048,10 +1048,10 @@ fn testRem() !void {
 
 /// Returns the negation of the integer parameter.
 /// Result is a signed integer.
-pub fn negateCast(x: anytype) !std.meta.Int(.signed, @bitSizeOf(@TypeOf(x))) {
+pub fn negateCast(x: anytype) !@Int(.signed, @bitSizeOf(@TypeOf(x))) {
     if (@typeInfo(@TypeOf(x)).int.signedness == .signed) return negate(x);
 
-    const int = std.meta.Int(.signed, @bitSizeOf(@TypeOf(x)));
+    const int = @Int(.signed, @bitSizeOf(@TypeOf(x)));
     if (x > -minInt(int)) return error.Overflow;
 
     if (x == -minInt(int)) return minInt(int);
@@ -1177,7 +1177,7 @@ pub inline fn floor(value: anytype) @TypeOf(value) {
 /// Returns the nearest power of two less than or equal to value, or
 /// zero if value is less than or equal to zero.
 pub fn floorPowerOfTwo(comptime T: type, value: T) T {
-    const uT = std.meta.Int(.unsigned, @typeInfo(T).int.bits);
+    const uT = @Int(.unsigned, @typeInfo(T).int.bits);
     if (value <= 0) return 0;
     return @as(T, 1) << log2_int(uT, @as(uT, @intCast(value)));
 }
@@ -1212,7 +1212,7 @@ pub inline fn ceil(value: anytype) @TypeOf(value) {
 /// Returns the next power of two (if the value is not already a power of two).
 /// Only unsigned integers can be used. Zero is not an allowed input.
 /// Result is a type with 1 more bit than the input type.
-pub fn ceilPowerOfTwoPromote(comptime T: type, value: T) std.meta.Int(@typeInfo(T).int.signedness, @typeInfo(T).int.bits + 1) {
+pub fn ceilPowerOfTwoPromote(comptime T: type, value: T) @Int(@typeInfo(T).int.signedness, @typeInfo(T).int.bits + 1) {
     comptime assert(@typeInfo(T) == .int);
     comptime assert(@typeInfo(T).int.signedness == .unsigned);
     assert(value != 0);
@@ -1497,11 +1497,11 @@ test "max value type" {
 
 /// Multiply a and b. Return type is wide enough to guarantee no
 /// overflow.
-pub fn mulWide(comptime T: type, a: T, b: T) std.meta.Int(
+pub fn mulWide(comptime T: type, a: T, b: T) @Int(
     @typeInfo(T).int.signedness,
     @typeInfo(T).int.bits * 2,
 ) {
-    const ResultInt = std.meta.Int(
+    const ResultInt = @Int(
         @typeInfo(T).int.signedness,
         @typeInfo(T).int.bits * 2,
     );

package/std/mem/Allocator.zig

@@ -456,12 +456,6 @@ pub fn dupe(allocator: Allocator, comptime T: type, m: []const T) Error![]T {
     return new_buf;
 }
 
-/// Deprecated in favor of `dupeSentinel`
-/// Copies `m` to newly allocated memory, with a null-terminated element. Caller owns the memory.
-pub fn dupeZ(allocator: Allocator, comptime T: type, m: []const T) Error![:0]T {
-    return allocator.dupeSentinel(T, m, 0);
-}
-
 /// Copies `m` to newly allocated memory, with a null-terminated element. Caller owns the memory.
 pub fn dupeSentinel(
     allocator: Allocator,

package/std/mem.zig

@@ -1777,7 +1777,7 @@ pub fn readVarInt(comptime ReturnType: type, bytes: []const u8, endian: Endian)
     assert(@typeInfo(ReturnType).int.bits >= bytes.len * 8);
     const bits = @typeInfo(ReturnType).int.bits;
     const signedness = @typeInfo(ReturnType).int.signedness;
-    const WorkType = std.meta.Int(signedness, @max(16, bits));
+    const WorkType = @Int(signedness, @max(16, bits));
     var result: WorkType = 0;
     switch (endian) {
         .big => {
@@ -1828,8 +1828,8 @@ pub fn readVarPackedInt(
     endian: std.builtin.Endian,
     signedness: std.builtin.Signedness,
 ) T {
-    const uN = std.meta.Int(.unsigned, @bitSizeOf(T));
-    const iN = std.meta.Int(.signed, @bitSizeOf(T));
+    const uN = @Int(.unsigned, @bitSizeOf(T));
+    const iN = @Int(.signed, @bitSizeOf(T));
     const Log2N = std.math.Log2Int(T);
 
     const read_size = (bit_count + (bit_offset % 8) + 7) / 8;
@@ -1921,7 +1921,7 @@ test readInt {
 }
 
 fn readPackedIntLittle(comptime T: type, bytes: []const u8, bit_offset: usize) T {
-    const uN = std.meta.Int(.unsigned, @bitSizeOf(T));
+    const uN = @Int(.unsigned, @bitSizeOf(T));
     const Log2N = std.math.Log2Int(T);
 
     const bit_count = @as(usize, @bitSizeOf(T));
@@ -1929,7 +1929,7 @@ fn readPackedIntLittle(comptime T: type, bytes: []const u8, bit_offset: usize) T
 
     const load_size = (bit_count + 7) / 8;
     const load_tail_bits = @as(u3, @intCast((load_size * 8) - bit_count));
-    const LoadInt = std.meta.Int(.unsigned, load_size * 8);
+    const LoadInt = @Int(.unsigned, load_size * 8);
 
     if (bit_count == 0)
         return 0;
@@ -1947,7 +1947,7 @@ fn readPackedIntLittle(comptime T: type, bytes: []const u8, bit_offset: usize) T
 }
 
 fn readPackedIntBig(comptime T: type, bytes: []const u8, bit_offset: usize) T {
-    const uN = std.meta.Int(.unsigned, @bitSizeOf(T));
+    const uN = @Int(.unsigned, @bitSizeOf(T));
     const Log2N = std.math.Log2Int(T);
 
     const bit_count = @as(usize, @bitSizeOf(T));
@@ -1956,7 +1956,7 @@ fn readPackedIntBig(comptime T: type, bytes: []const u8, bit_offset: usize) T {
 
     const load_size = (bit_count + 7) / 8;
     const load_tail_bits = @as(u3, @intCast((load_size * 8) - bit_count));
-    const LoadInt = std.meta.Int(.unsigned, load_size * 8);
+    const LoadInt = @Int(.unsigned, load_size * 8);
 
     if (bit_count == 0)
         return 0;
@@ -2061,7 +2061,7 @@ test writeInt {
 }
 
 fn writePackedIntLittle(comptime T: type, bytes: []u8, bit_offset: usize, value: T) void {
-    const uN = std.meta.Int(.unsigned, @bitSizeOf(T));
+    const uN = @Int(.unsigned, @bitSizeOf(T));
     const Log2N = std.math.Log2Int(T);
 
     const bit_count = @as(usize, @bitSizeOf(T));
@@ -2069,7 +2069,7 @@ fn writePackedIntLittle(comptime T: type, bytes: []u8, bit_offset: usize, value:
 
     const store_size = (@bitSizeOf(T) + 7) / 8;
     const store_tail_bits = @as(u3, @intCast((store_size * 8) - bit_count));
-    const StoreInt = std.meta.Int(.unsigned, store_size * 8);
+    const StoreInt = @Int(.unsigned, store_size * 8);
 
     if (bit_count == 0)
         return;
@@ -2094,7 +2094,7 @@ fn writePackedIntLittle(comptime T: type, bytes: []u8, bit_offset: usize, value:
 }
 
 fn writePackedIntBig(comptime T: type, bytes: []u8, bit_offset: usize, value: T) void {
-    const uN = std.meta.Int(.unsigned, @bitSizeOf(T));
+    const uN = @Int(.unsigned, @bitSizeOf(T));
     const Log2N = std.math.Log2Int(T);
 
     const bit_count = @as(usize, @bitSizeOf(T));
@@ -2103,7 +2103,7 @@ fn writePackedIntBig(comptime T: type, bytes: []u8, bit_offset: usize, value: T)
 
     const store_size = (@bitSizeOf(T) + 7) / 8;
     const store_tail_bits = @as(u3, @intCast((store_size * 8) - bit_count));
-    const StoreInt = std.meta.Int(.unsigned, store_size * 8);
+    const StoreInt = @Int(.unsigned, store_size * 8);
 
     if (bit_count == 0)
         return;
@@ -2160,7 +2160,7 @@ test writePackedInt {
 /// If negative, the written value is sign-extended.
 pub fn writeVarPackedInt(bytes: []u8, bit_offset: usize, bit_count: usize, value: anytype, endian: std.builtin.Endian) void {
     const T = @TypeOf(value);
-    const uN = std.meta.Int(.unsigned, @bitSizeOf(T));
+    const uN = @Int(.unsigned, @bitSizeOf(T));
 
     const bit_shift = @as(u3, @intCast(bit_offset % 8));
     const write_size = (bit_count + bit_shift + 7) / 8;
@@ -2242,7 +2242,7 @@ pub fn byteSwapAllFieldsAligned(comptime S: type, comptime a: Alignment, ptr: *a
                     },
                     .bool => {},
                     .float => |float_info| {
-                        @field(ptr, f.name) = @bitCast(@byteSwap(@as(std.meta.Int(.unsigned, float_info.bits), @bitCast(@field(ptr, f.name)))));
+                        @field(ptr, f.name) = @bitCast(@byteSwap(@as(@Int(.unsigned, float_info.bits), @bitCast(@field(ptr, f.name)))));
                     },
                     else => {
                         @field(ptr, f.name) = @byteSwap(@field(ptr, f.name));
@@ -2262,7 +2262,7 @@ pub fn byteSwapAllFieldsAligned(comptime S: type, comptime a: Alignment, ptr: *a
                 }
             }
 
-            const BackingInt = std.meta.Int(.unsigned, @bitSizeOf(S));
+            const BackingInt = @Int(.unsigned, @bitSizeOf(S));
             ptr.* = @bitCast(@byteSwap(@as(BackingInt, @bitCast(ptr.*))));
         },
         .array => |info| {
@@ -2370,7 +2370,7 @@ pub fn byteSwapAllElements(comptime Elem: type, slice: []Elem) void {
             },
             .bool => {},
             .float => |float_info| {
-                elem.* = @bitCast(@byteSwap(@as(std.meta.Int(.unsigned, float_info.bits), @bitCast(elem.*))));
+                elem.* = @bitCast(@byteSwap(@as(@Int(.unsigned, float_info.bits), @bitCast(elem.*))));
             },
             else => {
                 elem.* = @byteSwap(elem.*);
@@ -4800,7 +4800,7 @@ pub fn doNotOptimizeAway(val: anytype) void {
             const bits = t.int.bits;
             if (bits <= max_gp_register_bits and builtin.zig_backend != .stage2_c) {
                 const val2 = @as(
-                    std.meta.Int(t.int.signedness, @max(8, std.math.ceilPowerOfTwoAssert(u16, bits))),
+                    @Int(t.int.signedness, @max(8, std.math.ceilPowerOfTwoAssert(u16, bits))),
                     val,
                 );
                 asm volatile (""
@@ -4964,7 +4964,7 @@ test isAligned {
 }
 
 test "freeing empty string with null-terminated sentinel" {
-    const empty_string = try testing.allocator.dupeZ(u8, "");
+    const empty_string = try testing.allocator.dupeSentinel(u8, "", 0);
     testing.allocator.free(empty_string);
 }
 
@@ -5035,8 +5035,8 @@ test "read/write(Var)PackedInt" {
                 if (@bitSizeOf(PackedType) > @bitSizeOf(BackingType))
                     continue;
 
-                const iPackedType = std.meta.Int(.signed, @bitSizeOf(PackedType));
-                const uPackedType = std.meta.Int(.unsigned, @bitSizeOf(PackedType));
+                const iPackedType = @Int(.signed, @bitSizeOf(PackedType));
+                const uPackedType = @Int(.unsigned, @bitSizeOf(PackedType));
                 const Log2T = std.math.Log2Int(BackingType);
 
                 const offset_at_end = @bitSizeOf(BackingType) - @bitSizeOf(PackedType);
@@ -5103,8 +5103,8 @@ test "read/write(Var)PackedInt" {
                         }
 
                         const signedness = @typeInfo(PackedType).int.signedness;
-                        const NextPowerOfTwoInt = std.meta.Int(signedness, try comptime std.math.ceilPowerOfTwo(u16, @bitSizeOf(PackedType)));
-                        const ui64 = std.meta.Int(signedness, 64);
+                        const NextPowerOfTwoInt = @Int(signedness, try std.math.ceilPowerOfTwo(u16, @bitSizeOf(PackedType)));
+                        const ui64 = @Int(signedness, 64);
                         inline for ([_]type{ PackedType, NextPowerOfTwoInt, ui64 }) |U| {
                             { // Variable-size Read/Write (Native-endian)
 

package/std/meta/trailer_flags.zig

@@ -13,7 +13,7 @@ pub fn TrailerFlags(comptime Fields: type) type {
     return struct {
         bits: Int,
 
-        pub const Int = meta.Int(.unsigned, bit_count);
+        pub const Int = @Int(.unsigned, bit_count);
         pub const bit_count = @typeInfo(Fields).@"struct".fields.len;
 
         pub const FieldEnum = std.meta.FieldEnum(Fields);

package/std/meta.zig

@@ -751,11 +751,6 @@ pub fn fieldIndex(comptime T: type, comptime name: []const u8) ?comptime_int {
     return null;
 }
 
-/// Deprecated: use @Int
-pub fn Int(comptime signedness: std.builtin.Signedness, comptime bit_count: u16) type {
-    return @Int(signedness, bit_count);
-}
-
 pub fn Float(comptime bit_count: u8) type {
     return switch (bit_count) {
         16 => f16,
@@ -796,14 +791,7 @@ pub fn ArgsTuple(comptime Function: type) type {
         argument_field_list[i] = T;
     }
 
-    return Tuple(&argument_field_list);
-}
-
-/// Deprecated; use `@Tuple` instead.
-///
-/// To be removed after Zig 0.16.0 releases.
-pub fn Tuple(comptime types: []const type) type {
-    return @Tuple(types);
+    return @Tuple(&argument_field_list);
 }
 
 const TupleTester = struct {
@@ -839,33 +827,13 @@ test ArgsTuple {
     TupleTester.assertTuple(.{u32}, ArgsTuple(fn (comptime a: u32) []const u8));
 }
 
-test Tuple {
-    TupleTester.assertTuple(.{}, Tuple(&[_]type{}));
-    TupleTester.assertTuple(.{u32}, Tuple(&[_]type{u32}));
-    TupleTester.assertTuple(.{ u32, f16 }, Tuple(&[_]type{ u32, f16 }));
-    TupleTester.assertTuple(.{ u32, f16, []const u8, void }, Tuple(&[_]type{ u32, f16, []const u8, void }));
-}
-
-test "Tuple deduplication" {
-    const T1 = std.meta.Tuple(&.{ u32, f32, i8 });
-    const T2 = std.meta.Tuple(&.{ u32, f32, i8 });
-    const T3 = std.meta.Tuple(&.{ u32, f32, i7 });
-
-    if (T1 != T2) {
-        @compileError("std.meta.Tuple doesn't deduplicate tuple types.");
-    }
-    if (T1 == T3) {
-        @compileError("std.meta.Tuple fails to generate different types.");
-    }
-}
-
 test "ArgsTuple forwarding" {
-    const T1 = std.meta.Tuple(&.{ u32, f32, i8 });
+    const T1 = @Tuple(&.{ u32, f32, i8 });
     const T2 = std.meta.ArgsTuple(fn (u32, f32, i8) void);
     const T3 = std.meta.ArgsTuple(fn (u32, f32, i8) callconv(.c) noreturn);
 
     if (T1 != T2) {
-        @compileError("std.meta.ArgsTuple produces different types than std.meta.Tuple");
+        @compileError("std.meta.ArgsTuple produces different types than @Tuple");
     }
     if (T1 != T3) {
         @compileError("std.meta.ArgsTuple produces different types for the same argument lists.");

package/std/os/emscripten.zig

@@ -17,7 +17,7 @@ pub const CLOCK = linux.CLOCK;
 
 pub const CPU_SETSIZE = 128;
 pub const cpu_set_t = [CPU_SETSIZE / @sizeOf(usize)]usize;
-pub const cpu_count_t = std.meta.Int(.unsigned, std.math.log2(CPU_SETSIZE * 8));
+pub const cpu_count_t = @Int(.unsigned, std.math.log2(CPU_SETSIZE * 8));
 
 pub fn CPU_COUNT(set: cpu_set_t) cpu_count_t {
     var sum: cpu_count_t = 0;
@@ -467,8 +467,8 @@ pub const SHUT = struct {
 pub const SIG = linux.SIG;
 
 pub const Sigaction = extern struct {
-    pub const handler_fn = *align(1) const fn (i32) callconv(.c) void;
-    pub const sigaction_fn = *const fn (i32, *const siginfo_t, ?*anyopaque) callconv(.c) void;
+    pub const handler_fn = *align(1) const fn (SIG) callconv(.c) void;
+    pub const sigaction_fn = *const fn (SIG, *const siginfo_t, ?*anyopaque) callconv(.c) void;
 
     handler: extern union {
         handler: ?handler_fn,
@@ -484,7 +484,7 @@ pub fn sigemptyset() sigset_t {
     return @splat(0);
 }
 pub const siginfo_t = extern struct {
-    signo: i32,
+    signo: SIG,
     errno: i32,
     code: i32,
     fields: siginfo_fields_union,

package/std/os/linux/bpf.zig

@@ -58,6 +58,12 @@ pub const JGT = 0x20;
 pub const JGE = 0x30;
 pub const JSET = 0x40;
 
+// misc fields
+/// copy A into X
+pub const TAX = 0x00;
+/// copy X into A
+pub const TXA = 0x80;
+
 //#define BPF_SRC(code)   ((code) & 0x08)
 pub const K = 0x00;
 pub const X = 0x08;

package/std/os/linux/ioctl.zig

@@ -15,12 +15,12 @@ const bits = switch (@import("builtin").cpu.arch) {
     else => .{ .size = 14, .dir = 2, .none = 0, .read = 2, .write = 1 },
 };
 
-const Direction = std.meta.Int(.unsigned, bits.dir);
+const Direction = @Int(.unsigned, bits.dir);
 
 pub const Request = packed struct {
     nr: u8,
     io_type: u8,
-    size: std.meta.Int(.unsigned, bits.size),
+    size: @Int(.unsigned, bits.size),
     dir: Direction,
 };
 

package/std/os/linux.zig

@@ -1256,21 +1256,23 @@ pub fn munlockall() usize {
 }
 
 pub fn poll(fds: [*]pollfd, n: nfds_t, timeout: i32) usize {
-    return if (@hasField(SYS, "poll"))
-        return syscall3(.poll, @intFromPtr(fds), n, @as(u32, @bitCast(timeout)))
-    else
-        ppoll(
+    if (@hasField(SYS, "poll")) {
+        return syscall3(.poll, @intFromPtr(fds), n, @as(u32, @bitCast(timeout)));
+    } else {
+        var ts: timespec = if (timeout >= 0)
+            .{
+                .sec = @divTrunc(timeout, 1000),
+                .nsec = @rem(timeout, 1000) * 1000000,
+            }
+        else
+            undefined;
+        return ppoll(
             fds,
             n,
-            if (timeout >= 0)
-                @constCast(&timespec{
-                    .sec = @divTrunc(timeout, 1000),
-                    .nsec = @rem(timeout, 1000) * 1000000,
-                })
-            else
-                null,
+            if (timeout >= 0) &ts else null,
             null,
         );
+    }
 }
 
 pub fn ppoll(fds: [*]pollfd, n: nfds_t, timeout: ?*timespec, sigmask: ?*const sigset_t) usize {
@@ -6291,7 +6293,7 @@ pub const dl_phdr_info = extern struct {
 
 pub const CPU_SETSIZE = 128;
 pub const cpu_set_t = [CPU_SETSIZE / @sizeOf(usize)]usize;
-pub const cpu_count_t = std.meta.Int(.unsigned, std.math.log2(CPU_SETSIZE * 8));
+pub const cpu_count_t = @Int(.unsigned, std.math.log2(CPU_SETSIZE * 8));
 
 pub fn CPU_COUNT(set: cpu_set_t) cpu_count_t {
     var sum: cpu_count_t = 0;

package/std/os/plan9.zig

@@ -299,7 +299,7 @@ pub fn openat(dirfd: i32, path: [*:0]const u8, flags: u32, _: mode_t) usize {
     const dir_path = std.mem.span(@as([*:0]u8, @ptrCast(&dir_path_buf)));
     const total_path = std.fs.path.join(alloc, &.{ dir_path, std.mem.span(path) }) catch unreachable; // the allocation shouldn't fail because it should not exceed max_path_bytes
     fba.reset();
-    const total_path_z = alloc.dupeZ(u8, total_path) catch unreachable; // should not exceed max_path_bytes + 1
+    const total_path_z = alloc.dupeSentinel(u8, total_path, 0) catch unreachable; // should not exceed max_path_bytes + 1
     return open(total_path_z.ptr, flags);
 }
 

package/std/os/uefi/tables/runtime_services.zig

@@ -419,7 +419,7 @@ pub const RuntimeServices = extern struct {
     pub const DebugDisposition = enum(usize) {
         const Bits = packed struct(usize) {
             optional_ptr: bool = false,
-            _pad: std.meta.Int(.unsigned, @bitSizeOf(usize) - 1) = 0,
+            _pad: @Int(.unsigned, @bitSizeOf(usize) - 1) = 0,
         };
 
         pointer = @bitCast(Bits{}),

package/std/posix.zig

@@ -803,7 +803,7 @@ pub fn dl_iterate_phdr(
             }
         }.callbackC, @ptrCast(@constCast(&context)))) {
             0 => return,
-            else => |err| return @as(Error, @errorCast(@errorFromInt(@as(std.meta.Int(.unsigned, @bitSizeOf(anyerror)), @intCast(err))))),
+            else => |err| return @as(Error, @errorCast(@errorFromInt(@as(@Int(.unsigned, @bitSizeOf(anyerror)), @intCast(err))))),
         }
     }
 

package/std/process/Environ.zig

@@ -754,7 +754,7 @@ pub fn createPosixBlock(
             },
             .nothing => {},
         };
-        envp[envp_len] = try gpa.dupeZ(u8, mem.span(entry));
+        envp[envp_len] = try gpa.dupeSentinel(u8, mem.span(entry), 0);
         envp_len += 1;
     }
 

package/std/process.zig

@@ -86,7 +86,7 @@ pub fn currentPathAlloc(io: Io, allocator: Allocator) CurrentPathAllocError![:0]
         error.NameTooLong => unreachable,
         else => |e| return e,
     };
-    return allocator.dupeZ(u8, buffer[0..n]);
+    return allocator.dupeSentinel(u8, buffer[0..n], 0);
 }
 
 test currentPathAlloc {
@@ -735,7 +735,7 @@ pub fn executablePathAlloc(io: Io, allocator: Allocator) ExecutablePathAllocErro
         error.NameTooLong => unreachable,
         else => |e| return e,
     };
-    return allocator.dupeZ(u8, buffer[0..n]);
+    return allocator.dupeSentinel(u8, buffer[0..n], 0);
 }
 
 pub const ExecutablePathError = ExecutablePathBaseError || error{NameTooLong};

package/std/std.zig

@@ -65,8 +65,11 @@ pub const array_hash_map = @import("array_hash_map.zig");
 pub const atomic = @import("atomic.zig");
 pub const base64 = @import("base64.zig");
 pub const bit_set = @import("bit_set.zig");
+/// Deprecated; use `lang`.
+///
+/// To be removed after Zig 0.17.0.
 pub const builtin = lang;
-pub const lang = @import("builtin.zig");
+pub const lang = @import("lang.zig");
 pub const c = @import("c.zig");
 pub const coff = @import("coff.zig");
 pub const compress = @import("compress.zig");

package/std/testing.zig

@@ -163,7 +163,7 @@ fn expectEqualInner(comptime T: type, expected: T, actual: T) !void {
                     }
                 }
 
-                const BackingInt = std.meta.Int(.unsigned, @bitSizeOf(T));
+                const BackingInt = @Int(.unsigned, @bitSizeOf(T));
                 return expectEqual(
                     @as(BackingInt, @bitCast(expected)),
                     @as(BackingInt, @bitCast(actual)),

package/std/zig/Ast.zig

@@ -2103,7 +2103,7 @@ fn fullFnProtoComponents(tree: Ast, info: full.FnProto.Components) full.FnProto
 }
 
 fn fullPtrTypeComponents(tree: Ast, info: full.PtrType.Components) full.PtrType {
-    const size: std.builtin.Type.Pointer.Size = switch (tree.tokenTag(info.main_token)) {
+    const size: std.lang.Type.Pointer.Size = switch (tree.tokenTag(info.main_token)) {
         .asterisk => .one,
         .l_bracket => switch (tree.tokenTag(info.main_token + 1)) {
             .asterisk => if (tree.tokenTag(info.main_token + 2) == .identifier) .c else .many,
@@ -2726,7 +2726,7 @@ pub const full = struct {
     };
 
     pub const PtrType = struct {
-        size: std.builtin.Type.Pointer.Size,
+        size: std.lang.Type.Pointer.Size,
         allowzero_token: ?TokenIndex,
         const_token: ?TokenIndex,
         volatile_token: ?TokenIndex,