replace all @Type usages

Author: alichraghi

doc/langref/std_options.zig

@@ -11,7 +11,7 @@ pub const std_options: std.Options = .{
 
 fn myLogFn(
     comptime level: std.log.Level,
-    comptime scope: @Type(.enum_literal),
+    comptime scope: @TypeOf(.enum_literal),
     comptime format: []const u8,
     args: anytype,
 ) void {

lib/compiler/aro/aro/Attribute.zig

@@ -712,13 +712,11 @@ pub const Arguments = blk: {
         };
     }
 
-    break :blk @Type(.{
-        .@"union" = .{
-            .layout = .auto,
-            .tag_type = null,
-            .fields = &union_fields,
-            .decls = &.{},
-        },
+    break :blk @Union(.{
+        .layout = .auto,
+        .tag_type = null,
+        .fields = &union_fields,
+        .decls = &.{},
     });
 };
 

lib/compiler/resinator/code_pages.zig

@@ -179,12 +179,12 @@ pub const UnsupportedCodePage = enum(u16) {
 
 pub const CodePage = blk: {
     const fields = @typeInfo(SupportedCodePage).@"enum".fields ++ @typeInfo(UnsupportedCodePage).@"enum".fields;
-    break :blk @Type(.{ .@"enum" = .{
+    break :blk @Enum(.{
         .tag_type = u16,
         .decls = &.{},
         .fields = fields,
         .is_exhaustive = true,
-    } });
+    });
 };
 
 pub fn isSupported(code_page: CodePage) bool {

lib/compiler/resinator/errors.zig

@@ -872,12 +872,12 @@ pub const ErrorDetailsWithoutCodePage = blk: {
         i += 1;
     }
     std.debug.assert(i == fields_without_codepage.len);
-    break :blk @Type(.{ .@"struct" = .{
+    break :blk @Struct(.{
         .layout = .auto,
         .fields = &fields_without_codepage,
         .decls = &.{},
         .is_tuple = false,
-    } });
+    });
 };
 
 fn cellCount(code_page: SupportedCodePage, source: []const u8, start_index: usize, end_index: usize) usize {

lib/compiler/test_runner.zig

@@ -264,7 +264,7 @@ fn mainTerminal() void {
 
 pub fn log(
     comptime message_level: std.log.Level,
-    comptime scope: @Type(.enum_literal),
+    comptime scope: @TypeOf(.enum_literal),
     comptime format: []const u8,
     args: anytype,
 ) void {

lib/compiler_rt/common.zig

@@ -252,10 +252,7 @@ pub fn normalize(comptime T: type, significand: *std.meta.Int(.unsigned, @typeIn
 pub inline fn fneg(a: anytype) @TypeOf(a) {
     const F = @TypeOf(a);
     const bits = @typeInfo(F).float.bits;
-    const U = @Type(.{ .int = .{
-        .signedness = .unsigned,
-        .bits = bits,
-    } });
+    const U = @Int(.unsigned, bits);
     const sign_bit_mask = @as(U, 1) << (bits - 1);
     const negated = @as(U, @bitCast(a)) ^ sign_bit_mask;
     return @bitCast(negated);

lib/compiler_rt/float_from_int.zig

@@ -66,17 +66,17 @@ pub inline fn floatFromBigInt(comptime T: type, comptime signedness: std.builtin
     switch (x.len) {
         0 => return 0,
         inline 1...4 => |limbs_len| return @floatFromInt(@as(
-            @Type(.{ .int = .{ .signedness = signedness, .bits = 32 * limbs_len } }),
+            @Int(signedness, 32 * limbs_len),
             @bitCast(x[0..limbs_len].*),
         )),
         else => {},
     }
 
     // sign implicit fraction round sticky
-    const I = comptime @Type(.{ .int = .{
-        .signedness = signedness,
-        .bits = @as(u16, @intFromBool(signedness == .signed)) + 1 + math.floatFractionalBits(T) + 1 + 1,
-    } });
+    const I = comptime @Int(
+        signedness,
+        @as(u16, @intFromBool(signedness == .signed)) + 1 + math.floatFractionalBits(T) + 1 + 1,
+    );
 
     const clrsb = clrsb: {
         var clsb: usize = 0;

lib/compiler_rt/int_from_float.zig

@@ -56,7 +56,7 @@ pub inline fn bigIntFromFloat(comptime signedness: std.builtin.Signedness, resul
         0 => return,
         inline 1...4 => |limbs_len| {
             result[0..limbs_len].* = @bitCast(@as(
-                @Type(.{ .int = .{ .signedness = signedness, .bits = 32 * limbs_len } }),
+                @Int(signedness, 32 * limbs_len),
                 @intFromFloat(a),
             ));
             return;
@@ -66,10 +66,7 @@ pub inline fn bigIntFromFloat(comptime signedness: std.builtin.Signedness, resul
 
     // sign implicit fraction
     const significand_bits = 1 + math.floatFractionalBits(@TypeOf(a));
-    const I = @Type(comptime .{ .int = .{
-        .signedness = signedness,
-        .bits = @as(u16, @intFromBool(signedness == .signed)) + significand_bits,
-    } });
+    const I = @Int(signedness, @as(u16, @intFromBool(signedness == .signed)) + significand_bits);
 
     const parts = math.frexp(a);
     const significand_bits_adjusted_to_handle_smin = @as(i32, significand_bits) +

lib/compiler_rt/memcpy.zig

@@ -159,7 +159,7 @@ inline fn copyFixedLength(
     else if (len > @sizeOf(usize))
         @Vector(len, u8)
     else
-        @Type(.{ .int = .{ .signedness = .unsigned, .bits = len * 8 } });
+        @Int(.unsigned, len * 8);
 
     const loop_count = @divExact(len, @sizeOf(T));
 

lib/fuzzer.zig

@@ -13,7 +13,7 @@ var log_file: ?std.fs.File = null;
 
 fn logOverride(
     comptime level: std.log.Level,
-    comptime scope: @Type(.enum_literal),
+    comptime scope: @TypeOf(.enum_literal),
     comptime format: []const u8,
     args: anytype,
 ) void {