@zigc/lib 0.17.0-dev.39 → 0.17.0-dev.420

package/compiler/reduce/Walk.zig

@@ -6,9 +6,9 @@ const BuiltinFn = std.zig.BuiltinFn;
 
 ast: *const Ast,
 transformations: *std.array_list.Managed(Transformation),
-unreferenced_globals: std.StringArrayHashMapUnmanaged(Ast.Node.Index),
-in_scope_names: std.StringArrayHashMapUnmanaged(u32),
-replace_names: std.StringArrayHashMapUnmanaged(u32),
+unreferenced_globals: std.array_hash_map.String(Ast.Node.Index),
+in_scope_names: std.array_hash_map.String(u32),
+replace_names: std.array_hash_map.String(u32),
 gpa: std.mem.Allocator,
 arena: std.mem.Allocator,
 
@@ -63,9 +63,9 @@ pub fn findTransformations(
         .transformations = transformations,
         .gpa = transformations.allocator,
         .arena = arena,
-        .unreferenced_globals = .{},
-        .in_scope_names = .{},
-        .replace_names = .{},
+        .unreferenced_globals = .empty,
+        .in_scope_names = .empty,
+        .replace_names = .empty,
     };
     defer {
         walk.unreferenced_globals.deinit(walk.gpa);
@@ -223,12 +223,8 @@ fn walkExpression(w: *Walk, node: Ast.Node.Index) Error!void {
             return walkBlock(w, node, statements);
         },
 
-        .@"errdefer" => {
-            const expr = ast.nodeData(node).opt_token_and_node[1];
-            return walkExpression(w, expr);
-        },
-
         .@"defer",
+        .@"errdefer",
         .@"comptime",
         .@"nosuspend",
         .@"suspend",
@@ -252,7 +248,6 @@ fn walkExpression(w: *Walk, node: Ast.Node.Index) Error!void {
         .add_wrap,
         .add_sat,
         .array_cat,
-        .array_mult,
         .assign,
         .assign_bit_and,
         .assign_bit_or,
@@ -607,7 +602,7 @@ fn walkBlock(
                 {
                     try w.transformations.append(.{ .delete_var_decl = .{
                         .var_decl_node = stmt,
-                        .references = .{},
+                        .references = .empty,
                     } });
                     const name_tok = var_decl.ast.mut_token + 1;
                     const name_bytes = ast.tokenSlice(name_tok);

package/compiler/resinator/compile.zig

@@ -3084,7 +3084,7 @@ pub const StringTable = struct {
 
     pub const Block = struct {
         strings: std.ArrayList(Token) = .empty,
-        set_indexes: std.bit_set.IntegerBitSet(16) = .{ .mask = 0 },
+        set_indexes: std.bit_set.Integer(16) = .{ .mask = 0 },
         memory_flags: MemoryFlags = MemoryFlags.defaults(res.RT.STRING),
         characteristics: u32,
         version: u32,

package/compiler/resinator/cvtres.zig

@@ -321,7 +321,7 @@ pub fn writeCoff(
         .checksum = 0,
         .number = 0,
         .selection = .NONE,
-        .unused = .{0} ** 3,
+        .unused = @splat(0),
     });
 
     try writeSymbol(writer, .{
@@ -342,7 +342,7 @@ pub fn writeCoff(
         .checksum = 0,
         .number = 0,
         .selection = .NONE,
-        .unused = .{0} ** 3,
+        .unused = @splat(0),
     });
 
     for (resource_symbols) |resource_symbol| {
@@ -353,11 +353,11 @@ pub fn writeCoff(
         const name_bytes: [8]u8 = name_bytes: {
             if (external_symbol_name.len > 8) {
                 const string_table_offset: u32 = try string_table.put(allocator, external_symbol_name);
-                var bytes = [_]u8{0} ** 8;
+                var bytes: [8]u8 = @splat(0);
                 std.mem.writeInt(u32, bytes[4..8], string_table_offset, .little);
                 break :name_bytes bytes;
             } else {
-                var symbol_shortname = [_]u8{0} ** 8;
+                var symbol_shortname: [8]u8 = @splat(0);
                 @memcpy(symbol_shortname[0..external_symbol_name.len], external_symbol_name);
                 break :name_bytes symbol_shortname;
             }

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/resinator/ico.zig

@@ -183,7 +183,7 @@ pub const Entry = struct {
 };
 
 test "icon" {
-    const data = "\x00\x00\x01\x00\x01\x00\x10\x10\x00\x00\x01\x00\x10\x00\x10\x00\x00\x00\x16\x00\x00\x00" ++ [_]u8{0} ** 16;
+    const data = "\x00\x00\x01\x00\x01\x00\x10\x10\x00\x00\x01\x00\x10\x00\x10\x00\x00\x00\x16\x00\x00\x00" ++ @as([16]u8, @splat(0));
     var fbs: std.Io.Reader = .fixed(data);
     const icon = try read(std.testing.allocator, &fbs, data.len);
     defer icon.deinit();
@@ -196,19 +196,19 @@ test "icon too many images" {
     // Note that with verifying that all data sizes are within the file bounds and >= 16,
     // it's not possible to hit EOF when looking for more RESDIR structures, since they are
     // themselves 16 bytes long, so we'll always hit ImpossibleDataSize instead.
-    const data = "\x00\x00\x01\x00\x02\x00\x10\x10\x00\x00\x01\x00\x10\x00\x10\x00\x00\x00\x16\x00\x00\x00" ++ [_]u8{0} ** 16;
+    const data = "\x00\x00\x01\x00\x02\x00\x10\x10\x00\x00\x01\x00\x10\x00\x10\x00\x00\x00\x16\x00\x00\x00" ++ @as([16]u8, @splat(0));
     var fbs: std.Io.Reader = .fixed(data);
     try std.testing.expectError(error.ImpossibleDataSize, read(std.testing.allocator, &fbs, data.len));
 }
 
 test "icon data size past EOF" {
-    const data = "\x00\x00\x01\x00\x01\x00\x10\x10\x00\x00\x01\x00\x10\x00\x10\x01\x00\x00\x16\x00\x00\x00" ++ [_]u8{0} ** 16;
+    const data = "\x00\x00\x01\x00\x01\x00\x10\x10\x00\x00\x01\x00\x10\x00\x10\x01\x00\x00\x16\x00\x00\x00" ++ @as([16]u8, @splat(0));
     var fbs: std.Io.Reader = .fixed(data);
     try std.testing.expectError(error.ImpossibleDataSize, read(std.testing.allocator, &fbs, data.len));
 }
 
 test "icon data offset past EOF" {
-    const data = "\x00\x00\x01\x00\x01\x00\x10\x10\x00\x00\x01\x00\x10\x00\x10\x00\x00\x00\x17\x00\x00\x00" ++ [_]u8{0} ** 16;
+    const data = "\x00\x00\x01\x00\x01\x00\x10\x10\x00\x00\x01\x00\x10\x00\x10\x00\x00\x00\x17\x00\x00\x00" ++ @as([16]u8, @splat(0));
     var fbs: std.Io.Reader = .fixed(data);
     try std.testing.expectError(error.ImpossibleDataSize, read(std.testing.allocator, &fbs, data.len));
 }

package/compiler/resinator/parse.zig

@@ -138,8 +138,8 @@ pub const Parser = struct {
         var optional_statements: std.ArrayList(*Node) = .empty;
 
         const num_statement_types = @typeInfo(rc.OptionalStatements).@"enum".fields.len;
-        var statement_type_has_duplicates = [_]bool{false} ** num_statement_types;
-        var last_statement_per_type = [_]?*Node{null} ** num_statement_types;
+        var statement_type_has_duplicates: [num_statement_types]bool = @splat(false);
+        var last_statement_per_type: [num_statement_types]?*Node = @splat(null);
 
         while (true) {
             const lookahead_token = try self.lookaheadToken(.normal);

package/compiler/resinator/res.zig

@@ -1068,7 +1068,7 @@ pub const FixedFileInfo = struct {
     pub const key = std.unicode.utf8ToUtf16LeStringLiteral("VS_VERSION_INFO");
 
     pub const Version = struct {
-        parts: [4]u16 = [_]u16{0} ** 4,
+        parts: [4]u16 = @splat(0),
 
         pub fn mostSignificantCombinedParts(self: Version) u32 {
             return (@as(u32, self.parts[0]) << 16) + self.parts[1];

package/compiler/std-docs.zig

@@ -18,7 +18,7 @@ fn usage(io: Io) noreturn {
         \\                            By default, enabled unless a port is specified.
         \\
     ) catch {};
-    std.process.exit(1);
+    std.process.exit(0);
 }
 
 pub fn main(init: std.process.Init) !void {

package/compiler/test_runner.zig

@@ -91,8 +91,8 @@ fn mainServer(init: std.process.Init.Minimal) !void {
                 return std.process.exit(0);
             },
             .query_test_metadata => {
-                testing.allocator_instance = .{};
-                defer if (testing.allocator_instance.deinit() == .leak) {
+                testing.allocator_instance = .init(std.heap.page_allocator, .{});
+                defer if (testing.allocator_instance.deinit() != 0) {
                     @panic("internal test runner memory leak");
                 };
 
@@ -123,7 +123,10 @@ fn mainServer(init: std.process.Init.Minimal) !void {
 
             .run_test => {
                 testing.environ = init.environ;
-                testing.allocator_instance = .{};
+                testing.allocator_instance = .init(std.heap.page_allocator, .{
+                    .canary = 0xc3a701ba,
+                    .check_write_after_free = true,
+                });
                 testing.io_instance = .init(testing.allocator, .{
                     .argv0 = .init(init.args),
                     .environ = init.environ,
@@ -150,8 +153,7 @@ fn mainServer(init: std.process.Init.Minimal) !void {
                     },
                 };
                 testing.io_instance.deinit();
-                const leak_count = testing.allocator_instance.detectLeaks();
-                testing.allocator_instance.deinitWithoutLeakChecks();
+                const leak_count = testing.allocator_instance.deinit();
                 try server.serveTestResults(.{
                     .index = index,
                     .flags = .{
@@ -173,8 +175,8 @@ fn mainServer(init: std.process.Init.Minimal) !void {
                 // since they are not present.
                 if (!builtin.fuzz) unreachable;
 
-                var gpa_instance: std.heap.DebugAllocator(.{}) = .init;
-                defer if (gpa_instance.deinit() == .leak) {
+                var gpa_instance: std.heap.SafeAllocator = .init(std.heap.page_allocator, .{});
+                defer if (gpa_instance.deinit() != 0) {
                     @panic("internal test runner memory leak");
                 };
                 const gpa = gpa_instance.allocator();
@@ -271,14 +273,17 @@ fn mainTerminal(init: std.process.Init.Minimal) void {
 
     var leaks: usize = 0;
     for (test_fn_list, 0..) |test_fn, i| {
-        testing.allocator_instance = .{};
+        testing.allocator_instance = .init(std.heap.page_allocator, .{
+            .canary = 0xc3a701ba,
+            .check_write_after_free = true,
+        });
         testing.io_instance = .init(testing.allocator, .{
             .argv0 = .init(init.args),
             .environ = init.environ,
         });
         defer {
             testing.io_instance.deinit();
-            if (testing.allocator_instance.deinit() == .leak) leaks += 1;
+            if (testing.allocator_instance.deinit() != 0) leaks += 1;
         }
         testing.log_level = .warn;
         testing.environ = init.environ;
@@ -430,8 +435,11 @@ var fuzz_runner: if (builtin.fuzz) struct {
             error.WriteFailed => panic("failed to write to stdout: {t}", .{stdout_writer.err.?}),
         };
 
-        testing.allocator_instance = .{};
-        defer if (testing.allocator_instance.deinit() == .leak) std.process.exit(1);
+        testing.allocator_instance = .init(std.heap.page_allocator, .{
+            .canary = 0xc3a701ba,
+            .check_write_after_free = true,
+        });
+        defer if (testing.allocator_instance.deinit() != 0) std.process.exit(1);
         is_fuzz_test = false;
 
         builtin.test_functions[fuzz_runner.indexes[i]].func() catch |err| switch (err) {
@@ -488,7 +496,7 @@ var fuzz_runner: if (builtin.fuzz) struct {
     fn inputPoller() Io.Cancelable!void {
         @disableInstrumentation();
         switch (inputPollerInner()) {
-            error.Canceled => return error.Canceled,
+            error.Canceled => |e| return e,
             error.ReadFailed => {
                 if (stdin_reader.err.? == error.Canceled) return error.Canceled;
                 panic("failed to read from stdin: {t}", .{stdin_reader.err.?});
@@ -554,8 +562,11 @@ pub fn fuzz(
 
         fn test_one() callconv(.c) bool {
             @disableInstrumentation();
-            testing.allocator_instance = .{};
-            defer if (testing.allocator_instance.deinit() == .leak) std.process.exit(1);
+            testing.allocator_instance = .init(std.heap.page_allocator, .{
+                .canary = 0xcacce5e0,
+                .check_write_after_free = true,
+            });
+            defer if (testing.allocator_instance.deinit() != 0) std.process.exit(1);
             log_err_count = 0;
             testOne(ctx, @constCast(&testing.Smith{ .in = null })) catch |err| switch (err) {
                 error.SkipZigTest => return true,
@@ -582,7 +593,6 @@ pub fn fuzz(
     if (builtin.fuzz) {
         // Preserve the calling test's allocator state
         const prev_allocator_state = testing.allocator_instance;
-        testing.allocator_instance = .{};
         defer testing.allocator_instance = prev_allocator_state;
 
         global.ctx = context;

package/compiler/translate-c/MacroTranslator.zig

@@ -361,7 +361,7 @@ fn parseCNumLit(mt: *MacroTranslator) ParseError!ZigNode {
                 return error.ParseError;
             },
         });
-        if (bytes.getLast() == '.') {
+        if (bytes.getLast().? == '.') {
             bytes.appendAssumeCapacity('0');
         } else if (mem.findAny(u8, bytes.items, ".eEpP") == null) {
             bytes.appendSliceAssumeCapacity(".0");

package/compiler/translate-c/Translator.zig

@@ -475,8 +475,12 @@ pub const builtin_typedef_map = std.StaticStringMap([]const u8).initComptime(.{
     .{ "int8_t", "i8" },
     .{ "uint16_t", "u16" },
     .{ "int16_t", "i16" },
+    .{ "uint24_t", "u24" },
+    .{ "int24_t", "i24" },
     .{ "uint32_t", "u32" },
     .{ "int32_t", "i32" },
+    .{ "uint48_t", "u48" },
+    .{ "int48_t", "i48" },
     .{ "uint64_t", "u64" },
     .{ "int64_t", "i64" },
     .{ "intptr_t", "isize" },
@@ -1293,7 +1297,7 @@ fn transType(t: *Translator, scope: *Scope, qt: QualType, source_loc: TokenIndex
                     error.SelfReferential => {},
                     error.UnsupportedTranslation => {},
                     error.UnsupportedType => {},
-                    error.OutOfMemory => return error.OutOfMemory,
+                    error.OutOfMemory => |e| return e,
                 }
             }
             continue :loop typeof_ty.base.type(t.comp);
@@ -4095,7 +4099,7 @@ fn createIntNode(t: *Translator, int: aro.Value) !ZigNode {
     big.positive = true;
 
     const str = big.toStringAlloc(t.arena, 10, .lower) catch |err| switch (err) {
-        error.OutOfMemory => return error.OutOfMemory,
+        error.OutOfMemory => |e| return e,
     };
     const res = try ZigTag.integer_literal.create(t.arena, str);
     if (is_negative) return ZigTag.negate.create(t.arena, res);

package/compiler/translate-c/ast.zig

@@ -242,7 +242,7 @@ pub const Node = extern union {
 
         /// array_type{}
         empty_array,
-        /// [1]type{val} ** count
+        /// @as([count]type, @splat(val))
         array_filler,
 
         /// comptime { if (!(lhs)) @compileError(rhs); }
@@ -863,11 +863,14 @@ pub fn render(gpa: Allocator, nodes: []const Node) !std.zig.Ast {
         .start = @as(u32, @intCast(ctx.buf.items.len)),
     });
 
+    try ctx.buf.shrinkToLenSentinel(gpa);
+    try ctx.extra_data.shrinkToLen(gpa);
+
     return .{
-        .source = try ctx.buf.toOwnedSliceSentinel(gpa, 0),
+        .source = ctx.buf.toOwnedSliceSentinelAssert(0),
         .tokens = ctx.tokens.toOwnedSlice(),
         .nodes = ctx.nodes.toOwnedSlice(),
-        .extra_data = try ctx.extra_data.toOwnedSlice(gpa),
+        .extra_data = ctx.extra_data.toOwnedSliceAssert(),
         .errors = &.{},
         .mode = .zig,
     };
@@ -1973,28 +1976,18 @@ fn renderNode(c: *Context, node: Node) Allocator.Error!NodeIndex {
         .array_filler => {
             const payload = node.castTag(.array_filler).?.data;
 
-            const type_expr = try renderArrayType(c, 1, payload.type);
-            const l_brace = try c.addToken(.l_brace, "{");
-            const val = try renderNode(c, payload.filler);
-            _ = try c.addToken(.r_brace, "}");
+            const as_tok = try c.addToken(.builtin, "@as");
+            _ = try c.addToken(.l_paren, "(");
+            const type_node = try renderArrayType(c, payload.count, payload.type);
+            _ = try c.addToken(.comma, ",");
+            const splat_node = try renderBuiltinCall(c, "@splat", &.{payload.filler});
+            _ = try c.addToken(.r_paren, ")");
 
-            const init = try c.addNode(.{
-                .tag = .array_init_one,
-                .main_token = l_brace,
-                .data = .{ .node_and_node = .{
-                    type_expr, val,
-                } },
-            });
             return c.addNode(.{
-                .tag = .array_cat,
-                .main_token = try c.addToken(.asterisk_asterisk, "**"),
-                .data = .{ .node_and_node = .{
-                    init,
-                    try c.addNode(.{
-                        .tag = .number_literal,
-                        .main_token = try c.addTokenFmt(.number_literal, "{d}", .{payload.count}),
-                        .data = undefined,
-                    }),
+                .tag = .builtin_call_two,
+                .main_token = as_tok,
+                .data = .{ .opt_node_and_opt_node = .{
+                    .fromOptional(type_node), .fromOptional(splat_node),
                 } },
             });
         },

package/compiler/translate-c/main.zig

@@ -225,7 +225,7 @@ fn translate(d: *aro.Driver, tc: *aro.Toolchain, args: []const [:0]const u8, zig
     const source = d.inputs.items[0];
 
     tc.discover() catch |er| switch (er) {
-        error.OutOfMemory => return error.OutOfMemory,
+        error.OutOfMemory => |e| return e,
         error.TooManyMultilibs => return d.fatal("found more than one multilib with the same priority", .{}),
     };
     try tc.defineSystemIncludes();

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

@@ -57,9 +57,9 @@ const __udivmodsi4 = @import("int.zig").__udivmodsi4;
 const __divmoddi4 = @import("int.zig").__divmoddi4;
 const __udivmoddi4 = @import("int.zig").__udivmoddi4;
 
-extern fn memset(dest: ?[*]u8, c: i32, n: usize) ?[*]u8;
-extern fn memcpy(noalias dest: ?[*]u8, noalias src: ?[*]const u8, n: usize) ?[*]u8;
-extern fn memmove(dest: ?[*]u8, src: ?[*]const u8, n: usize) ?[*]u8;
+extern fn memset(dest: ?*anyopaque, c: i32, n: usize) ?*anyopaque;
+extern fn memcpy(noalias dest: ?*anyopaque, noalias src: ?*const anyopaque, n: usize) ?*anyopaque;
+extern fn memmove(dest: ?*anyopaque, src: ?*const anyopaque, n: usize) ?*anyopaque;
 
 pub fn __aeabi_memcpy(dest: [*]u8, src: [*]u8, n: usize) callconv(.{ .arm_aapcs = .{} }) void {
     @setRuntimeSafety(false);

package/compiler_rt/atomics.zig

@@ -94,7 +94,7 @@ const SpinlockTable = struct {
         }
     };
 
-    list: [max_spinlocks]Spinlock = [_]Spinlock{.{}} ** max_spinlocks,
+    list: [max_spinlocks]Spinlock = @splat(.{}),
 
     // The spinlock table behaves as a really simple hash table, mapping
     // addresses to spinlocks. The mapping is not unique but that's only a

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

@@ -7,6 +7,7 @@
 
 const std = @import("std");
 const math = std.math;
+const ld = math.long_double;
 const mem = std.mem;
 const expect = std.testing.expect;
 const expectApproxEqAbs = std.testing.expectApproxEqAbs;
@@ -17,7 +18,6 @@ const trig = @import("trig.zig");
 const rem_pio2 = @import("rem_pio2.zig").rem_pio2;
 const rem_pio2f = @import("rem_pio2f.zig").rem_pio2f;
 const rem_pio2l = @import("rem_pio2l.zig").rem_pio2l;
-const ld = @import("long_double.zig");
 
 comptime {
     symbol(&cosh, "__cosh");
@@ -173,8 +173,6 @@ pub fn cosq(x: f128) callconv(.c) f128 {
 
 pub fn cosl(x: c_longdouble) callconv(.c) c_longdouble {
     switch (@typeInfo(c_longdouble).float.bits) {
-        16 => return cosh(x),
-        32 => return cosf(x),
         64 => return cos(x),
         80 => return cosx(x),
         128 => return cosq(x),

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

@@ -198,8 +198,6 @@ const expq = @import("exp_f128.zig").exp;
 
 pub fn expl(x: c_longdouble) callconv(.c) c_longdouble {
     switch (@typeInfo(c_longdouble).float.bits) {
-        16 => return __exph(x),
-        32 => return expf(x),
         64 => return exp(x),
         80 => return __expx(x),
         128 => return expq(x),

package/compiler_rt/exp2.zig

@@ -165,8 +165,6 @@ pub const exp2q = @import("exp_f128.zig").exp2;
 
 pub fn exp2l(x: c_longdouble) callconv(.c) c_longdouble {
     switch (@typeInfo(c_longdouble).float.bits) {
-        16 => return __exp2h(x),
-        32 => return exp2f(x),
         64 => return exp2(x),
         80 => return __exp2x(x),
         128 => return exp2q(x),

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

@@ -38,8 +38,6 @@ pub fn fabsq(a: f128) callconv(.c) f128 {
 
 pub fn fabsl(x: c_longdouble) callconv(.c) c_longdouble {
     switch (@typeInfo(c_longdouble).float.bits) {
-        16 => return __fabsh(x),
-        32 => return fabsf(x),
         64 => return fabs(x),
         80 => return __fabsx(x),
         128 => return fabsq(x),
@@ -49,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);