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

package/compiler/aro/aro/CodeGen.zig

@@ -894,7 +894,7 @@ fn genLval(c: *CodeGen, node_index: Node.Index) Error!Ir.Ref {
                 }
             }
 
-            const duped_name = try c.builder.arena.allocator().dupeZ(u8, slice);
+            const duped_name = try c.builder.arena.allocator().dupeSentinel(u8, slice, 0);
             const ref: Ir.Ref = @enumFromInt(c.builder.instructions.len);
             try c.builder.instructions.append(c.builder.gpa, .{ .tag = .symbol, .data = .{ .label = duped_name }, .ty = .ptr });
             return ref;
@@ -1112,7 +1112,7 @@ fn genCall(c: *CodeGen, call: Node.Call) Error!Ir.Ref {
                     }
                 }
 
-                const duped_name = try c.builder.arena.allocator().dupeZ(u8, slice);
+                const duped_name = try c.builder.arena.allocator().dupeSentinel(u8, slice, 0);
                 const ref: Ir.Ref = @enumFromInt(c.builder.instructions.len);
                 try c.builder.instructions.append(c.builder.gpa, .{ .tag = .symbol, .data = .{ .label = duped_name }, .ty = .ptr });
                 break :blk ref;

package/compiler/resinator/errors.zig

@@ -43,7 +43,7 @@ pub const Diagnostics = struct {
         try self.errors.append(self.allocator, error_details);
     }
 
-    const SmallestStringIndexType = std.meta.Int(.unsigned, @min(
+    const SmallestStringIndexType = @Int(.unsigned, @min(
         @bitSizeOf(ErrorDetails.FileOpenError.FilenameStringIndex),
         @min(
             @bitSizeOf(ErrorDetails.IconReadError.FilenameStringIndex),
@@ -165,7 +165,7 @@ pub const ErrorDetails = struct {
         err: FileOpenErrorEnum,
         filename_string_index: FilenameStringIndex,
 
-        pub const FilenameStringIndex = std.meta.Int(.unsigned, 32 - @bitSizeOf(FileOpenErrorEnum));
+        pub const FilenameStringIndex = @Int(.unsigned, 32 - @bitSizeOf(FileOpenErrorEnum));
         pub const FileOpenErrorEnum = std.meta.FieldEnum(Io.File.OpenError || Io.File.StatError);
 
         pub fn enumFromError(err: (Io.File.OpenError || Io.File.StatError)) FileOpenErrorEnum {
@@ -180,7 +180,7 @@ pub const ErrorDetails = struct {
         icon_type: enum(u1) { cursor, icon },
         filename_string_index: FilenameStringIndex,
 
-        pub const FilenameStringIndex = std.meta.Int(.unsigned, 32 - @bitSizeOf(IconReadErrorEnum) - 1);
+        pub const FilenameStringIndex = @Int(.unsigned, 32 - @bitSizeOf(IconReadErrorEnum) - 1);
         pub const IconReadErrorEnum = std.meta.FieldEnum(ico.ReadError);
 
         pub fn enumFromError(err: ico.ReadError) IconReadErrorEnum {
@@ -197,14 +197,14 @@ pub const ErrorDetails = struct {
         bitmap_version: ico.BitmapHeader.Version = .unknown,
         _: Padding = 0,
 
-        pub const Padding = std.meta.Int(.unsigned, 15 - @bitSizeOf(ico.BitmapHeader.Version) - @bitSizeOf(ico.ImageFormat));
+        pub const Padding = @Int(.unsigned, 15 - @bitSizeOf(ico.BitmapHeader.Version) - @bitSizeOf(ico.ImageFormat));
     };
 
     pub const BitmapReadError = packed struct(u32) {
         err: BitmapReadErrorEnum,
         filename_string_index: FilenameStringIndex,
 
-        pub const FilenameStringIndex = std.meta.Int(.unsigned, 32 - @bitSizeOf(BitmapReadErrorEnum));
+        pub const FilenameStringIndex = @Int(.unsigned, 32 - @bitSizeOf(BitmapReadErrorEnum));
         pub const BitmapReadErrorEnum = std.meta.FieldEnum(bmp.ReadError);
 
         pub fn enumFromError(err: bmp.ReadError) BitmapReadErrorEnum {
@@ -218,14 +218,14 @@ pub const ErrorDetails = struct {
         dib_version: ico.BitmapHeader.Version,
         filename_string_index: FilenameStringIndex,
 
-        pub const FilenameStringIndex = std.meta.Int(.unsigned, 32 - @bitSizeOf(ico.BitmapHeader.Version));
+        pub const FilenameStringIndex = @Int(.unsigned, 32 - @bitSizeOf(ico.BitmapHeader.Version));
     };
 
     pub const AcceleratorError = packed struct(u32) {
         err: AcceleratorErrorEnum,
         _: Padding = 0,
 
-        pub const Padding = std.meta.Int(.unsigned, 32 - @bitSizeOf(AcceleratorErrorEnum));
+        pub const Padding = @Int(.unsigned, 32 - @bitSizeOf(AcceleratorErrorEnum));
         pub const AcceleratorErrorEnum = std.meta.FieldEnum(res.ParseAcceleratorKeyStringError);
 
         pub fn enumFromError(err: res.ParseAcceleratorKeyStringError) AcceleratorErrorEnum {

package/compiler_rt/addf3.zig

@@ -8,7 +8,7 @@ const normalize = compiler_rt.normalize;
 /// https://github.com/llvm/llvm-project/blob/02d85149a05cb1f6dc49f0ba7a2ceca53718ae17/compiler-rt/lib/builtins/fp_add_impl.inc
 pub inline fn addf3(comptime T: type, a: T, b: T) T {
     const bits = @typeInfo(T).float.bits;
-    const Z = std.meta.Int(.unsigned, bits);
+    const Z = @Int(.unsigned, bits);
 
     const typeWidth = bits;
     const significandBits = math.floatMantissaBits(T);

package/compiler_rt/comparef.zig

@@ -162,8 +162,8 @@ pub const GE = enum(i32) {
 
 pub inline fn cmpf2(comptime T: type, comptime RT: type, a: T, b: T) RT {
     const bits = @typeInfo(T).float.bits;
-    const srep_t = std.meta.Int(.signed, bits);
-    const rep_t = std.meta.Int(.unsigned, bits);
+    const srep_t = @Int(.signed, bits);
+    const rep_t = @Int(.unsigned, bits);
 
     const significandBits = std.math.floatMantissaBits(T);
     const exponentBits = std.math.floatExponentBits(T);
@@ -253,7 +253,7 @@ test "cmp_f80" {
 }
 
 pub inline fn unordcmp(comptime T: type, a: T, b: T) i32 {
-    const rep_t = std.meta.Int(.unsigned, @typeInfo(T).float.bits);
+    const rep_t = @Int(.unsigned, @typeInfo(T).float.bits);
 
     const significandBits = std.math.floatMantissaBits(T);
     const exponentBits = std.math.floatExponentBits(T);

package/compiler_rt/count0bits.zig

@@ -198,7 +198,7 @@ pub fn __ctzti2(a: i128) callconv(.c) i32 {
 }
 
 inline fn ffsXi2(comptime T: type, a: T) i32 {
-    var x: std.meta.Int(.unsigned, @typeInfo(T).int.bits) = @bitCast(a);
+    var x: @Int(.unsigned, @typeInfo(T).int.bits) = @bitCast(a);
     var n: T = 1;
     // adapted from Number of trailing zeroes (see ctzXi2)
     var mask: @TypeOf(x) = std.math.maxInt(@TypeOf(x));

package/compiler_rt/divdf3.zig

@@ -26,8 +26,8 @@ fn __aeabi_ddiv(a: f64, b: f64) callconv(.{ .arm_aapcs = .{} }) f64 {
 }
 
 inline fn div(a: f64, b: f64) f64 {
-    const Z = std.meta.Int(.unsigned, 64);
-    const SignedZ = std.meta.Int(.signed, 64);
+    const Z = @Int(.unsigned, 64);
+    const SignedZ = @Int(.signed, 64);
 
     const significandBits = std.math.floatMantissaBits(f64);
     const exponentBits = std.math.floatExponentBits(f64);

package/compiler_rt/divsf3.zig

@@ -25,7 +25,7 @@ fn __aeabi_fdiv(a: f32, b: f32) callconv(.{ .arm_aapcs = .{} }) f32 {
 }
 
 inline fn div(a: f32, b: f32) f32 {
-    const Z = std.meta.Int(.unsigned, 32);
+    const Z = @Int(.unsigned, 32);
 
     const significandBits = std.math.floatMantissaBits(f32);
     const exponentBits = std.math.floatExponentBits(f32);

package/compiler_rt/divtf3.zig

@@ -24,7 +24,7 @@ fn _Qp_div(c: *f128, a: *const f128, b: *const f128) callconv(.c) void {
 }
 
 inline fn div(a: f128, b: f128) f128 {
-    const Z = std.meta.Int(.unsigned, 128);
+    const Z = @Int(.unsigned, 128);
 
     const significandBits = std.math.floatMantissaBits(f128);
     const exponentBits = std.math.floatExponentBits(f128);

package/compiler_rt/divxf3.zig

@@ -13,7 +13,7 @@ comptime {
 
 pub fn __divxf3(a: f80, b: f80) callconv(.c) f80 {
     const T = f80;
-    const Z = std.meta.Int(.unsigned, @bitSizeOf(T));
+    const Z = @Int(.unsigned, @bitSizeOf(T));
 
     const significandBits = std.math.floatMantissaBits(T);
     const fractionalBits = std.math.floatFractionalBits(T);

package/compiler_rt/extendf.zig

@@ -3,10 +3,10 @@ const std = @import("std");
 pub inline fn extendf(
     comptime dst_t: type,
     comptime src_t: type,
-    a: std.meta.Int(.unsigned, @typeInfo(src_t).float.bits),
+    a: @Int(.unsigned, @typeInfo(src_t).float.bits),
 ) dst_t {
-    const src_rep_t = std.meta.Int(.unsigned, @typeInfo(src_t).float.bits);
-    const dst_rep_t = std.meta.Int(.unsigned, @typeInfo(dst_t).float.bits);
+    const src_rep_t = @Int(.unsigned, @typeInfo(src_t).float.bits);
+    const dst_rep_t = @Int(.unsigned, @typeInfo(dst_t).float.bits);
     const srcSigBits = std.math.floatMantissaBits(src_t);
     const dstSigBits = std.math.floatMantissaBits(dst_t);
 
@@ -70,8 +70,8 @@ pub inline fn extendf(
     return @bitCast(result);
 }
 
-pub inline fn extend_f80(comptime src_t: type, a: std.meta.Int(.unsigned, @typeInfo(src_t).float.bits)) f80 {
-    const src_rep_t = std.meta.Int(.unsigned, @typeInfo(src_t).float.bits);
+pub inline fn extend_f80(comptime src_t: type, a: @Int(.unsigned, @typeInfo(src_t).float.bits)) f80 {
+    const src_rep_t = @Int(.unsigned, @typeInfo(src_t).float.bits);
     const src_sig_bits = std.math.floatMantissaBits(src_t);
     const dst_int_bit = 0x8000000000000000;
     const dst_sig_bits = std.math.floatMantissaBits(f80) - 1; // -1 for the integer bit

package/compiler_rt/fabs.zig

@@ -47,7 +47,7 @@ pub fn fabsl(x: c_longdouble) callconv(.c) c_longdouble {
 
 inline fn generic_fabs(x: anytype) @TypeOf(x) {
     const T = @TypeOf(x);
-    const TBits = std.meta.Int(.unsigned, @typeInfo(T).float.bits);
+    const TBits = @Int(.unsigned, @typeInfo(T).float.bits);
     const float_bits: TBits = @bitCast(x);
     const remove_sign = ~@as(TBits, 0) >> 1;
     return @bitCast(float_bits & remove_sign);

package/compiler_rt/float_from_int.zig

@@ -1,5 +1,4 @@
 const std = @import("std");
-const Int = std.meta.Int;
 const math = std.math;
 
 pub fn floatFromInt(comptime T: type, x: anytype) T {
@@ -7,14 +6,14 @@ pub fn floatFromInt(comptime T: type, x: anytype) T {
 
     // Various constants whose values follow from the type parameters.
     // Any reasonable optimizer will fold and propagate all of these.
-    const Z = Int(.unsigned, @bitSizeOf(@TypeOf(x)));
-    const uT = Int(.unsigned, @bitSizeOf(T));
+    const Z = @Int(.unsigned, @bitSizeOf(@TypeOf(x)));
+    const uT = @Int(.unsigned, @bitSizeOf(T));
     const inf = math.inf(T);
     const float_bits = @bitSizeOf(T);
     const int_bits = @bitSizeOf(@TypeOf(x));
     const exp_bits = math.floatExponentBits(T);
     const fractional_bits = math.floatFractionalBits(T);
-    const exp_bias = math.maxInt(Int(.unsigned, exp_bits - 1));
+    const exp_bias = math.maxInt(@Int(.unsigned, exp_bits - 1));
     const implicit_bit = if (T != f80) @as(uT, 1) << fractional_bits else 0;
     const max_exp = exp_bias;
 

package/compiler_rt/fmax.zig

@@ -59,7 +59,7 @@ inline fn generic_fmax(comptime T: type, x: T, y: T) T {
 test "generic_fmax" {
     inline for ([_]type{ f32, f64, c_longdouble, f80, f128 }) |T| {
         const nan_val = math.nan(T);
-        const Int = std.meta.Int(.unsigned, @bitSizeOf(T));
+        const Int = @Int(.unsigned, @bitSizeOf(T));
 
         try std.testing.expect(math.isNan(generic_fmax(T, nan_val, nan_val)));
         try std.testing.expectEqual(@as(T, 1.0), generic_fmax(T, nan_val, 1.0));

package/compiler_rt/fmin.zig

@@ -59,7 +59,7 @@ inline fn generic_fmin(comptime T: type, x: T, y: T) T {
 test "generic_fmin" {
     inline for ([_]type{ f32, f64, c_longdouble, f80, f128 }) |T| {
         const nan_val = math.nan(T);
-        const Int = std.meta.Int(.unsigned, @bitSizeOf(T));
+        const Int = @Int(.unsigned, @bitSizeOf(T));
 
         try std.testing.expect(math.isNan(generic_fmin(T, nan_val, nan_val)));
         try std.testing.expectEqual(@as(T, 1.0), generic_fmin(T, nan_val, 1.0));

package/compiler_rt/fmod.zig

@@ -36,7 +36,7 @@ pub fn fmod(x: f64, y: f64) callconv(.c) f64 {
 /// Logic and flow heavily inspired by MUSL fmodl for 113 mantissa digits
 pub fn __fmodx(a: f80, b: f80) callconv(.c) f80 {
     const T = f80;
-    const Z = std.meta.Int(.unsigned, @bitSizeOf(T));
+    const Z = @Int(.unsigned, @bitSizeOf(T));
 
     const significandBits = math.floatMantissaBits(T);
     const fractionalBits = math.floatFractionalBits(T);
@@ -260,7 +260,7 @@ pub fn fmodl(a: c_longdouble, b: c_longdouble) callconv(.c) c_longdouble {
 
 inline fn generic_fmod(comptime T: type, x: T, y: T) T {
     const bits = @typeInfo(T).float.bits;
-    const uint = std.meta.Int(.unsigned, bits);
+    const uint = @Int(.unsigned, bits);
     comptime assert(T == f32 or T == f64);
     const digits = if (T == f32) 23 else 52;
     const exp_bits = if (T == f32) 9 else 12;

package/compiler_rt/mulf3.zig

@@ -12,7 +12,7 @@ pub inline fn mulf3(comptime T: type, a: T, b: T) T {
     const fractionalBits = math.floatFractionalBits(T);
     const exponentBits = math.floatExponentBits(T);
 
-    const Z = std.meta.Int(.unsigned, typeWidth);
+    const Z = @Int(.unsigned, typeWidth);
 
     // ZSignificand is large enough to contain the significand, including an explicit integer bit
     const ZSignificand = PowerOfTwoSignificandZ(T);
@@ -195,7 +195,7 @@ fn normalize(comptime T: type, significand: *PowerOfTwoSignificandZ(T)) i32 {
 /// the significand of T, including an explicit integer bit
 fn PowerOfTwoSignificandZ(comptime T: type) type {
     const bits = math.ceilPowerOfTwoAssert(u16, math.floatFractionalBits(T) + 1);
-    return std.meta.Int(.unsigned, bits);
+    return @Int(.unsigned, bits);
 }
 
 test {

package/compiler_rt/truncf.zig

@@ -1,8 +1,8 @@
 const std = @import("std");
 
 pub inline fn truncf(comptime dst_t: type, comptime src_t: type, a: src_t) dst_t {
-    const src_rep_t = std.meta.Int(.unsigned, @typeInfo(src_t).float.bits);
-    const dst_rep_t = std.meta.Int(.unsigned, @typeInfo(dst_t).float.bits);
+    const src_rep_t = @Int(.unsigned, @typeInfo(src_t).float.bits);
+    const dst_rep_t = @Int(.unsigned, @typeInfo(dst_t).float.bits);
     const srcSigBits = std.math.floatMantissaBits(src_t);
     const dstSigBits = std.math.floatMantissaBits(dst_t);
 
@@ -100,7 +100,7 @@ pub inline fn truncf(comptime dst_t: type, comptime src_t: type, a: src_t) dst_t
 }
 
 pub inline fn trunc_f80(comptime dst_t: type, a: f80) dst_t {
-    const dst_rep_t = std.meta.Int(.unsigned, @typeInfo(dst_t).float.bits);
+    const dst_rep_t = @Int(.unsigned, @typeInfo(dst_t).float.bits);
     const src_sig_bits = std.math.floatMantissaBits(f80) - 1; // -1 for the integer bit
     const dst_sig_bits = std.math.floatMantissaBits(dst_t);
 

package/compiler_rt.zig

@@ -574,8 +574,8 @@ pub fn wideMultiply(comptime Z: type, a: Z, b: Z, hi: *Z, lo: *Z) void {
     }
 }
 
-pub fn normalize(comptime T: type, significand: *std.meta.Int(.unsigned, @typeInfo(T).float.bits)) i32 {
-    const Z = std.meta.Int(.unsigned, @typeInfo(T).float.bits);
+pub fn normalize(comptime T: type, significand: *@Int(.unsigned, @typeInfo(T).float.bits)) i32 {
+    const Z = @Int(.unsigned, @typeInfo(T).float.bits);
     const integerBit = @as(Z, 1) << std.math.floatFractionalBits(T);
 
     const shift = @clz(significand.*) - @clz(integerBit);
@@ -625,8 +625,8 @@ fn __aeabi_fneg(a: f32) callconv(.{ .arm_aapcs = .{} }) f32 {
 pub fn HalveInt(comptime T: type, comptime signed_half: bool) type {
     return extern union {
         pub const bits = @divExact(@typeInfo(T).int.bits, 2);
-        pub const HalfTU = std.meta.Int(.unsigned, bits);
-        pub const HalfTS = std.meta.Int(.signed, bits);
+        pub const HalfTU = @Int(.unsigned, bits);
+        pub const HalfTS = @Int(.signed, bits);
         pub const HalfT = if (signed_half) HalfTS else HalfTU;
 
         all: T,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zigc/lib",
-  "version": "0.17.0-dev.269",
+  "version": "0.17.0-dev.292",
   "description": "Zig standard library and libc headers (shared across all platforms)",
   "repository": {
     "type": "git",

package/std/Build/Watch/FsEvents.zig

@@ -195,7 +195,7 @@ pub fn setPaths(fse: *FsEvents, gpa: Allocator, steps: []const *std.Build.Step)
     } else {
         fse.watch_roots = try gpa.realloc(fse.watch_roots, need_dirs.count());
         for (fse.watch_roots, need_dirs.keys()) |*out, in| {
-            out.* = try paths_arena.dupeZ(u8, in);
+            out.* = try paths_arena.dupeSentinel(u8, in, 0);
         }
     }
     if (enable_debug_logs) {

package/std/Build/abi.zig

@@ -266,7 +266,7 @@ pub const fuzz = struct {
                 .comptime_int => x,
                 .bool => @intFromBool(x),
                 .@"enum" => @intFromEnum(x),
-                else => @as(std.meta.Int(.unsigned, @bitSizeOf(T)), @bitCast(x)),
+                else => @as(@Int(.unsigned, @bitSizeOf(T)), @bitCast(x)),
 
                 .int => |i| x: {
                     comptime {

package/std/Io/Dir.zig

@@ -944,7 +944,7 @@ pub const RealPathFileAllocError = RealPathFileError || Allocator.Error;
 pub fn realPathFileAlloc(dir: Dir, io: Io, sub_path: []const u8, allocator: Allocator) RealPathFileAllocError![:0]u8 {
     var buffer: [max_path_bytes]u8 = undefined;
     const n = try realPathFile(dir, io, sub_path, &buffer);
-    return allocator.dupeZ(u8, buffer[0..n]);
+    return allocator.dupeSentinel(u8, buffer[0..n], 0);
 }
 
 /// Same as `realPathFile` except `absolute_path` is asserted to be an absolute
@@ -974,7 +974,7 @@ pub fn realPathFileAbsolute(io: Io, absolute_path: []const u8, out_buffer: []u8)
 pub fn realPathFileAbsoluteAlloc(io: Io, absolute_path: []const u8, allocator: Allocator) RealPathFileAllocError![:0]u8 {
     var buffer: [max_path_bytes]u8 = undefined;
     const n = try realPathFileAbsolute(io, absolute_path, &buffer);
-    return allocator.dupeZ(u8, buffer[0..n]);
+    return allocator.dupeSentinel(u8, buffer[0..n], 0);
 }
 
 pub const DeleteFileError = error{

package/std/Io/Dispatch.zig

@@ -4086,7 +4086,7 @@ fn processReplace(userdata: ?*anyopaque, options: process.ReplaceOptions) proces
     const arena = arena_allocator.allocator();
 
     const argv_buf = try arena.allocSentinel(?[*:0]const u8, options.argv.len, null);
-    for (options.argv, 0..) |arg, i| argv_buf[i] = (try arena.dupeZ(u8, arg)).ptr;
+    for (options.argv, 0..) |arg, i| argv_buf[i] = (try arena.dupeSentinel(u8, arg, 0)).ptr;
 
     const env_block = env_block: {
         const prog_fd: i32 = -1;
@@ -4222,7 +4222,7 @@ fn spawn(ev: *Evented, options: process.SpawnOptions) process.SpawnError!Spawned
     // Therefore, we do all the allocation for the execve() before the fork().
     // This means we must do the null-termination of argv and env vars here.
     const argv_buf = try arena.allocSentinel(?[*:0]const u8, options.argv.len, null);
-    for (options.argv, 0..) |arg, i| argv_buf[i] = (try arena.dupeZ(u8, arg)).ptr;
+    for (options.argv, 0..) |arg, i| argv_buf[i] = (try arena.dupeSentinel(u8, arg, 0)).ptr;
 
     const env_block = env_block: {
         const prog_fd: i32 = if (prog_pipe[1] == -1) -1 else prog_fileno;

package/std/Io/Threaded.zig

@@ -956,7 +956,7 @@ const Thread = struct {
             comptime assert(builtin.cpu.has(.wasm, .atomics));
             // TODO implement cancelation for WASM futex waits by signaling the futex
             if (!uncancelable) try Thread.checkCancel();
-            const to: i64 = if (timeout_ns) |ns| ns else -1;
+            const to: i64 = if (timeout_ns) |ns| std.math.cast(i64, ns) orelse std.math.maxInt(i64) else -1;
             const signed_expect: i32 = @bitCast(expect);
             const result = asm volatile (
                 \\local.get %[ptr]
@@ -13851,7 +13851,7 @@ fn netLookupFallible(
         const name_c = name_buffer[0..name.len :0];
 
         var port_buffer: [8]u8 = undefined;
-        const port_c = std.fmt.bufPrintZ(&port_buffer, "{d}", .{options.port}) catch unreachable;
+        const port_c = std.fmt.bufPrintSentinel(&port_buffer, "{d}", .{options.port}, 0) catch unreachable;
 
         const hints: posix.addrinfo = .{
             .flags = .{ .CANONNAME = options.canonical_name_buffer != null, .NUMERICSERV = true },
@@ -14954,7 +14954,7 @@ fn processReplace(userdata: ?*anyopaque, options: process.ReplaceOptions) proces
     const arena = arena_allocator.allocator();
 
     const argv_buf = try arena.allocSentinel(?[*:0]const u8, options.argv.len, null);
-    for (options.argv, 0..) |arg, i| argv_buf[i] = (try arena.dupeZ(u8, arg)).ptr;
+    for (options.argv, 0..) |arg, i| argv_buf[i] = (try arena.dupeSentinel(u8, arg, 0)).ptr;
 
     const env_block = env_block: {
         const prog_fd: i32 = -1;
@@ -15061,7 +15061,7 @@ fn spawnPosix(t: *Threaded, options: process.SpawnOptions) process.SpawnError!Sp
     // Therefore, we do all the allocation for the execve() before the fork().
     // This means we must do the null-termination of argv and env vars here.
     const argv_buf = try arena.allocSentinel(?[*:0]const u8, options.argv.len, null);
-    for (options.argv, 0..) |arg, i| argv_buf[i] = (try arena.dupeZ(u8, arg)).ptr;
+    for (options.argv, 0..) |arg, i| argv_buf[i] = (try arena.dupeSentinel(u8, arg, 0)).ptr;
 
     const prog_fileno = 3;
     comptime assert(@max(posix.STDIN_FILENO, posix.STDOUT_FILENO, posix.STDERR_FILENO) + 1 == prog_fileno);
@@ -15574,7 +15574,7 @@ fn readIntFd(fd: posix.fd_t) !ErrInt {
     return @intCast(std.mem.readInt(u64, &buffer, .little));
 }
 
-const ErrInt = std.meta.Int(.unsigned, @sizeOf(anyerror) * 8);
+const ErrInt = @Int(.unsigned, @sizeOf(anyerror) * 8);
 
 fn destroyPipe(pipe: [2]posix.fd_t) void {
     if (pipe[0] != -1) closeFd(pipe[0]);

package/std/Io/Uring.zig

@@ -4226,7 +4226,7 @@ fn processReplace(userdata: ?*anyopaque, options: process.ReplaceOptions) proces
     const arena = arena_allocator.allocator();
 
     const argv_buf = try arena.allocSentinel(?[*:0]const u8, options.argv.len, null);
-    for (options.argv, 0..) |arg, i| argv_buf[i] = (try arena.dupeZ(u8, arg)).ptr;
+    for (options.argv, 0..) |arg, i| argv_buf[i] = (try arena.dupeSentinel(u8, arg, 0)).ptr;
 
     const env_block = env_block: {
         const prog_fd: i32 = -1;
@@ -4369,7 +4369,7 @@ fn spawn(ev: *Evented, options: process.SpawnOptions) process.SpawnError!Spawned
     // Therefore, we do all the allocation for the execve() before the fork().
     // This means we must do the null-termination of argv and env vars here.
     const argv_buf = try arena.allocSentinel(?[*:0]const u8, options.argv.len, null);
-    for (options.argv, 0..) |arg, i| argv_buf[i] = (try arena.dupeZ(u8, arg)).ptr;
+    for (options.argv, 0..) |arg, i| argv_buf[i] = (try arena.dupeSentinel(u8, arg, 0)).ptr;
 
     const env_block = env_block: {
         const prog_fd: i32 = if (prog_pipe[1] == -1) -1 else prog_fileno;

package/std/Io/Writer.zig

@@ -1517,7 +1517,7 @@ pub fn printIntAny(
     // The type must have the same size as `base` or be wider in order for the
     // division to work
     const min_int_bits = comptime @max(value_info.bits, 8);
-    const MinInt = std.meta.Int(.unsigned, min_int_bits);
+    const MinInt = @Int(.unsigned, min_int_bits);
 
     const abs_value = @abs(value);
     // The worst case in terms of space needed is base 2, plus 1 for the sign
@@ -1637,7 +1637,7 @@ pub fn printFloatHex(w: *Writer, value: anytype, case: std.fmt.Case, opt_precisi
     });
 
     const T = @TypeOf(v);
-    const TU = std.meta.Int(.unsigned, @bitSizeOf(T));
+    const TU = @Int(.unsigned, @bitSizeOf(T));
 
     const mantissa_bits = std.math.floatMantissaBits(T);
     const fractional_bits = std.math.floatFractionalBits(T);

package/std/Random.zig

@@ -125,9 +125,9 @@ pub fn enumValueWithIndex(r: Random, comptime EnumType: type, comptime Index: ty
 /// `i` is evenly distributed.
 pub fn int(r: Random, comptime T: type) T {
     const bits = @typeInfo(T).int.bits;
-    const UnsignedT = std.meta.Int(.unsigned, bits);
+    const UnsignedT = @Int(.unsigned, bits);
     const ceil_bytes = comptime std.math.divCeil(u16, bits, 8) catch unreachable;
-    const ByteAlignedT = std.meta.Int(.unsigned, ceil_bytes * 8);
+    const ByteAlignedT = @Int(.unsigned, ceil_bytes * 8);
 
     var rand_bytes: [ceil_bytes]u8 = undefined;
     r.bytes(&rand_bytes);
@@ -215,7 +215,7 @@ pub fn intRangeLessThanBiased(r: Random, comptime T: type, at_least: T, less_tha
     const info = @typeInfo(T).int;
     if (info.signedness == .signed) {
         // Two's complement makes this math pretty easy.
-        const UnsignedT = std.meta.Int(.unsigned, info.bits);
+        const UnsignedT = @Int(.unsigned, info.bits);
         const lo: UnsignedT = @bitCast(at_least);
         const hi: UnsignedT = @bitCast(less_than);
         const result = lo +% r.uintLessThanBiased(UnsignedT, hi -% lo);
@@ -234,7 +234,7 @@ pub fn intRangeLessThan(r: Random, comptime T: type, at_least: T, less_than: T)
     const info = @typeInfo(T).int;
     if (info.signedness == .signed) {
         // Two's complement makes this math pretty easy.
-        const UnsignedT = std.meta.Int(.unsigned, info.bits);
+        const UnsignedT = @Int(.unsigned, info.bits);
         const lo: UnsignedT = @bitCast(at_least);
         const hi: UnsignedT = @bitCast(less_than);
         const result = lo +% r.uintLessThan(UnsignedT, hi -% lo);
@@ -252,7 +252,7 @@ pub fn intRangeAtMostBiased(r: Random, comptime T: type, at_least: T, at_most: T
     const info = @typeInfo(T).int;
     if (info.signedness == .signed) {
         // Two's complement makes this math pretty easy.
-        const UnsignedT = std.meta.Int(.unsigned, info.bits);
+        const UnsignedT = @Int(.unsigned, info.bits);
         const lo: UnsignedT = @bitCast(at_least);
         const hi: UnsignedT = @bitCast(at_most);
         const result = lo +% r.uintAtMostBiased(UnsignedT, hi -% lo);
@@ -271,7 +271,7 @@ pub fn intRangeAtMost(r: Random, comptime T: type, at_least: T, at_most: T) T {
     const info = @typeInfo(T).int;
     if (info.signedness == .signed) {
         // Two's complement makes this math pretty easy.
-        const UnsignedT = std.meta.Int(.unsigned, info.bits);
+        const UnsignedT = @Int(.unsigned, info.bits);
         const lo: UnsignedT = @bitCast(at_least);
         const hi: UnsignedT = @bitCast(at_most);
         const result = lo +% r.uintAtMost(UnsignedT, hi -% lo);

package/std/Target.zig

@@ -1228,7 +1228,7 @@ pub const Cpu = struct {
             pub const needed_bit_count = 347;
             pub const byte_count = (needed_bit_count + 7) / 8;
             pub const usize_count = (byte_count + (@sizeOf(usize) - 1)) / @sizeOf(usize);
-            pub const Index = std.math.Log2Int(std.meta.Int(.unsigned, usize_count * @bitSizeOf(usize)));
+            pub const Index = std.math.Log2Int(@Int(.unsigned, usize_count * @bitSizeOf(usize)));
             pub const ShiftInt = std.math.Log2Int(usize);
 
             pub const empty: Set = .{ .ints = @splat(0) };

package/std/bit_set.zig

@@ -65,7 +65,7 @@ pub fn Integer(comptime size: u16) type {
         pub const bit_length: usize = size;
 
         /// The integer type used to represent a mask in this bit set
-        pub const MaskInt = std.meta.Int(.unsigned, size);
+        pub const MaskInt = @Int(.unsigned, size);
 
         /// The integer type used to shift a mask in this bit set
         pub const ShiftInt = std.math.Log2Int(MaskInt);
@@ -359,7 +359,7 @@ pub fn Array(comptime MaskIntType: type, comptime size: usize) type {
     if (!std.math.isPowerOfTwo(@bitSizeOf(MaskIntType))) {
         var desired_bits = std.math.ceilPowerOfTwoAssert(usize, @bitSizeOf(MaskIntType));
         if (desired_bits < byte_size) desired_bits = byte_size;
-        const FixedMaskType = std.meta.Int(.unsigned, desired_bits);
+        const FixedMaskType = @Int(.unsigned, desired_bits);
         @compileError("Array was passed integer type " ++ @typeName(MaskIntType) ++
             ", which is not a power of two.  Please round this up to a power of two integer size (i.e. " ++ @typeName(FixedMaskType) ++ ").");
     }
@@ -370,7 +370,7 @@ pub fn Array(comptime MaskIntType: type, comptime size: usize) type {
     if (@bitSizeOf(MaskIntType) != @sizeOf(MaskIntType) * byte_size) {
         var desired_bits = @sizeOf(MaskIntType) * byte_size;
         desired_bits = std.math.ceilPowerOfTwoAssert(usize, desired_bits);
-        const FixedMaskType = std.meta.Int(.unsigned, desired_bits);
+        const FixedMaskType = @Int(.unsigned, desired_bits);
         @compileError("Array was passed integer type " ++ @typeName(MaskIntType) ++
             ", which contains padding bits.  Please round this up to an unpadded integer size (i.e. " ++ @typeName(FixedMaskType) ++ ").");
     }

package/std/c.zig

@@ -2610,7 +2610,8 @@ pub const SHUT = switch (native_os) {
 
 /// Signal types
 pub const SIG = switch (native_os) {
-    .linux, .emscripten => linux.SIG,
+    .linux => linux.SIG,
+    .emscripten => emscripten.SIG,
     .windows => enum(u32) {
         /// interrupt
         INT = 2,
@@ -7185,7 +7186,7 @@ pub const RTLD = switch (native_os) {
         NOW: bool = false,
         GLOBAL: bool = false,
         LOCAL: bool = false,
-        _: std.meta.Int(.unsigned, @bitSizeOf(c_int) - 6) = 0,
+        _: @Int(.unsigned, @bitSizeOf(c_int) - 6) = 0,
     },
     else => void,
 };
@@ -7365,7 +7366,7 @@ pub const AI = if (builtin.abi.isAndroid()) packed struct(u32) {
         V4MAPPED: bool = false,
         ALL: bool = false,
         ADDRCONFIG: bool = false,
-        _: std.meta.Int(.unsigned, @bitSizeOf(c_int) - 7) = 0,
+        _: @Int(.unsigned, @bitSizeOf(c_int) - 7) = 0,
     },
     else => void,
 };
@@ -7398,7 +7399,7 @@ pub const NI = switch (native_os) {
         NAMEREQD: bool = false,
         NOFQDN: bool = false,
         DGRAM: bool = false,
-        _: std.meta.Int(.unsigned, @bitSizeOf(c_int) - 5) = 0,
+        _: @Int(.unsigned, @bitSizeOf(c_int) - 5) = 0,
     },
     .freebsd, .haiku => packed struct(u32) {
         NOFQDN: bool = false,
@@ -8634,7 +8635,7 @@ pub const O = switch (native_os) {
         CLOEXEC: bool = false,
         DIRECT: bool = false,
         SYNC: bool = false,
-        _: std.meta.Int(.unsigned, @bitSizeOf(c_int) - 14) = 0,
+        _: @Int(.unsigned, @bitSizeOf(c_int) - 14) = 0,
     },
     else => void,
 };
@@ -8788,7 +8789,7 @@ pub const MAP = switch (native_os) {
         RANDOMIZED: bool = false,
         PURGEABLE: bool = false,
         FIXED_NOREPLACE: bool = false,
-        _: std.meta.Int(.unsigned, @bitSizeOf(c_int) - 11) = 0,
+        _: @Int(.unsigned, @bitSizeOf(c_int) - 11) = 0,
     },
     else => void,
 };