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

package/std/compress/zstd/Decompress.zig

@@ -533,7 +533,7 @@ pub const Frame = struct {
                     table: Table,
                     accuracy_log: u8,
 
-                    const State = std.meta.Int(.unsigned, max_accuracy_log);
+                    const State = @Int(.unsigned, max_accuracy_log);
                 };
             }
 
@@ -1783,7 +1783,7 @@ const ReverseBitReader = struct {
     }
 
     fn initBits(comptime T: type, out: anytype, num: u16) Bits(T) {
-        const UT = std.meta.Int(.unsigned, @bitSizeOf(T));
+        const UT = @Int(.unsigned, @bitSizeOf(T));
         return .{
             @bitCast(@as(UT, @intCast(out))),
             num,
@@ -1803,7 +1803,7 @@ const ReverseBitReader = struct {
     }
 
     fn readBitsTuple(self: *ReverseBitReader, comptime T: type, num: u16) !Bits(T) {
-        const UT = std.meta.Int(.unsigned, @bitSizeOf(T));
+        const UT = @Int(.unsigned, @bitSizeOf(T));
         const U = if (@bitSizeOf(T) < 8) u8 else UT;
 
         if (num <= self.count) return initBits(T, self.removeBits(@intCast(num)), num);
@@ -1871,7 +1871,7 @@ const BitReader = struct {
     count: u4 = 0,
 
     fn initBits(comptime T: type, out: anytype, num: u16) Bits(T) {
-        const UT = std.meta.Int(.unsigned, @bitSizeOf(T));
+        const UT = @Int(.unsigned, @bitSizeOf(T));
         return .{
             @bitCast(@as(UT, @intCast(out))),
             num,
@@ -1891,7 +1891,7 @@ const BitReader = struct {
     }
 
     fn readBitsTuple(self: *@This(), comptime T: type, num: u16) !Bits(T) {
-        const UT = std.meta.Int(.unsigned, @bitSizeOf(T));
+        const UT = @Int(.unsigned, @bitSizeOf(T));
         const U = if (@bitSizeOf(T) < 8) u8 else UT;
 
         if (num <= self.count) return initBits(T, self.removeBits(@intCast(num)), num);

package/std/crypto/aes_ccm.zig

@@ -171,7 +171,7 @@ fn AesCcm(comptime BlockCipher: type, comptime tag_len: usize, comptime nonce_le
             block[0] = L - 1; // flags
             @memcpy(block[1..][0..nonce_length], &npub);
             // Counter goes in the last L bytes
-            const CounterInt = std.meta.Int(.unsigned, L * 8);
+            const CounterInt = @Int(.unsigned, L * 8);
             mem.writeInt(CounterInt, block[1 + nonce_length ..][0..L], @as(CounterInt, @intCast(counter)), .big);
         }
 
@@ -229,7 +229,7 @@ fn AesCcm(comptime BlockCipher: type, comptime tag_len: usize, comptime nonce_le
             @memcpy(block[1..][0..nonce_length], &npub);
 
             // Encode message length in last L bytes
-            const LengthInt = std.meta.Int(.unsigned, L * 8);
+            const LengthInt = @Int(.unsigned, L * 8);
             mem.writeInt(LengthInt, block[1 + nonce_length ..][0..L], @as(LengthInt, @intCast(msg_len)), .big);
         }
 

package/std/crypto/cmac.zig

@@ -74,7 +74,7 @@ pub fn Cmac(comptime BlockCipher: type) type {
         }
 
         fn double(l: Block) Block {
-            const Int = std.meta.Int(.unsigned, block_length * 8);
+            const Int = @Int(.unsigned, block_length * 8);
             const l_ = mem.readInt(Int, &l, .big);
             const l_2 = switch (block_length) {
                 8 => (l_ << 1) ^ (0x1b & -%(l_ >> 63)), // mod x^64 + x^4 + x^3 + x + 1

package/std/crypto/codecs/asn1/der/Encoder.zig

@@ -129,7 +129,7 @@ fn int(self: *Encoder, comptime T: type, value: T) !void {
     const needs_padding: u1 = if (value == 0)
         1
     else if (bits_needed > 8) brk: {
-        const RightShift = std.meta.Int(.unsigned, @bitSizeOf(@TypeOf(bits_needed)) - 1);
+        const RightShift = @Int(.unsigned, @bitSizeOf(@TypeOf(bits_needed)) - 1);
         const right_shift: RightShift = @intCast(bits_needed - 9);
         break :brk if (value >> right_shift == 0x1ff) 1 else 0;
     } else 0;

package/std/crypto/ff.zig

@@ -10,7 +10,6 @@ const builtin = @import("builtin");
 const crypto = std.crypto;
 const math = std.math;
 const mem = std.mem;
-const meta = std.meta;
 const testing = std.testing;
 const assert = std.debug.assert;
 const Endian = std.builtin.Endian;
@@ -25,7 +24,7 @@ const carry_bits = 1;
 const t_bits: usize = @bitSizeOf(Limb) - carry_bits;
 
 // A TLimb is a Limb that is truncated to t_bits.
-const TLimb = meta.Int(.unsigned, t_bits);
+const TLimb = @Int(.unsigned, t_bits);
 
 const native_endian = builtin.target.cpu.arch.endian();
 
@@ -906,7 +905,7 @@ const ct_protected = struct {
     // Multiplies two limbs and returns the result as a wide limb.
     fn mulWide(x: Limb, y: Limb) WideLimb {
         const half_bits = @typeInfo(Limb).int.bits / 2;
-        const Half = meta.Int(.unsigned, half_bits);
+        const Half = @Int(.unsigned, half_bits);
         const x0 = @as(Half, @truncate(x));
         const x1 = @as(Half, @truncate(x >> half_bits));
         const y0 = @as(Half, @truncate(y));

package/std/crypto/keccak_p.zig

@@ -9,7 +9,7 @@ const mode = @import("builtin").mode;
 /// The Keccak-f permutation.
 pub fn KeccakF(comptime f: u11) type {
     comptime assert(f >= 200 and f <= 1600 and f % 200 == 0); // invalid bit size
-    const T = std.meta.Int(.unsigned, f / 25);
+    const T = @Int(.unsigned, f / 25);
     const Block = [25]T;
 
     const PI = [_]u5{

package/std/crypto/ml_dsa.zig

@@ -3413,7 +3413,7 @@ fn modularInverse(comptime T: type, comptime a: T, comptime p: T) T {
     // Use a signed type for EEA computation
     const type_info = @typeInfo(T);
     const SignedT = if (type_info == .int and type_info.int.signedness == .unsigned)
-        std.meta.Int(.signed, type_info.int.bits)
+        @Int(.signed, type_info.int.bits)
     else
         T;
 
@@ -3436,7 +3436,7 @@ fn modularInverse(comptime T: type, comptime a: T, comptime p: T) T {
 fn modularPow(comptime T: type, comptime a: T, s: T, comptime p: T) T {
     const type_info = @typeInfo(T);
     const bits = type_info.int.bits;
-    const WideT = std.meta.Int(.unsigned, bits * 2);
+    const WideT = @Int(.unsigned, bits * 2);
 
     var ret: T = 1;
     var base: T = a;
@@ -3465,14 +3465,14 @@ fn bitMask(comptime T: type, bit: T) T {
 
 /// Creates a mask from the sign bit of a signed integer.
 /// Returns all 1s (0xFF...FF) if x < 0, all 0s if x >= 0.
-fn signMask(comptime T: type, x: T) std.meta.Int(.unsigned, @typeInfo(T).int.bits) {
+fn signMask(comptime T: type, x: T) @Int(.unsigned, @typeInfo(T).int.bits) {
     const type_info = @typeInfo(T);
     if (type_info != .int) {
         @compileError("signMask requires an integer type");
     }
 
     const bits = type_info.int.bits;
-    const SignedT = std.meta.Int(.signed, bits);
+    const SignedT = @Int(.signed, bits);
 
     // Convert to signed if needed, arithmetic right shift to propagate sign bit
     const x_signed: SignedT = if (type_info.int.signedness == .signed) x else @bitCast(x);
@@ -3499,8 +3499,8 @@ fn montgomeryReduce(
     const m: OutT = @truncate(m_full);
 
     const yR = x -% @as(InT, m) * @as(InT, q);
-    const y_shifted = @as(std.meta.Int(.unsigned, @typeInfo(InT).Int.bits), @bitCast(yR)) >> r_bits;
-    return @bitCast(@as(std.meta.Int(.unsigned, @typeInfo(OutT).Int.bits), @truncate(y_shifted)));
+    const y_shifted = @as(@Int(.unsigned, @typeInfo(InT).Int.bits), @bitCast(yR)) >> r_bits;
+    return @bitCast(@as(@Int(.unsigned, @typeInfo(OutT).Int.bits), @truncate(y_shifted)));
 }
 
 /// Uniform sampling using SHAKE-128 with rejection sampling.

package/std/crypto/ml_kem.zig

@@ -1794,7 +1794,7 @@ fn modularInverse(comptime T: type, comptime a: T, comptime p: T) T {
     // Use a signed type for EEA computation
     const type_info = @typeInfo(T);
     const SignedT = if (type_info == .int and type_info.int.signedness == .unsigned)
-        std.meta.Int(.signed, type_info.int.bits)
+        @Int(.signed, type_info.int.bits)
     else
         T;
 
@@ -1817,7 +1817,7 @@ fn modularInverse(comptime T: type, comptime a: T, comptime p: T) T {
 fn modularPow(comptime T: type, comptime a: T, s: T, comptime p: T) T {
     const type_info = @typeInfo(T);
     const bits = type_info.int.bits;
-    const WideT = std.meta.Int(.unsigned, bits * 2);
+    const WideT = @Int(.unsigned, bits * 2);
 
     var ret: T = 1;
     var base: T = a;
@@ -1846,14 +1846,14 @@ fn bitMask(comptime T: type, bit: T) T {
 
 /// Creates a mask from the sign bit of a signed integer.
 /// Returns all 1s (0xFF...FF) if x < 0, all 0s if x >= 0.
-fn signMask(comptime T: type, x: T) std.meta.Int(.unsigned, @typeInfo(T).int.bits) {
+fn signMask(comptime T: type, x: T) @Int(.unsigned, @typeInfo(T).int.bits) {
     const type_info = @typeInfo(T);
     if (type_info != .int) {
         @compileError("signMask requires an integer type");
     }
 
     const bits = type_info.int.bits;
-    const SignedT = std.meta.Int(.signed, bits);
+    const SignedT = @Int(.signed, bits);
 
     // Convert to signed if needed, arithmetic right shift to propagate sign bit
     const x_signed: SignedT = if (type_info.int.signedness == .signed) x else @bitCast(x);
@@ -1898,8 +1898,8 @@ fn montgomeryReduce(
     const m: OutT = @truncate(m_full);
 
     const yR = x -% @as(InT, m) * @as(InT, q);
-    const y_shifted = @as(std.meta.Int(.unsigned, @typeInfo(InT).Int.bits), @bitCast(yR)) >> r_bits;
-    return @bitCast(@as(std.meta.Int(.unsigned, @typeInfo(OutT).Int.bits), @truncate(y_shifted)));
+    const y_shifted = @as(@Int(.unsigned, @typeInfo(InT).Int.bits), @bitCast(yR)) >> r_bits;
+    return @bitCast(@as(@Int(.unsigned, @typeInfo(OutT).Int.bits), @truncate(y_shifted)));
 }
 
 /// Uniform sampling using SHAKE-128 with rejection sampling.

package/std/crypto/modes.zig

@@ -40,7 +40,7 @@ pub fn ctrSlice(
     var counterBlock = iv;
     var i: usize = 0;
 
-    const CounterInt = std.meta.Int(.unsigned, counter_size * 8);
+    const CounterInt = @Int(.unsigned, counter_size * 8);
 
     const parallel_count = BlockCipher.block.parallel.optimal_parallel_blocks;
     const wide_block_length = parallel_count * block_length;

package/std/crypto/pcurves/common.zig

@@ -2,7 +2,6 @@ const std = @import("std");
 const crypto = std.crypto;
 const debug = std.debug;
 const mem = std.mem;
-const meta = std.meta;
 
 const NonCanonicalError = crypto.errors.NonCanonicalError;
 const NotSquareError = crypto.errors.NotSquareError;
@@ -54,7 +53,7 @@ pub fn Field(comptime params: FieldParams) type {
             var s = if (endian == .little) s_ else orderSwap(s_);
             const field_order_s = comptime fos: {
                 var fos: [encoded_length]u8 = undefined;
-                mem.writeInt(std.meta.Int(.unsigned, encoded_length * 8), &fos, field_order, .little);
+                mem.writeInt(@Int(.unsigned, encoded_length * 8), &fos, field_order, .little);
                 break :fos fos;
             };
             if (crypto.timing_safe.compare(u8, &s, &field_order_s, .little) != .lt) {
@@ -90,7 +89,7 @@ pub fn Field(comptime params: FieldParams) type {
         }
 
         /// Element as an integer.
-        pub const IntRepr = meta.Int(.unsigned, params.field_bits);
+        pub const IntRepr = @Int(.unsigned, params.field_bits);
 
         /// Create a field element from an integer.
         pub fn fromInt(comptime x: IntRepr) NonCanonicalError!Fe {
@@ -270,7 +269,7 @@ pub fn Field(comptime params: FieldParams) type {
                 const ls = x126.sqn(126).mul(x126).sqn(3).mul(t111).sqn(33).mul(x32).sqn(95).mul(x31);
                 return ls.equivalent(Fe.one);
             } else {
-                const ls = x2.pow(std.meta.Int(.unsigned, field_bits), (field_order - 1) / 2); // Legendre symbol
+                const ls = x2.pow(@Int(.unsigned, field_bits), (field_order - 1) / 2); // Legendre symbol
                 return ls.equivalent(Fe.one);
             }
         }
@@ -307,7 +306,7 @@ pub fn Field(comptime params: FieldParams) type {
                 const x108 = x54.sqn(54).mul(x54);
                 return x108.sqn(108).mul(x108).sqn(7).mul(t1111111).sqn(23).mul(x22).sqn(6).mul(t11).sqn(2);
             } else {
-                return x2.pow(std.meta.Int(.unsigned, field_bits), (field_order + 1) / 4);
+                return x2.pow(@Int(.unsigned, field_bits), (field_order + 1) / 4);
             }
         }
 

package/std/crypto/timing_safe.zig

@@ -21,8 +21,8 @@ pub fn eql(comptime T: type, a: T, b: T) bool {
                 acc |= x ^ b[i];
             }
             const s = @typeInfo(C).int.bits;
-            const Cu = std.meta.Int(.unsigned, s);
-            const Cext = std.meta.Int(.unsigned, s + 1);
+            const Cu = @Int(.unsigned, s);
+            const Cext = @Int(.unsigned, s + 1);
             return @as(bool, @bitCast(@as(u1, @truncate((@as(Cext, @as(Cu, @bitCast(acc))) -% 1) >> s))));
         },
         .vector => |info| {
@@ -32,8 +32,8 @@ pub fn eql(comptime T: type, a: T, b: T) bool {
             }
             const acc = @reduce(.Or, a ^ b);
             const s = @typeInfo(C).int.bits;
-            const Cu = std.meta.Int(.unsigned, s);
-            const Cext = std.meta.Int(.unsigned, s + 1);
+            const Cu = @Int(.unsigned, s);
+            const Cext = @Int(.unsigned, s + 1);
             return @as(bool, @bitCast(@as(u1, @truncate((@as(Cext, @as(Cu, @bitCast(acc))) -% 1) >> s))));
         },
         else => {
@@ -50,7 +50,7 @@ pub fn compare(comptime T: type, a: []const T, b: []const T, endian: Endian) Ord
         .int => |cinfo| if (cinfo.signedness != .unsigned) @compileError("Elements to be compared must be unsigned") else cinfo.bits,
         else => @compileError("Elements to be compared must be integers"),
     };
-    const Cext = std.meta.Int(.unsigned, bits + 1);
+    const Cext = @Int(.unsigned, bits + 1);
     var gt: T = 0;
     var eq: T = 1;
     if (endian == .little) {

package/std/debug.zig

@@ -258,6 +258,9 @@ pub const sys_can_stack_trace = switch (builtin.cpu.arch) {
     .bpfeb,
     => false,
 
+    // https://codeberg.org/ziglang/zig/issues/31127
+    .avr => false,
+
     else => true,
 };
 
@@ -517,7 +520,7 @@ pub fn defaultPanic(msg: []const u8, first_trace_addr: ?usize) noreturn {
 
             if (uefi.system_table.boot_services) |bs| {
                 // ExitData buffer must be allocated using boot_services.allocatePool (spec: page 220)
-                const exit_data = uefi.raw_pool_allocator.dupeZ(u16, exit_msg) catch @trap();
+                const exit_data = uefi.raw_pool_allocator.dupeSentinel(u16, exit_msg, 0) catch @trap();
                 bs.exit(uefi.handle, .aborted, exit_data) catch {};
             }
             @trap();

package/std/enums.zig

@@ -1291,7 +1291,7 @@ pub fn EnumIndexer(comptime E: type) type {
             const min_value = std.math.minInt(BackingInt);
             const max_value = std.math.maxInt(BackingInt);
 
-            const RangeType = std.meta.Int(.unsigned, @bitSizeOf(BackingInt));
+            const RangeType = @Int(.unsigned, @bitSizeOf(BackingInt));
             pub const count: comptime_int = std.math.maxInt(RangeType) + 1;
 
             pub fn indexOf(e: E) usize {
@@ -1307,7 +1307,7 @@ pub fn EnumIndexer(comptime E: type) type {
                 if (backing_int_sign == .unsigned)
                     return @enumFromInt(i);
 
-                return @enumFromInt(@as(std.meta.Int(.signed, @bitSizeOf(RangeType) + 1), @intCast(i)) + min_value);
+                return @enumFromInt(@as(@Int(.signed, @bitSizeOf(RangeType) + 1), @intCast(i)) + min_value);
             }
         };
     }
@@ -1380,14 +1380,14 @@ test "EnumIndexer non-exhaustive" {
         i4,
         i8,
         i16,
-        std.meta.Int(.signed, @bitSizeOf(isize) - 1),
+        @Int(.signed, @bitSizeOf(isize) - 1),
         isize,
         u1,
         u2,
         u3,
         u4,
         u16,
-        std.meta.Int(.unsigned, @bitSizeOf(usize) - 1),
+        @Int(.unsigned, @bitSizeOf(usize) - 1),
         usize,
     };
     inline for (backing_ints) |BackingInt| {
@@ -1400,7 +1400,7 @@ test "EnumIndexer non-exhaustive" {
         const min_tag: E = @enumFromInt(std.math.minInt(BackingInt));
         const max_tag: E = @enumFromInt(std.math.maxInt(BackingInt));
 
-        const RangedType = std.meta.Int(.unsigned, @bitSizeOf(BackingInt));
+        const RangedType = @Int(.unsigned, @bitSizeOf(BackingInt));
         const max_index: comptime_int = std.math.maxInt(RangedType);
         const number_zero_tag_index: usize = switch (@typeInfo(BackingInt).int.signedness) {
             .unsigned => 0,

package/std/fmt/parse_float.zig

@@ -128,7 +128,7 @@ test parseFloat {
 
 test "nan and inf" {
     inline for ([_]type{ f16, f32, f64, f80, f128 }) |T| {
-        const Z = std.meta.Int(.unsigned, @typeInfo(T).float.bits);
+        const Z = @Int(.unsigned, @typeInfo(T).float.bits);
 
         try expectEqual(@as(Z, @bitCast(try parseFloat(T, "nAn"))), @as(Z, @bitCast(std.math.nan(T))));
         try expectEqual(try parseFloat(T, "inF"), std.math.inf(T));

package/std/fmt.zig

@@ -433,7 +433,7 @@ fn parseIntWithSign(
     // accumulate into Accumulate which is always 8 bits or larger.  this prevents
     // `buf_base` from overflowing Result.
     const info = @typeInfo(Result);
-    const Accumulate = std.meta.Int(info.int.signedness, @max(8, info.int.bits));
+    const Accumulate = @Int(info.int.signedness, @max(8, info.int.bits));
     var accumulate: Accumulate = 0;
 
     if (buf_start[0] == '_' or buf_start[buf_start.len - 1] == '_') return error.InvalidCharacter;
@@ -602,11 +602,6 @@ pub fn bufPrint(buf: []u8, comptime fmt: []const u8, args: anytype) BufPrintErro
     return w.buffered();
 }
 
-/// Deprecated in favor of `bufPrintSentinel`
-pub fn bufPrintZ(buf: []u8, comptime fmt: []const u8, args: anytype) BufPrintError![:0]u8 {
-    return try bufPrintSentinel(buf, fmt, args, 0);
-}
-
 pub fn bufPrintSentinel(
     buf: []u8,
     comptime fmt: []const u8,

package/std/hash/wyhash.zig

@@ -130,7 +130,7 @@ pub const Wyhash = struct {
 
     inline fn read(comptime bytes: usize, data: []const u8) u64 {
         std.debug.assert(bytes <= 8);
-        const T = std.meta.Int(.unsigned, 8 * bytes);
+        const T = @Int(.unsigned, 8 * bytes);
         return @as(u64, std.mem.readInt(T, data[0..bytes], .little));
     }
 

package/std/hash_map.zig

@@ -1271,7 +1271,7 @@ pub fn HashMapUnmanaged(
             // map, which is assumed to exist as key_ptr must be valid.  This
             // item must be at index 0.
             const idx = if (@sizeOf(K) > 0)
-                (key_ptr - self.keys())
+                @as([*]K, @ptrCast(key_ptr)) - self.keys()
             else
                 0;
 
@@ -2175,3 +2175,22 @@ test "rehash" {
         }
     }
 }
+
+test "removeByPtr, key is array" {
+    const gpa = testing.allocator;
+
+    var map: AutoHashMapUnmanaged([2]u32, u32) = .empty;
+    defer map.deinit(gpa);
+
+    const key: [2]u32 = .{ 1, 2 };
+    try map.put(gpa, key, 3);
+
+    try expectEqual(1, map.count());
+    try expectEqual(3, map.get(key));
+
+    const key_ptr = map.getKeyPtr(key).?;
+    map.removeByPtr(key_ptr);
+
+    try expectEqual(0, map.count());
+    try expectEqual(null, map.get(key));
+}

package/std/heap/debug_allocator.zig

@@ -189,7 +189,7 @@ pub fn DebugAllocator(comptime config: Config) type {
         const page_size = config.page_size;
         const page_align: mem.Alignment = .fromByteUnits(page_size);
         /// Integer type for pointing to slots in a small allocation
-        const SlotIndex = std.meta.Int(.unsigned, math.log2(page_size) + 1);
+        const SlotIndex = @Int(.unsigned, math.log2(page_size) + 1);
 
         const total_requested_bytes_init = if (config.enable_memory_limit) @as(usize, 0) else {};
         const requested_memory_limit_init = if (config.enable_memory_limit) @as(usize, math.maxInt(usize)) else {};

package/std/{builtin.zig → lang.zig}

@@ -4,7 +4,7 @@ const builtin = @import("builtin");
 const std = @import("std.zig");
 const root = @import("root");
 
-pub const assembly = @import("builtin/assembly.zig");
+pub const assembly = @import("lang/assembly.zig");
 
 /// This data structure is used by the Zig language code generation and
 /// therefore must be kept in sync with the compiler implementation.

package/std/leb128.zig

@@ -9,7 +9,7 @@ const testing = std.testing;
 /// An example use case of this is in emitting DWARF info where one wants to make a ULEB128 field
 /// "relocatable", meaning that it becomes possible to later go back and patch the number to be a
 /// different value without shifting all the following code.
-pub fn writeUnsignedFixed(comptime l: usize, ptr: *[l]u8, int: std.meta.Int(.unsigned, l * 7)) void {
+pub fn writeUnsignedFixed(comptime l: usize, ptr: *[l]u8, int: @Int(.unsigned, l * 7)) void {
     writeUnsignedExtended(ptr, int);
 }
 
@@ -65,7 +65,7 @@ test writeUnsignedFixed {
 /// An example use case of this is in emitting DWARF info where one wants to make a ILEB128 field
 /// "relocatable", meaning that it becomes possible to later go back and patch the number to be a
 /// different value without shifting all the following code.
-pub fn writeSignedFixed(comptime l: usize, ptr: *[l]u8, int: std.meta.Int(.signed, l * 7)) void {
+pub fn writeSignedFixed(comptime l: usize, ptr: *[l]u8, int: @Int(.signed, l * 7)) void {
     const T = @TypeOf(int);
     const U = if (@typeInfo(T).int.bits < 8) u8 else T;
     var value: U = @intCast(int);

package/std/math/big/int.zig

@@ -2047,7 +2047,7 @@ pub const Mutable = struct {
             var limb = switch (signedness) {
                 .unsigned => mem.readVarPackedInt(Limb, buffer, bit_index + bit_offset, bit_count - bit_index, endian, .unsigned),
                 .signed => b: {
-                    const SLimb = std.meta.Int(.signed, @bitSizeOf(Limb));
+                    const SLimb = @Int(.signed, @bitSizeOf(Limb));
                     const limb = mem.readVarPackedInt(SLimb, buffer, bit_index + bit_offset, bit_count - bit_index, endian, .signed);
                     break :b @as(Limb, @bitCast(limb));
                 },
@@ -2284,7 +2284,7 @@ pub const Const = struct {
                 // Make sure -0 is handled correctly.
                 if (self.eqlZero()) return 0;
 
-                const Unsigned = std.meta.Int(.unsigned, info.bits);
+                const Unsigned = @Int(.unsigned, info.bits);
 
                 if (!self.fitsInTwosComp(info.signedness, info.bits)) {
                     return error.TargetTooSmall;

package/std/math/big.zig

@@ -4,10 +4,10 @@ const assert = std.debug.assert;
 pub const int = @import("big/int.zig");
 pub const Limb = usize;
 const limb_info = @typeInfo(Limb).int;
-pub const SignedLimb = std.meta.Int(.signed, limb_info.bits);
-pub const DoubleLimb = std.meta.Int(.unsigned, 2 * limb_info.bits);
-pub const HalfLimb = std.meta.Int(.unsigned, limb_info.bits / 2);
-pub const SignedDoubleLimb = std.meta.Int(.signed, 2 * limb_info.bits);
+pub const SignedLimb = @Int(.signed, limb_info.bits);
+pub const DoubleLimb = @Int(.unsigned, 2 * limb_info.bits);
+pub const HalfLimb = @Int(.unsigned, limb_info.bits / 2);
+pub const SignedDoubleLimb = @Int(.signed, 2 * limb_info.bits);
 pub const Log2Limb = std.math.Log2Int(Limb);
 
 comptime {

package/std/math/copysign.zig

@@ -5,7 +5,7 @@ const expect = std.testing.expect;
 /// Returns a value with the magnitude of `magnitude` and the sign of `sign`.
 pub fn copysign(magnitude: anytype, sign: @TypeOf(magnitude)) @TypeOf(magnitude) {
     const T = @TypeOf(magnitude);
-    const TBits = std.meta.Int(.unsigned, @typeInfo(T).float.bits);
+    const TBits = @Int(.unsigned, @typeInfo(T).float.bits);
     const sign_bit_mask = @as(TBits, 1) << (@bitSizeOf(T) - 1);
     const mag = @as(TBits, @bitCast(magnitude)) & ~sign_bit_mask;
     const sgn = @as(TBits, @bitCast(sign)) & sign_bit_mask;

package/std/math/frexp.zig

@@ -22,16 +22,16 @@ pub fn frexp(x: anytype) Frexp(@TypeOf(x)) {
     const T: type = @TypeOf(x);
 
     const bits: comptime_int = @typeInfo(T).float.bits;
-    const Int: type = std.meta.Int(.unsigned, bits);
+    const Int: type = @Int(.unsigned, bits);
 
     const exp_bits: comptime_int = math.floatExponentBits(T);
     const mant_bits: comptime_int = math.floatMantissaBits(T);
     const frac_bits: comptime_int = math.floatFractionalBits(T);
     const exp_min: comptime_int = math.floatExponentMin(T);
 
-    const ExpInt: type = std.meta.Int(.unsigned, exp_bits);
-    const MantInt: type = std.meta.Int(.unsigned, mant_bits);
-    const FracInt: type = std.meta.Int(.unsigned, frac_bits);
+    const ExpInt: type = @Int(.unsigned, exp_bits);
+    const MantInt: type = @Int(.unsigned, mant_bits);
+    const FracInt: type = @Int(.unsigned, frac_bits);
 
     const unreal_exponent: comptime_int = (1 << exp_bits) - 1;
     const bias: comptime_int = (1 << (exp_bits - 1)) - 2;

package/std/math/ilogb.zig

@@ -30,7 +30,7 @@ fn ilogbX(comptime T: type, x: T) i32 {
     const significandBits = math.floatMantissaBits(T);
     const exponentBits = math.floatExponentBits(T);
 
-    const Z = std.meta.Int(.unsigned, typeWidth);
+    const Z = @Int(.unsigned, typeWidth);
 
     const signBit = (@as(Z, 1) << (significandBits + exponentBits));
     const maxExponent = ((1 << exponentBits) - 1);

package/std/math/isfinite.zig

@@ -5,7 +5,7 @@ const expect = std.testing.expect;
 /// Returns whether x is a finite value.
 pub fn isFinite(x: anytype) bool {
     const T = @TypeOf(x);
-    const TBits = std.meta.Int(.unsigned, @typeInfo(T).float.bits);
+    const TBits = @Int(.unsigned, @typeInfo(T).float.bits);
     const remove_sign = ~@as(TBits, 0) >> 1;
     return @as(TBits, @bitCast(x)) & remove_sign < @as(TBits, @bitCast(math.inf(T)));
 }

package/std/math/isinf.zig

@@ -5,7 +5,7 @@ const expect = std.testing.expect;
 /// Returns whether x is an infinity, ignoring sign.
 pub inline fn isInf(x: anytype) bool {
     const T = @TypeOf(x);
-    const TBits = std.meta.Int(.unsigned, @typeInfo(T).float.bits);
+    const TBits = @Int(.unsigned, @typeInfo(T).float.bits);
     const remove_sign = ~@as(TBits, 0) >> 1;
     return @as(TBits, @bitCast(x)) & remove_sign == @as(TBits, @bitCast(math.inf(T)));
 }

package/std/math/isnan.zig

@@ -1,7 +1,6 @@
 const std = @import("../std.zig");
 const builtin = @import("builtin");
 const math = std.math;
-const meta = std.meta;
 const expect = std.testing.expect;
 
 pub fn isNan(x: anytype) bool {
@@ -12,7 +11,7 @@ pub fn isNan(x: anytype) bool {
 ///       this is tracked by https://github.com/ziglang/zig/issues/14366
 pub fn isSignalNan(x: anytype) bool {
     const T = @TypeOf(x);
-    const U = meta.Int(.unsigned, @bitSizeOf(T));
+    const U = @Int(.unsigned, @bitSizeOf(T));
     const quiet_signal_bit_mask = 1 << (math.floatFractionalBits(T) - 1);
     return isNan(x) and (@as(U, @bitCast(x)) & quiet_signal_bit_mask == 0);
 }

package/std/math/isnormal.zig

@@ -5,7 +5,7 @@ const expect = std.testing.expect;
 /// Returns whether x is neither zero, subnormal, infinity, or NaN.
 pub fn isNormal(x: anytype) bool {
     const T = @TypeOf(x);
-    const TBits = std.meta.Int(.unsigned, @typeInfo(T).float.bits);
+    const TBits = @Int(.unsigned, @typeInfo(T).float.bits);
 
     const increment_exp = 1 << math.floatMantissaBits(T);
     const remove_sign = ~@as(TBits, 0) >> 1;
@@ -22,7 +22,7 @@ pub fn isNormal(x: anytype) bool {
 test isNormal {
     // TODO add `c_longdouble' when math.inf(T) supports it
     inline for ([_]type{ f16, f32, f64, f80, f128 }) |T| {
-        const TBits = std.meta.Int(.unsigned, @bitSizeOf(T));
+        const TBits = @Int(.unsigned, @bitSizeOf(T));
 
         // normals
         try expect(isNormal(@as(T, 1.0)));

package/std/math/iszero.zig

@@ -6,7 +6,7 @@ const expect = std.testing.expect;
 pub inline fn isPositiveZero(x: anytype) bool {
     const T = @TypeOf(x);
     const bit_count = @typeInfo(T).float.bits;
-    const TBits = std.meta.Int(.unsigned, bit_count);
+    const TBits = @Int(.unsigned, bit_count);
     return @as(TBits, @bitCast(x)) == @as(TBits, 0);
 }
 
@@ -14,7 +14,7 @@ pub inline fn isPositiveZero(x: anytype) bool {
 pub inline fn isNegativeZero(x: anytype) bool {
     const T = @TypeOf(x);
     const bit_count = @typeInfo(T).float.bits;
-    const TBits = std.meta.Int(.unsigned, bit_count);
+    const TBits = @Int(.unsigned, bit_count);
     return @as(TBits, @bitCast(x)) == @as(TBits, 1) << (bit_count - 1);
 }
 

package/std/math/ldexp.zig

@@ -7,7 +7,7 @@ const expect = std.testing.expect;
 /// Returns x * 2^n.
 pub fn ldexp(x: anytype, n: i32) @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 exponent_bits = math.floatExponentBits(T);
     const mantissa_bits = math.floatMantissaBits(T);
@@ -103,7 +103,7 @@ test ldexp {
 
         // Multiplications might flush the denormals to zero, esp. at
         // runtime, so we manually construct the constants here instead.
-        const Z = std.meta.Int(.unsigned, @bitSizeOf(T));
+        const Z = @Int(.unsigned, @bitSizeOf(T));
         const EightTimesTrueMin = @as(T, @bitCast(@as(Z, 8)));
         const TwoTimesTrueMin = @as(T, @bitCast(@as(Z, 2)));