all: replace all @Type usages

Co-authored-by: Matthew Lugg <[email protected]>

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: @EnumLiteral(),
     comptime format: []const u8,
     args: anytype,
 ) void {

doc/langref/test_coerce_unions_enums.zig

@@ -41,7 +41,7 @@ test "coercion between unions and enums" {
     try expect(u_4.tag() == 1);
 
     // The following example is invalid.
-    // error: coercion from enum '@TypeOf(.enum_literal)' to union 'test_coerce_unions_enum.U2' must initialize 'f32' field 'b'
+    // error: coercion from enum '@EnumLiteral()' to union 'test_coerce_unions_enum.U2' must initialize 'f32' field 'b'
     //var u_5: U2 = .b;
     //try expect(u_5.tag() == 2);
 }

lib/build-web/main.zig

@@ -49,7 +49,7 @@ pub fn panic(msg: []const u8, st: ?*std.builtin.StackTrace, addr: ?usize) noretu
 
 fn logFn(
     comptime message_level: log.Level,
-    comptime scope: @TypeOf(.enum_literal),
+    comptime scope: @EnumLiteral(),
     comptime format: []const u8,
     args: anytype,
 ) void {

lib/compiler/aro/aro/Attribute.zig

@@ -717,23 +717,13 @@ pub const Tag = std.meta.DeclEnum(attributes);
 
 pub const Arguments = blk: {
     const decls = @typeInfo(attributes).@"struct".decls;
-    var union_fields: [decls.len]ZigType.UnionField = undefined;
-    for (decls, &union_fields) |decl, *field| {
-        field.* = .{
-            .name = decl.name,
-            .type = @field(attributes, decl.name),
-            .alignment = @alignOf(@field(attributes, decl.name)),
-        };
+    var names: [decls.len][]const u8 = undefined;
+    var types: [decls.len]type = undefined;
+    for (decls, &names, &types) |decl, *name, *T| {
+        name.* = decl.name;
+        T.* = @field(attributes, decl.name);
     }
-
-    break :blk @Type(.{
-        .@"union" = .{
-            .layout = .auto,
-            .tag_type = null,
-            .fields = &union_fields,
-            .decls = &.{},
-        },
-    });
+    break :blk @Union(.auto, null, &names, &types, &@splat(.{}));
 };
 
 pub fn ArgumentsForTag(comptime tag: Tag) type {

lib/compiler/aro/assembly_backend/x86_64.zig

@@ -59,7 +59,7 @@ fn serializeFloat(comptime T: type, value: T, w: *std.Io.Writer) !void {
         else => {
             const size = @bitSizeOf(T);
             const storage_unit = std.meta.intToEnum(StorageUnit, size) catch unreachable;
-            const IntTy = @Type(.{ .int = .{ .signedness = .unsigned, .bits = size } });
+            const IntTy = @Int(.unsigned, size);
             const int_val: IntTy = @bitCast(value);
             return serializeInt(int_val, storage_unit, w);
         },

lib/compiler/resinator/code_pages.zig

@@ -179,12 +179,13 @@ pub const UnsupportedCodePage = enum(u16) {
 
 pub const CodePage = blk: {
     const fields = @typeInfo(SupportedCodePage).@"enum".fields ++ @typeInfo(UnsupportedCodePage).@"enum".fields;
-    break :blk @Type(.{ .@"enum" = .{
-        .tag_type = u16,
-        .decls = &.{},
-        .fields = fields,
-        .is_exhaustive = true,
-    } });
+    var field_names: [fields.len][]const u8 = undefined;
+    var field_values: [fields.len]u16 = undefined;
+    for (fields, &field_names, &field_values) |field, *name, *val| {
+        name.* = field.name;
+        val.* = field.value;
+    }
+    break :blk @Enum(u16, .exhaustive, &field_names, &field_values);
 };
 
 pub fn isSupported(code_page: CodePage) bool {

lib/compiler/resinator/errors.zig

@@ -862,20 +862,23 @@ pub const ErrorDetails = struct {
 pub const ErrorDetailsWithoutCodePage = blk: {
     const details_info = @typeInfo(ErrorDetails);
     const fields = details_info.@"struct".fields;
-    var fields_without_codepage: [fields.len - 1]std.builtin.Type.StructField = undefined;
+    var field_names: [fields.len - 1][]const u8 = undefined;
+    var field_types: [fields.len - 1]type = undefined;
+    var field_attrs: [fields.len - 1]std.builtin.Type.StructField.Attributes = undefined;
     var i: usize = 0;
     for (fields) |field| {
         if (std.mem.eql(u8, field.name, "code_page")) continue;
-        fields_without_codepage[i] = field;
+        field_names[i] = field.name;
+        field_types[i] = field.type;
+        field_attrs[i] = .{
+            .@"comptime" = field.is_comptime,
+            .@"align" = field.alignment,
+            .default_value_ptr = field.default_value_ptr,
+        };
         i += 1;
     }
-    std.debug.assert(i == fields_without_codepage.len);
-    break :blk @Type(.{ .@"struct" = .{
-        .layout = .auto,
-        .fields = &fields_without_codepage,
-        .decls = &.{},
-        .is_tuple = false,
-    } });
+    std.debug.assert(i == fields.len - 1);
+    break :blk @Struct(.auto, null, &field_names, &field_types, &field_attrs);
 };
 
 fn cellCount(code_page: SupportedCodePage, source: []const u8, start_index: usize, end_index: usize) usize {

lib/compiler/test_runner.zig

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

lib/compiler_rt/common.zig

@@ -290,10 +290,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;