@zigc/lib 0.17.0-dev.644 → 0.17.0-dev.667

package/std/zig/llvm/BitcodeReader.zig

@@ -282,7 +282,7 @@ fn startBlock(bc: *BitcodeReader, block_id: ?u32, new_abbrev_len: u6) !void {
     };
     try state.abbrevs.abbrevs.ensureTotalCapacity(
         bc.allocator,
-        @typeInfo(Abbrev.Builtin).@"enum".fields.len + abbrevs.len,
+        @typeInfo(Abbrev.Builtin).@"enum".field_names.len + abbrevs.len,
     );
 
     assert(state.abbrevs.abbrevs.items.len == @intFromEnum(Abbrev.Builtin.end_block));
@@ -318,7 +318,7 @@ fn startBlock(bc: *BitcodeReader, block_id: ?u32, new_abbrev_len: u6) !void {
             .{ .encoding = .{ .vbr = 6 } }, // ops
         },
     });
-    assert(state.abbrevs.abbrevs.items.len == @typeInfo(Abbrev.Builtin).@"enum".fields.len);
+    assert(state.abbrevs.abbrevs.items.len == @typeInfo(Abbrev.Builtin).@"enum".field_names.len);
     for (abbrevs) |abbrev| try state.abbrevs.addAbbrevAssumeCapacity(bc.allocator, abbrev);
 }
 
@@ -457,7 +457,7 @@ const Abbrev = struct {
         define_abbrev,
         unabbrev_record,
 
-        const first_record_id: u32 = std.math.maxInt(u32) - @typeInfo(Builtin).@"enum".fields.len + 1;
+        const first_record_id: u32 = std.math.maxInt(u32) - @typeInfo(Builtin).@"enum".field_names.len + 1;
         fn toRecordId(builtin: Builtin) u32 {
             return first_record_id + @intFromEnum(builtin);
         }

package/std/zig/llvm/Builder.zig

@@ -1137,21 +1137,22 @@ pub const Attribute = union(Kind) {
                 .no_sanitize_hwaddress,
                 .sanitize_address_dyninit,
                 => |kind| {
-                    const field = comptime blk: {
+                    const field_name, const field_type = comptime blk: {
                         @setEvalBranchQuota(10_000);
-                        for (@typeInfo(Attribute).@"union".fields) |field| {
-                            if (std.mem.eql(u8, field.name, @tagName(kind))) break :blk field;
+                        const info = @typeInfo(Attribute).@"union";
+                        for (info.field_names, info.field_types) |field_name, field_type| {
+                            if (std.mem.eql(u8, field_name, @tagName(kind))) break :blk .{ field_name, field_type };
                         }
                         unreachable;
                     };
-                    comptime assert(std.mem.eql(u8, @tagName(kind), field.name));
-                    return @unionInit(Attribute, field.name, switch (field.type) {
+                    comptime assert(std.mem.eql(u8, @tagName(kind), field_name));
+                    return @unionInit(Attribute, field_name, switch (field_type) {
                         void => {},
                         u32 => storage.value,
                         Alignment.Lazy, String, Type, UwTable => @enumFromInt(storage.value),
                         AllocKind, AllocSize, FpClass, Memory, VScaleRange => @bitCast(storage.value),
-                        else => @compileError("bad payload type: " ++ field.name ++ ": " ++
-                            @typeName(field.type)),
+                        else => @compileError("bad payload type: " ++ field_name ++ ": " ++
+                            @typeName(field_type)),
                     });
                 },
                 .string, .none => unreachable,
@@ -1258,14 +1259,14 @@ pub const Attribute = union(Kind) {
                     try w.print(" {s}(", .{@tagName(attribute)});
                     var any = false;
                     var remaining: Int = @bitCast(fpclass);
-                    inline for (@typeInfo(FpClass).@"struct".decls) |decl| {
-                        const pattern: Int = @bitCast(@field(FpClass, decl.name));
+                    inline for (@typeInfo(FpClass).@"struct".decl_names) |decl_name| {
+                        const pattern: Int = @bitCast(@field(FpClass, decl_name));
                         if (remaining & pattern == pattern) {
                             if (!any) {
                                 try w.writeByte(' ');
                                 any = true;
                             }
-                            try w.writeAll(decl.name);
+                            try w.writeAll(decl_name);
                             remaining &= ~pattern;
                         }
                     }
@@ -1283,14 +1284,14 @@ pub const Attribute = union(Kind) {
                 .allockind => |allockind| {
                     try w.print(" {t}(\"", .{attribute});
                     var any = false;
-                    inline for (@typeInfo(AllocKind).@"struct".fields) |field| {
-                        if (comptime std.mem.eql(u8, field.name, "_")) continue;
-                        if (@field(allockind, field.name)) {
+                    inline for (@typeInfo(AllocKind).@"struct".field_names) |field_name| {
+                        if (comptime std.mem.eql(u8, field_name, "_")) continue;
+                        if (@field(allockind, field_name)) {
                             if (!any) {
                                 try w.writeByte(',');
                                 any = true;
                             }
-                            try w.writeAll(field.name);
+                            try w.writeAll(field_name);
                         }
                     }
                     try w.writeAll("\")");
@@ -1442,7 +1443,7 @@ pub const Attribute = union(Kind) {
         none = maxInt(u32),
         _,
 
-        pub const len = @typeInfo(Kind).@"enum".fields.len - 2;
+        pub const len = @typeInfo(Kind).@"enum".field_names.len - 2;
 
         pub fn fromString(str: String) Kind {
             assert(!str.isAnon());
@@ -5167,9 +5168,13 @@ pub const Function = struct {
         index: Instruction.ExtraIndex,
     ) struct { data: T, trail: ExtraDataTrail } {
         var result: T = undefined;
-        const fields = @typeInfo(T).@"struct".fields;
-        inline for (fields, self.extra[index..][0..fields.len]) |field, value|
-            @field(result, field.name) = switch (field.type) {
+        const info = @typeInfo(T).@"struct";
+        inline for (
+            info.field_names,
+            info.field_types,
+            self.extra[index..][0..info.field_names.len],
+        ) |field_name, field_type, value|
+            @field(result, field_name) = switch (field_type) {
                 u32 => value,
                 Alignment,
                 AtomicOrdering,
@@ -5183,11 +5188,11 @@ pub const Function = struct {
                 Instruction.Alloca.Info,
                 Instruction.Call.Info,
                 => @bitCast(value),
-                else => @compileError("bad field type: " ++ field.name ++ ": " ++ @typeName(field.type)),
+                else => @compileError("bad field type: " ++ field_name ++ ": " ++ @typeName(field_type)),
             };
         return .{
             .data = result,
-            .trail = .{ .index = index + @as(Type.Item.ExtraIndex, @intCast(fields.len)) },
+            .trail = .{ .index = index + @as(Type.Item.ExtraIndex, @intCast(info.field_names.len)) },
         };
     }
 
@@ -6327,9 +6332,10 @@ pub const WipFunction = struct {
 
             fn addExtra(wip_extra: *@This(), extra: anytype) Instruction.ExtraIndex {
                 const result = wip_extra.index;
-                inline for (@typeInfo(@TypeOf(extra)).@"struct".fields) |field| {
-                    const value = @field(extra, field.name);
-                    wip_extra.items[wip_extra.index] = switch (field.type) {
+                const info = @typeInfo(@TypeOf(extra)).@"struct";
+                inline for (info.field_names, info.field_types) |field_name, field_type| {
+                    const value = @field(extra, field_name);
+                    wip_extra.items[wip_extra.index] = switch (field_type) {
                         u32 => value,
                         Alignment,
                         AtomicOrdering,
@@ -6343,7 +6349,7 @@ pub const WipFunction = struct {
                         Instruction.Alloca.Info,
                         Instruction.Call.Info,
                         => @bitCast(value),
-                        else => @compileError("bad field type: " ++ field.name ++ ": " ++ @typeName(field.type)),
+                        else => @compileError("bad field type: " ++ field_name ++ ": " ++ @typeName(field_type)),
                     };
                     wip_extra.index += 1;
                 }
@@ -6944,7 +6950,7 @@ pub const WipFunction = struct {
     ) Allocator.Error!void {
         try self.extra.ensureUnusedCapacity(
             self.builder.gpa,
-            count * (@typeInfo(Extra).@"struct".fields.len + trail_len),
+            count * (@typeInfo(Extra).@"struct".field_names.len + trail_len),
         );
     }
 
@@ -6983,9 +6989,10 @@ pub const WipFunction = struct {
 
     fn addExtraAssumeCapacity(self: *WipFunction, extra: anytype) Instruction.ExtraIndex {
         const result: Instruction.ExtraIndex = @intCast(self.extra.items.len);
-        inline for (@typeInfo(@TypeOf(extra)).@"struct".fields) |field| {
-            const value = @field(extra, field.name);
-            self.extra.appendAssumeCapacity(switch (field.type) {
+        const info = @typeInfo(@TypeOf(extra)).@"struct";
+        inline for (info.field_names, info.field_types) |field_name, field_type| {
+            const value = @field(extra, field_name);
+            self.extra.appendAssumeCapacity(switch (field_type) {
                 u32 => value,
                 Alignment,
                 AtomicOrdering,
@@ -6999,7 +7006,7 @@ pub const WipFunction = struct {
                 Instruction.Alloca.Info,
                 Instruction.Call.Info,
                 => @bitCast(value),
-                else => @compileError("bad field type: " ++ field.name ++ ": " ++ @typeName(field.type)),
+                else => @compileError("bad field type: " ++ field_name ++ ": " ++ @typeName(field_type)),
             });
         }
         return result;
@@ -7032,9 +7039,13 @@ pub const WipFunction = struct {
         index: Instruction.ExtraIndex,
     ) struct { data: T, trail: ExtraDataTrail } {
         var result: T = undefined;
-        const fields = @typeInfo(T).@"struct".fields;
-        inline for (fields, self.extra.items[index..][0..fields.len]) |field, value|
-            @field(result, field.name) = switch (field.type) {
+        const info = @typeInfo(T).@"struct";
+        inline for (
+            info.field_names,
+            info.field_types,
+            self.extra.items[index..][0..info.field_names.len],
+        ) |field_name, field_type, value|
+            @field(result, field_name) = switch (field_type) {
                 u32 => value,
                 Alignment,
                 AtomicOrdering,
@@ -7048,11 +7059,11 @@ pub const WipFunction = struct {
                 Instruction.Alloca.Info,
                 Instruction.Call.Info,
                 => @bitCast(value),
-                else => @compileError("bad field type: " ++ field.name ++ ": " ++ @typeName(field.type)),
+                else => @compileError("bad field type: " ++ field_name ++ ": " ++ @typeName(field_type)),
             };
         return .{
             .data = result,
-            .trail = .{ .index = index + @as(Type.Item.ExtraIndex, @intCast(fields.len)) },
+            .trail = .{ .index = index + @as(Type.Item.ExtraIndex, @intCast(info.field_names.len)) },
         };
     }
 
@@ -8202,19 +8213,20 @@ pub const Metadata = packed struct(u32) {
 
         pub fn format(self: DIFlags, w: *Writer) Writer.Error!void {
             var need_pipe = false;
-            inline for (@typeInfo(DIFlags).@"struct".fields) |field| {
-                switch (@typeInfo(field.type)) {
-                    .bool => if (@field(self, field.name)) {
+            const info = @typeInfo(DIFlags).@"struct";
+            inline for (info.field_names, info.field_types) |field_name, field_type| {
+                switch (@typeInfo(field_type)) {
+                    .bool => if (@field(self, field_name)) {
                         if (need_pipe) try w.writeAll(" | ") else need_pipe = true;
-                        try w.print("DIFlag{s}", .{field.name});
+                        try w.print("DIFlag{s}", .{field_name});
                     },
-                    .@"enum" => if (@field(self, field.name) != .Zero) {
+                    .@"enum" => if (@field(self, field_name) != .Zero) {
                         if (need_pipe) try w.writeAll(" | ") else need_pipe = true;
-                        try w.print("DIFlag{s}", .{@tagName(@field(self, field.name))});
+                        try w.print("DIFlag{s}", .{@tagName(@field(self, field_name))});
                     },
-                    .int => assert(@field(self, field.name) == 0),
-                    else => @compileError("bad field type: " ++ field.name ++ ": " ++
-                        @typeName(field.type)),
+                    .int => assert(@field(self, field_name) == 0),
+                    else => @compileError("bad field type: " ++ field_name ++ ": " ++
+                        @typeName(field_type)),
                 }
             }
             if (!need_pipe) try w.writeByte('0');
@@ -8259,19 +8271,20 @@ pub const Metadata = packed struct(u32) {
 
             pub fn format(self: DISPFlags, w: *Writer) Writer.Error!void {
                 var need_pipe = false;
-                inline for (@typeInfo(DISPFlags).@"struct".fields) |field| {
-                    switch (@typeInfo(field.type)) {
-                        .bool => if (@field(self, field.name)) {
+                const info = @typeInfo(DISPFlags).@"struct";
+                inline for (info.field_names, info.field_types) |field_name, field_type| {
+                    switch (@typeInfo(field_type)) {
+                        .bool => if (@field(self, field_name)) {
                             if (need_pipe) try w.writeAll(" | ") else need_pipe = true;
-                            try w.print("DISPFlag{s}", .{field.name});
+                            try w.print("DISPFlag{s}", .{field_name});
                         },
-                        .@"enum" => if (@field(self, field.name) != .Zero) {
+                        .@"enum" => if (@field(self, field_name) != .Zero) {
                             if (need_pipe) try w.writeAll(" | ") else need_pipe = true;
-                            try w.print("DISPFlag{s}", .{@tagName(@field(self, field.name))});
+                            try w.print("DISPFlag{s}", .{@tagName(@field(self, field_name))});
                         },
-                        .int => assert(@field(self, field.name) == 0),
-                        else => @compileError("bad field type: " ++ field.name ++ ": " ++
-                            @typeName(field.type)),
+                        .int => assert(@field(self, field_name) == 0),
+                        else => @compileError("bad field type: " ++ field_name ++ ": " ++
+                            @typeName(field_type)),
                     }
                 }
                 if (!need_pipe) try w.writeByte('0');
@@ -8567,7 +8580,7 @@ pub const Metadata = packed struct(u32) {
                 })) |some| switch (@typeInfo(Some)) {
                     .@"enum" => |enum_info| switch (Some) {
                         Metadata.String => .{ .string = some },
-                        else => if (enum_info.is_exhaustive)
+                        else => if (enum_info.mode == .exhaustive)
                             .{ .raw = @tagName(some) }
                         else
                             @compileError("unknown type to format: " ++ @typeName(Node)),
@@ -8763,14 +8776,15 @@ pub fn init(options: Options) Allocator.Error!Builder {
     }
 
     {
-        const static_len = @typeInfo(Type).@"enum".fields.len - 1;
+        const static_len = @typeInfo(Type).@"enum".field_names.len - 1;
         try self.type_map.ensureTotalCapacity(self.gpa, static_len);
         try self.type_items.ensureTotalCapacity(self.gpa, static_len);
-        inline for (@typeInfo(Type.Simple).@"enum".fields) |simple_field| {
+        const info = @typeInfo(Type.Simple).@"enum";
+        inline for (info.field_names, info.field_values) |simple_field_name, simple_field_value| {
             const result = self.getOrPutTypeNoExtraAssumeCapacity(
-                .{ .tag = .simple, .data = simple_field.value },
+                .{ .tag = .simple, .data = simple_field_value },
             );
-            assert(result.new and result.type == @field(Type, simple_field.name));
+            assert(result.new and result.type == @field(Type, simple_field_name));
         }
         inline for (.{ 1, 8, 16, 29, 32, 64, 80, 128 }) |bits|
             assert(self.intTypeAssumeCapacity(bits) ==
@@ -11016,7 +11030,7 @@ fn ensureUnusedTypeCapacity(
     try self.type_items.ensureUnusedCapacity(self.gpa, count);
     try self.type_extra.ensureUnusedCapacity(
         self.gpa,
-        count * (@typeInfo(Extra).@"struct".fields.len + trail_len),
+        count * (@typeInfo(Extra).@"struct".field_names.len + trail_len),
     );
 }
 
@@ -11046,12 +11060,13 @@ fn getOrPutTypeNoExtraAssumeCapacity(self: *Builder, item: Type.Item) struct { n
 
 fn addTypeExtraAssumeCapacity(self: *Builder, extra: anytype) Type.Item.ExtraIndex {
     const result: Type.Item.ExtraIndex = @intCast(self.type_extra.items.len);
-    inline for (@typeInfo(@TypeOf(extra)).@"struct".fields) |field| {
-        const value = @field(extra, field.name);
-        self.type_extra.appendAssumeCapacity(switch (field.type) {
+    const info = @typeInfo(@TypeOf(extra)).@"struct";
+    inline for (info.field_names, info.field_types) |field_name, field_type| {
+        const value = @field(extra, field_name);
+        self.type_extra.appendAssumeCapacity(switch (field_type) {
             u32 => value,
             String, Type => @intFromEnum(value),
-            else => @compileError("bad field type: " ++ field.name ++ ": " ++ @typeName(field.type)),
+            else => @compileError("bad field type: " ++ field_name ++ ": " ++ @typeName(field_type)),
         });
     }
     return result;
@@ -11084,16 +11099,20 @@ fn typeExtraDataTrail(
     index: Type.Item.ExtraIndex,
 ) struct { data: T, trail: TypeExtraDataTrail } {
     var result: T = undefined;
-    const fields = @typeInfo(T).@"struct".fields;
-    inline for (fields, self.type_extra.items[index..][0..fields.len]) |field, value|
-        @field(result, field.name) = switch (field.type) {
+    const info = @typeInfo(T).@"struct";
+    inline for (
+        info.field_names,
+        info.field_types,
+        self.type_extra.items[index..][0..info.field_names.len],
+    ) |field_name, field_type, value|
+        @field(result, field_name) = switch (field_type) {
             u32 => value,
             String, Type => @enumFromInt(value),
-            else => @compileError("bad field type: " ++ @typeName(field.type)),
+            else => @compileError("bad field type: " ++ @typeName(field_type)),
         };
     return .{
         .data = result,
-        .trail = .{ .index = index + @as(Type.Item.ExtraIndex, @intCast(fields.len)) },
+        .trail = .{ .index = index + @as(Type.Item.ExtraIndex, @intCast(info.field_names.len)) },
     };
 }
 
@@ -11899,7 +11918,7 @@ fn ensureUnusedConstantCapacity(
     try self.constant_items.ensureUnusedCapacity(self.gpa, count);
     try self.constant_extra.ensureUnusedCapacity(
         self.gpa,
-        count * (@typeInfo(Extra).@"struct".fields.len + trail_len),
+        count * (@typeInfo(Extra).@"struct".field_names.len + trail_len),
     );
 }
 
@@ -11974,13 +11993,14 @@ fn getOrPutConstantAggregateAssumeCapacity(
 
 fn addConstantExtraAssumeCapacity(self: *Builder, extra: anytype) Constant.Item.ExtraIndex {
     const result: Constant.Item.ExtraIndex = @intCast(self.constant_extra.items.len);
-    inline for (@typeInfo(@TypeOf(extra)).@"struct".fields) |field| {
-        const value = @field(extra, field.name);
-        self.constant_extra.appendAssumeCapacity(switch (field.type) {
+    const info = @typeInfo(@TypeOf(extra)).@"struct";
+    inline for (info.field_names, info.field_types) |field_name, field_type| {
+        const value = @field(extra, field_name);
+        self.constant_extra.appendAssumeCapacity(switch (field_type) {
             u32 => value,
             String, Type, Constant, Function.Index, Function.Block.Index => @intFromEnum(value),
             Constant.GetElementPtr.Info => @bitCast(value),
-            else => @compileError("bad field type: " ++ @typeName(field.type)),
+            else => @compileError("bad field type: " ++ @typeName(field_type)),
         });
     }
     return result;
@@ -12013,17 +12033,21 @@ fn constantExtraDataTrail(
     index: Constant.Item.ExtraIndex,
 ) struct { data: T, trail: ConstantExtraDataTrail } {
     var result: T = undefined;
-    const fields = @typeInfo(T).@"struct".fields;
-    inline for (fields, self.constant_extra.items[index..][0..fields.len]) |field, value|
-        @field(result, field.name) = switch (field.type) {
+    const info = @typeInfo(T).@"struct";
+    inline for (
+        info.field_names,
+        info.field_types,
+        self.constant_extra.items[index..][0..info.field_names.len],
+    ) |field_name, field_type, value|
+        @field(result, field_name) = switch (field_type) {
             u32 => value,
             String, Type, Constant, Function.Index, Function.Block.Index => @enumFromInt(value),
             Constant.GetElementPtr.Info => @bitCast(value),
-            else => @compileError("bad field type: " ++ @typeName(field.type)),
+            else => @compileError("bad field type: " ++ @typeName(field_type)),
         };
     return .{
         .data = result,
-        .trail = .{ .index = index + @as(Constant.Item.ExtraIndex, @intCast(fields.len)) },
+        .trail = .{ .index = index + @as(Constant.Item.ExtraIndex, @intCast(info.field_names.len)) },
     };
 }
 
@@ -12041,19 +12065,20 @@ fn ensureUnusedMetadataCapacity(
     try self.metadata_items.ensureUnusedCapacity(self.gpa, count);
     try self.metadata_extra.ensureUnusedCapacity(
         self.gpa,
-        count * (@typeInfo(Extra).@"struct".fields.len + trail_len),
+        count * (@typeInfo(Extra).@"struct".field_names.len + trail_len),
     );
 }
 
 fn addMetadataExtraAssumeCapacity(self: *Builder, extra: anytype) Metadata.Item.ExtraIndex {
     const result: Metadata.Item.ExtraIndex = @intCast(self.metadata_extra.items.len);
-    inline for (@typeInfo(@TypeOf(extra)).@"struct".fields) |field| {
-        const value = @field(extra, field.name);
-        self.metadata_extra.appendAssumeCapacity(switch (field.type) {
+    const info = @typeInfo(@TypeOf(extra)).@"struct";
+    inline for (info.field_names, info.field_types) |field_name, field_type| {
+        const value = @field(extra, field_name);
+        self.metadata_extra.appendAssumeCapacity(switch (field_type) {
             u32 => value,
             Metadata.String, Metadata.String.Optional, Variable.Index, Value => @intFromEnum(value),
             Metadata, Metadata.Optional, Metadata.DIFlags => @bitCast(value),
-            else => @compileError("bad field type: " ++ @typeName(field.type)),
+            else => @compileError("bad field type: " ++ @typeName(field_type)),
         });
     }
     return result;
@@ -12086,17 +12111,21 @@ fn metadataExtraDataTrail(
     index: Metadata.Item.ExtraIndex,
 ) struct { data: T, trail: MetadataExtraDataTrail } {
     var result: T = undefined;
-    const fields = @typeInfo(T).@"struct".fields;
-    inline for (fields, self.metadata_extra.items[index..][0..fields.len]) |field, value|
-        @field(result, field.name) = switch (field.type) {
+    const info = @typeInfo(T).@"struct";
+    inline for (
+        info.field_names,
+        info.field_types,
+        self.metadata_extra.items[index..][0..info.field_names.len],
+    ) |field_name, field_type, value|
+        @field(result, field_name) = switch (field_type) {
             u32 => value,
             Metadata.String, Metadata.String.Optional, Variable.Index, Value => @enumFromInt(value),
             Metadata, Metadata.Optional, Metadata.DIFlags => @bitCast(value),
-            else => @compileError("bad field type: " ++ @typeName(field.type)),
+            else => @compileError("bad field type: " ++ @typeName(field_type)),
         };
     return .{
         .data = result,
-        .trail = .{ .index = index + @as(Metadata.Item.ExtraIndex, @intCast(fields.len)) },
+        .trail = .{ .index = index + @as(Metadata.Item.ExtraIndex, @intCast(info.field_names.len)) },
     };
 }
 
@@ -12602,8 +12631,8 @@ fn metadataSimpleAssumeCapacity(self: *Builder, tag: Metadata.Tag, value: anytyp
         builder: *const Builder,
         pub fn hash(_: @This(), key: Key) u32 {
             var hasher = std.hash.Wyhash.init(std.hash.int(@intFromEnum(key.tag)));
-            inline for (std.meta.fields(@TypeOf(value))) |field| {
-                hasher.update(std.mem.asBytes(&@field(key.value, field.name)));
+            inline for (comptime std.meta.fieldNames(@TypeOf(value))) |field_name| {
+                hasher.update(std.mem.asBytes(&@field(key.value, field_name)));
             }
             return @truncate(hasher.final());
         }
@@ -14184,12 +14213,14 @@ pub fn toBitcode(self: *Builder, allocator: Allocator, producer: Producer) bitco
             const MetadataKindBlock = ir.ModuleBlock.MetadataKindBlock;
             var metadata_kind_block = try module_block.enterSubBlock(MetadataKindBlock, true);
 
-            inline for (@typeInfo(ir.FixedMetadataKind).@"enum".fields) |field| {
+            const info = @typeInfo(ir.FixedMetadataKind).@"enum";
+
+            inline for (info.field_names, info.field_values) |field_name, field_value| {
                 // don't include `dbg` in stripped functions
-                if (!(self.strip and std.mem.eql(u8, field.name, "dbg"))) {
+                if (!(self.strip and std.mem.eql(u8, field_name, "dbg"))) {
                     try metadata_kind_block.writeAbbrev(MetadataKindBlock.Kind{
-                        .id = field.value,
-                        .name = field.name,
+                        .id = field_value,
+                        .name = field_name,
                     });
                 }
             }

package/std/zig/llvm/bitcode_writer.zig

@@ -246,14 +246,14 @@ pub fn BitcodeWriter(comptime types: []const type) type {
 
                     try self.bitcode.writeBits(comptime abbrevId(Abbrev), abbrev_len);
 
-                    const fields = std.meta.fields(Abbrev);
+                    const field_names = comptime std.meta.fieldNames(Abbrev);
 
                     // This abbreviation might only contain literals
-                    if (fields.len == 0) return;
+                    if (field_names.len == 0) return;
 
                     comptime var field_index: usize = 0;
                     inline for (Abbrev.ops) |ty| {
-                        const param = @field(params, fields[field_index].name);
+                        const param = @field(params, field_names[field_index]);
                         switch (ty) {
                             .literal => continue,
                             .fixed => |len| try self.bitcode.writeBits(adapter.get(param), len),
@@ -296,7 +296,7 @@ pub fn BitcodeWriter(comptime types: []const type) type {
                             },
                         }
                         field_index += 1;
-                        if (field_index == fields.len) break;
+                        if (field_index == field_names.len) break;
                     }
                 }
 

package/std/zig/system/windows.zig

@@ -60,14 +60,14 @@ fn getCpuInfoFromRegistry(core: usize, args: anytype) !void {
         @compileError("expected tuple or struct argument, found " ++ @typeName(ArgsType));
     }
 
-    const fields_info = args_type_info.@"struct".fields;
+    const fields_info = args_type_info.@"struct";
 
     // Originally, I wanted to issue a single call with a more complex table structure such that we
     // would sequentially visit each CPU#d subkey in the registry and pull the value of interest into
     // a buffer, however, NT seems to be expecting a single buffer per each table meaning we would
     // end up pulling only the last CPU core info, overwriting everything else.
     // If anyone can come up with a solution to this, please do!
-    const table_size = 1 + fields_info.len;
+    const table_size = 1 + fields_info.field_names.len;
     var table: [table_size + 1]std.os.windows.RTL_QUERY_REGISTRY_TABLE = undefined;
 
     const topkey = std.unicode.utf8ToUtf16LeStringLiteral("\\Registry\\Machine\\HARDWARE\\DESCRIPTION\\System\\CentralProcessor");
@@ -90,11 +90,11 @@ fn getCpuInfoFromRegistry(core: usize, args: anytype) !void {
         .DefaultLength = 0,
     };
 
-    var tmp_bufs: [fields_info.len][max_value_len]u8 align(@alignOf(std.os.windows.UNICODE_STRING)) = undefined;
+    var tmp_bufs: [fields_info.field_names.len][max_value_len]u8 align(@alignOf(std.os.windows.UNICODE_STRING)) = undefined;
 
-    inline for (fields_info, 0..) |field, i| {
+    inline for (fields_info.field_names, 0..) |field_name, i| {
         const ctx: *anyopaque = blk: {
-            switch (@field(args, field.name).value_type) {
+            switch (@field(args, field_name).value_type) {
                 .SZ,
                 .EXPAND_SZ,
                 .MULTI_SZ,
@@ -119,7 +119,7 @@ fn getCpuInfoFromRegistry(core: usize, args: anytype) !void {
         };
 
         var key_buf: [max_value_len / 2 + 1]u16 = undefined;
-        const key_len = try std.unicode.utf8ToUtf16Le(&key_buf, @field(args, field.name).key);
+        const key_len = try std.unicode.utf8ToUtf16Le(&key_buf, @field(args, field_name).key);
         key_buf[key_len] = 0;
 
         table[i + 1] = .{
@@ -153,12 +153,12 @@ fn getCpuInfoFromRegistry(core: usize, args: anytype) !void {
     );
     switch (res) {
         .SUCCESS => {
-            inline for (fields_info, 0..) |field, i| switch (@field(args, field.name).value_type) {
+            inline for (fields_info.field_names, 0..) |field_name, i| switch (@field(args, field_name).value_type) {
                 .SZ,
                 .EXPAND_SZ,
                 .MULTI_SZ,
                 => {
-                    var buf = @field(args, field.name).value_buf;
+                    var buf = @field(args, field_name).value_buf;
                     const entry: *const std.os.windows.UNICODE_STRING = @ptrCast(table[i + 1].EntryContext);
                     const len = try std.unicode.utf16LeToUtf8(buf, entry.slice());
                     buf[len] = 0;
@@ -169,12 +169,12 @@ fn getCpuInfoFromRegistry(core: usize, args: anytype) !void {
                 .QWORD,
                 => {
                     const entry: [*]const u8 = @ptrCast(table[i + 1].EntryContext);
-                    switch (@field(args, field.name).value_type) {
+                    switch (@field(args, field_name).value_type) {
                         .DWORD, .DWORD_BIG_ENDIAN => {
-                            @memcpy(@field(args, field.name).value_buf[0..4], entry[0..4]);
+                            @memcpy(@field(args, field_name).value_buf[0..4], entry[0..4]);
                         },
                         .QWORD => {
-                            @memcpy(@field(args, field.name).value_buf[0..8], entry[0..8]);
+                            @memcpy(@field(args, field_name).value_buf[0..8], entry[0..8]);
                         },
                         else => unreachable,
                     }

package/std/zig/system.zig

@@ -973,10 +973,10 @@ fn detectAbiAndDynamicLinker(io: Io, cpu: Target.Cpu, os: Target.Os, query: Targ
     // relying on `builtin.target`.
     const all_abis = comptime blk: {
         assert(@intFromEnum(Target.Abi.none) == 0);
-        const fields = std.meta.fields(Target.Abi)[1..];
-        var array: [fields.len]Target.Abi = undefined;
-        for (fields, 0..) |field, i| {
-            array[i] = @field(Target.Abi, field.name);
+        const field_names = std.meta.fieldNames(Target.Abi)[1..];
+        var array: [field_names.len]Target.Abi = undefined;
+        for (field_names, 0..) |field_name, i| {
+            array[i] = @field(Target.Abi, field_name);
         }
         break :blk array;
     };

package/std/zig.zig

@@ -736,8 +736,8 @@ pub fn parseTargetQueryOrReportFatalError(
             help: {
                 var help_text = std.array_list.Managed(u8).init(allocator);
                 defer help_text.deinit();
-                inline for (@typeInfo(std.Target.ObjectFormat).@"enum".fields) |field| {
-                    help_text.print(" {s}\n", .{field.name}) catch break :help;
+                inline for (@typeInfo(std.Target.ObjectFormat).@"enum".field_names) |field_name| {
+                    help_text.print(" {s}\n", .{field_name}) catch break :help;
                 }
                 std.log.info("available object formats:\n{s}", .{help_text.items});
             }
@@ -747,8 +747,8 @@ pub fn parseTargetQueryOrReportFatalError(
             help: {
                 var help_text = std.array_list.Managed(u8).init(allocator);
                 defer help_text.deinit();
-                inline for (@typeInfo(std.Target.Cpu.Arch).@"enum".fields) |field| {
-                    help_text.print(" {s}\n", .{field.name}) catch break :help;
+                inline for (@typeInfo(std.Target.Cpu.Arch).@"enum".field_names) |field_name| {
+                    help_text.print(" {s}\n", .{field_name}) catch break :help;
                 }
                 std.log.info("available architectures:\n{s} native\n", .{help_text.items});
             }