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

package/std/http/Client.zig

@@ -4,8 +4,6 @@
 //!
 //! TLS support may be disabled via `std.options.http_disable_tls`.
 //!
-//! TODO all the lockUncancelable in this file should be changed to regular lock and
-//! `error.Canceled` added to more error sets.
 const Client = @This();
 
 const builtin = @import("builtin");
@@ -84,8 +82,8 @@ pub const ConnectionPool = struct {
     /// If no connection is found, null is returned.
     ///
     /// Threadsafe.
-    pub fn findConnection(pool: *ConnectionPool, io: Io, criteria: Criteria) ?*Connection {
-        pool.mutex.lockUncancelable(io);
+    pub fn findConnection(pool: *ConnectionPool, io: Io, criteria: Criteria) Io.Cancelable!?*Connection {
+        try pool.mutex.lock(io);
         defer pool.mutex.unlock(io);
 
         var next = pool.free.last;
@@ -113,8 +111,8 @@ pub const ConnectionPool = struct {
     }
 
     /// Acquires an existing connection from the connection pool. This function is threadsafe.
-    pub fn acquire(pool: *ConnectionPool, io: Io, connection: *Connection) void {
-        pool.mutex.lockUncancelable(io);
+    pub fn acquire(pool: *ConnectionPool, io: Io, connection: *Connection) Io.Cancelable!void {
+        try pool.mutex.lock(io);
         defer pool.mutex.unlock(io);
 
         return pool.acquireUnsafe(connection);
@@ -150,8 +148,8 @@ pub const ConnectionPool = struct {
     }
 
     /// Adds a newly created node to the pool of used connections. This function is threadsafe.
-    pub fn addUsed(pool: *ConnectionPool, io: Io, connection: *Connection) void {
-        pool.mutex.lockUncancelable(io);
+    pub fn addUsed(pool: *ConnectionPool, io: Io, connection: *Connection) Io.Cancelable!void {
+        try pool.mutex.lock(io);
         defer pool.mutex.unlock(io);
 
         pool.used.append(&connection.pool_node);
@@ -162,18 +160,15 @@ pub const ConnectionPool = struct {
     /// If the new size is smaller than the current size, then idle connections will be closed until the pool is the new size.
     ///
     /// Threadsafe.
-    pub fn resize(pool: *ConnectionPool, io: Io, allocator: Allocator, new_size: usize) void {
-        pool.mutex.lockUncancelable(io);
+    pub fn resize(pool: *ConnectionPool, io: Io, new_size: usize) Io.Cancelable!void {
+        try pool.mutex.lock(io);
         defer pool.mutex.unlock(io);
 
-        const next = pool.free.first;
-        _ = next;
         while (pool.free_len > new_size) {
-            const popped = pool.free.popFirst() orelse unreachable;
+            const popped: *Connection = @alignCast(@fieldParentPtr("pool_node", pool.free.popFirst().?));
             pool.free_len -= 1;
 
-            popped.data.close(allocator);
-            allocator.destroy(popped);
+            popped.destroy(io);
         }
 
         pool.free_size = new_size;
@@ -1323,7 +1318,7 @@ pub fn initDefaultProxies(client: *Client, arena: Allocator, environ_map: *const
     const io = client.io;
 
     // Prevent any new connections from being created.
-    client.connection_pool.mutex.lockUncancelable(io);
+    try client.connection_pool.mutex.lock(io);
     defer client.connection_pool.mutex.unlock(io);
 
     assert(client.connection_pool.used.first == null); // There are active requests.
@@ -1418,7 +1413,7 @@ pub const basic_authorization = struct {
 
 pub const ConnectTcpError = error{
     TlsInitializationFailed,
-} || Allocator.Error || HostName.ConnectError;
+} || Allocator.Error || HostName.ConnectError || Io.Cancelable;
 
 /// Reuses a `Connection` if one matching `host` and `port` is already open.
 ///
@@ -1451,7 +1446,7 @@ pub fn connectTcpOptions(client: *Client, options: ConnectTcpOptions) ConnectTcp
     const proxied_host = options.proxied_host orelse host;
     const proxied_port = options.proxied_port orelse port;
 
-    if (client.connection_pool.findConnection(io, .{
+    if (try client.connection_pool.findConnection(io, .{
         .host = proxied_host,
         .port = proxied_port,
         .protocol = protocol,
@@ -1469,18 +1464,20 @@ pub fn connectTcpOptions(client: *Client, options: ConnectTcpOptions) ConnectTcp
                 error.Canceled => |e| return e,
                 else => return error.TlsInitializationFailed,
             };
-            client.connection_pool.addUsed(io, &tc.connection);
+            errdefer tc.destroy();
+            try client.connection_pool.addUsed(io, &tc.connection);
             return &tc.connection;
         },
         .plain => {
             const pc = try Connection.Plain.create(client, proxied_host, proxied_port, stream);
-            client.connection_pool.addUsed(io, &pc.connection);
+            errdefer pc.destroy();
+            try client.connection_pool.addUsed(io, &pc.connection);
             return &pc.connection;
         },
     }
 }
 
-pub const ConnectUnixError = Allocator.Error || std.posix.SocketError || error{NameTooLong} || std.posix.ConnectError;
+pub const ConnectUnixError = Allocator.Error || std.posix.SocketError || error{NameTooLong} || std.posix.ConnectError || Io.Cancelable;
 
 /// Connect to `path` as a unix domain socket. This will reuse a connection if one is already open.
 ///
@@ -1488,7 +1485,7 @@ pub const ConnectUnixError = Allocator.Error || std.posix.SocketError || error{N
 pub fn connectUnix(client: *Client, path: []const u8) ConnectUnixError!*Connection {
     const io = client.io;
 
-    if (client.connection_pool.findConnection(io, .{
+    if (try client.connection_pool.findConnection(io, .{
         .host = path,
         .port = 0,
         .protocol = .plain,
@@ -1512,7 +1509,7 @@ pub fn connectUnix(client: *Client, path: []const u8) ConnectUnixError!*Connecti
     };
     errdefer client.allocator.free(conn.data.host);
 
-    client.connection_pool.addUsed(conn);
+    try client.connection_pool.addUsed(conn);
 
     return &conn.data;
 }
@@ -1530,7 +1527,7 @@ pub fn connectProxied(
     const io = client.io;
     if (!proxy.supports_connect) return error.TunnelNotSupported;
 
-    if (client.connection_pool.findConnection(io, .{
+    if (try client.connection_pool.findConnection(io, .{
         .host = proxied_host,
         .port = proxied_port,
         .protocol = proxy.protocol,

package/std/http.zig

@@ -400,7 +400,7 @@ pub const Reader = struct {
                         0 => return error.HttpConnectionClosing,
                         else => return error.HttpRequestTruncated,
                     },
-                    error.ReadFailed => return error.ReadFailed,
+                    error.ReadFailed => |e| return e,
                 };
                 continue;
             }
@@ -543,8 +543,7 @@ pub const Reader = struct {
             else => unreachable,
         };
         return chunkedReadEndless(reader, w, limit, chunk_len_ptr) catch |err| switch (err) {
-            error.ReadFailed => return error.ReadFailed,
-            error.WriteFailed => return error.WriteFailed,
+            error.ReadFailed, error.WriteFailed => |e| return e,
             error.EndOfStream => {
                 reader.body_err = error.HttpChunkTruncated;
                 return error.ReadFailed;
@@ -613,7 +612,7 @@ pub const Reader = struct {
             else => unreachable,
         };
         return chunkedDiscardEndless(reader, limit, chunk_len_ptr) catch |err| switch (err) {
-            error.ReadFailed => return error.ReadFailed,
+            error.ReadFailed => |e| return e,
             error.EndOfStream => {
                 reader.body_err = error.HttpChunkTruncated;
                 return error.ReadFailed;
@@ -750,7 +749,7 @@ pub const BodyWriter = struct {
     /// How many zeroes to reserve for hex-encoded chunk length.
     const chunk_len_digits = 8;
     const max_chunk_len: usize = std.math.pow(u64, 16, chunk_len_digits) - 1;
-    const chunk_header_template = ("0" ** chunk_len_digits) ++ "\r\n";
+    const chunk_header_template = @as([chunk_len_digits]u8, @splat('0')) ++ "\r\n";
 
     comptime {
         assert(max_chunk_len == std.math.maxInt(u32));

package/std/json/Scanner.zig

@@ -1401,7 +1401,7 @@ pub fn validate(allocator: Allocator, s: []const u8) Allocator.Error!bool {
     while (true) {
         const token = scanner.next() catch |err| switch (err) {
             error.SyntaxError, error.UnexpectedEndOfInput => return false,
-            error.OutOfMemory => return error.OutOfMemory,
+            error.OutOfMemory => |e| return e,
             error.BufferUnderrun => unreachable,
         };
         if (token == .end_of_document) break;
@@ -1734,7 +1734,7 @@ pub const Reader = struct {
 
     fn refillBuffer(self: *@This()) std.Io.Reader.Error!void {
         const input = self.reader.peekGreedy(1) catch |err| switch (err) {
-            error.ReadFailed => return error.ReadFailed,
+            error.ReadFailed => |e| return e,
             error.EndOfStream => return self.scanner.endInput(),
         };
         self.reader.toss(input.len);

package/std/json/static.zig

@@ -334,7 +334,7 @@ pub fn innerParse(
             if (.object_begin != try source.next()) return error.UnexpectedToken;
 
             var r: T = undefined;
-            var fields_seen = [_]bool{false} ** structInfo.fields.len;
+            var fields_seen: [structInfo.fields.len]bool = @splat(false);
 
             while (true) {
                 var name_token: ?Token = try source.nextAllocMax(allocator, .alloc_if_needed, options.max_value_len.?);
@@ -649,7 +649,7 @@ pub fn innerParseFromValue(
             if (source != .object) return error.UnexpectedToken;
 
             var r: T = undefined;
-            var fields_seen = [_]bool{false} ** structInfo.fields.len;
+            var fields_seen: [structInfo.fields.len]bool = @splat(false);
 
             var it = source.object.iterator();
             while (it.next()) |kv| {

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.
@@ -341,6 +341,10 @@ pub const CallingConvention = union(enum(u8)) {
     spirv_fragment,
     spirv_vertex,
 
+    // Calling conventions for the `ez80` architecture.
+    ez80_cet,
+    ez80_tiflags,
+
     /// Options shared across most calling conventions.
     pub const CommonOptions = struct {
         /// The boundary the stack is aligned to when the function is called.

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

@@ -29,8 +29,8 @@ const Constants = struct {
 };
 const constants: Constants = blk: {
     @setEvalBranchQuota(2000);
-    var digits_per_limb = [_]u8{0} ** 37;
-    var bases = [_]Limb{0} ** 37;
+    var digits_per_limb: [37]u8 = @splat(0);
+    var bases: [37]Limb = @splat(0);
     for (2..37) |base| {
         digits_per_limb[base] = @intCast(math.log(Limb, base, math.maxInt(Limb)));
         bases[base] = std.math.pow(Limb, base, digits_per_limb[base]);
@@ -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;
@@ -2391,7 +2391,7 @@ pub const Const = struct {
         var limbs: [calcToStringLimbsBufferLen(available_len, 10)]Limb = undefined;
 
         const biggest: Const = .{
-            .limbs = &([1]Limb{comptime math.maxInt(Limb)} ** available_len),
+            .limbs = &@as([available_len]Limb, @splat(comptime math.maxInt(Limb))),
             .positive = false,
         };
         var buf: [biggest.sizeInBaseUpperBound(2)]u8 = undefined;

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/float.zig

@@ -4,6 +4,68 @@ const assert = std.debug.assert;
 const expect = std.testing.expect;
 const expectEqual = std.testing.expectEqual;
 
+/// A namespace for functions that deal with floats that provide greater than
+/// double precision (`f80`, `f128`, `c_longdouble`). Commonly referred to as
+/// `long double` in C.
+pub const long_double = struct {
+    const U80 = @Int(.unsigned, 80);
+
+    inline fn bitWidth(x: anytype) u16 {
+        const T = @TypeOf(x);
+        return switch (T) {
+            f80, f128, c_longdouble => @typeInfo(T).float.bits,
+            else => @compileError("Unsupported type: " ++ @typeName(T) ++ "\nPass a `f80`, `f128`, or `c_longdouble`."),
+        };
+    }
+
+    /// Returns the sign + exponent bits of a `long double`.
+    pub fn signExponent(x: anytype) u16 {
+        const bit_width = bitWidth(x);
+        switch (bit_width) {
+            80 => {
+                const bits: U80 = @bitCast(x);
+                return @intCast(bits >> 64);
+            },
+            128 => {
+                const bits: u128 = @bitCast(x);
+                return @intCast(bits >> 112);
+            },
+            // `c_longdouble` can have <80 bits on some targets, we want to error on that
+            else => @compileError(std.fmt.comptimePrint("`signExponent` supports floats of only `80` and `128` bit width, got bit width: {d}", .{bit_width})),
+        }
+    }
+
+    test "signExponent" {
+        try expectEqual(signExponent(@as(f80, -0.0)), 0x8000);
+        try expectEqual(signExponent(@as(f128, 0.0)), 0x0000);
+        try expectEqual(signExponent(@as(f128, 42.0)), 0x4004);
+        try expectEqual(signExponent(nan(c_longdouble)), 0x7FFF);
+    }
+
+    /// Takes the top 16 bits of a `long double`'s mantissa.
+    pub fn mantissaTop(x: anytype) u16 {
+        const bit_width = bitWidth(x);
+        switch (bit_width) {
+            80 => {
+                const bits: U80 = @bitCast(x);
+                return @intCast((bits >> 48) & 0xFFFF);
+            },
+            128 => {
+                const bits: u128 = @bitCast(x);
+                return @intCast((bits >> 96) & 0xFFFF);
+            },
+            // `c_longdouble` can have <80 bits on some targets, we want to error on that
+            else => @compileError(std.fmt.comptimePrint("`mantissaTop` supports floats of only `80` and `128` bit width, got bit width: {d}", .{bit_width})),
+        }
+    }
+
+    test "mantissaTop" {
+        try expectEqual(mantissaTop(@as(f80, -0.0)), 0x0000);
+        try expectEqual(mantissaTop(nan(f128)), 0x8000);
+        try expectEqual(mantissaTop(@as(f128, 42.0)), 0x5000);
+    }
+};
+
 pub fn FloatRepr(comptime Float: type) type {
     const fractional_bits = floatFractionalBits(Float);
     const exponent_bits = floatExponentBits(Float);

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)));
 

package/std/math/log10.zig

@@ -139,8 +139,6 @@ test log10_int {
     if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
-    if (builtin.zig_backend == .stage2_llvm and comptime builtin.target.cpu.arch.isWasm()) return error.SkipZigTest; // TODO
-    if (builtin.zig_backend == .stage2_llvm and comptime builtin.target.cpu.arch == .hexagon) return error.SkipZigTest;
 
     inline for (
         .{ u8, u16, u32, u64, u128, u256, u512 },

package/std/math/modf.zig

@@ -86,8 +86,7 @@ fn ModfTests(comptime T: type) type {
         }
         test "vector" {
             if (builtin.os.tag.isDarwin() and builtin.cpu.arch == .aarch64) return error.SkipZigTest;
-            if (builtin.cpu.arch == .s390x) return error.SkipZigTest;
-            if (comptime builtin.cpu.has(.loongarch, .lsx)) return error.SkipZigTest; // https://github.com/llvm/llvm-project/issues/159529
+            if (builtin.cpu.arch == .s390x) return error.SkipZigTest; // https://github.com/llvm/llvm-project/issues/194256
 
             const widths = [_]comptime_int{ 1, 2, 3, 4, 8, 16 };
 

package/std/math/nextafter.zig

@@ -23,7 +23,7 @@ pub fn nextAfter(comptime T: type, x: T, y: T) T {
 fn nextAfterInt(comptime T: type, x: T, y: T) T {
     comptime assert(@typeInfo(T) == .int or @typeInfo(T) == .comptime_int);
     return if (@typeInfo(T) == .int and @bitSizeOf(T) < 2)
-        // Special case for `i0`, `u0`, `i1`, and `u1`.
+        // Special case for `u0`, `i1`, and `u1`.
         y
     else if (y > x)
         x + 1
@@ -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;
@@ -102,7 +102,6 @@ fn nextAfterFloat(comptime T: type, x: T, y: T) T {
 }
 
 test "int" {
-    try expect(nextAfter(i0, 0, 0) == 0);
     try expect(nextAfter(u0, 0, 0) == 0);
     try expect(nextAfter(i1, 0, 0) == 0);
     try expect(nextAfter(i1, 0, -1) == -1);
@@ -321,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/powi.zig

@@ -15,12 +15,12 @@ const testing = std.testing;
 ///  - Underflow: Absolute value of result smaller than 1
 ///
 /// Edge case rules ordered by precedence:
-///  - powi(T, x, 0)   = 1 unless T is i1, i0, u0
+///  - powi(T, x, 0)   = 1 unless T is i1, u0
 ///  - powi(T, 0, x)   = 0 when x > 0
 ///  - powi(T, 0, x)   = Overflow
 ///  - powi(T, 1, y)   = 1
 ///  - powi(T, -1, y)  = -1 for y an odd integer
-///  - powi(T, -1, y)  = 1 unless T is i1, i0, u0
+///  - powi(T, -1, y)  = 1 unless T is i1, u0
 ///  - powi(T, -1, y)  = Overflow
 ///  - powi(T, x, y)   = Overflow when y >= @bitSizeOf(x)
 ///  - powi(T, x, y)   = Underflow when y < 0
@@ -189,7 +189,6 @@ test "powi.special" {
 
 test "powi.narrow" {
     try testing.expectError(error.Overflow, powi(u0, 0, 0));
-    try testing.expectError(error.Overflow, powi(i0, 0, 0));
     try testing.expectError(error.Overflow, powi(i1, 0, 0));
     try testing.expectError(error.Overflow, powi(i1, -1, 0));
     try testing.expectError(error.Overflow, powi(i1, 0, -1));

package/std/math/signbit.zig

@@ -13,7 +13,6 @@ pub fn signbit(x: anytype) bool {
 }
 
 test signbit {
-    try testInts(i0);
     try testInts(u0);
     try testInts(i1);
     try testInts(u1);