@zigc/lib 0.17.0-dev.633 → 0.17.0-dev.657

package/std/multi_array_list.zig

@@ -44,17 +44,7 @@ pub fn MultiArrayList(comptime T: type) type {
         const Elem = switch (@typeInfo(T)) {
             .@"struct" => T,
             .@"union" => |u| struct {
-                pub const Bare = Bare: {
-                    var field_names: [u.fields.len][]const u8 = undefined;
-                    var field_types: [u.fields.len]type = undefined;
-                    var field_attrs: [u.fields.len]std.builtin.Type.UnionField.Attributes = undefined;
-                    for (u.fields, &field_names, &field_types, &field_attrs) |field, *name, *Type, *attrs| {
-                        name.* = field.name;
-                        Type.* = field.type;
-                        attrs.* = .{ .@"align" = field.alignment };
-                    }
-                    break :Bare @Union(u.layout, null, &field_names, &field_types, &field_attrs);
-                };
+                pub const Bare = @Union(u.layout, null, u.field_names, u.field_types[0..], u.field_attrs[0..]);
                 pub const Tag =
                     u.tag_type orelse @compileError("MultiArrayList does not support untagged unions");
                 tags: Tag,
@@ -87,7 +77,7 @@ pub fn MultiArrayList(comptime T: type) type {
         pub const Slice = struct {
             /// This array is indexed by the field index which can be obtained
             /// by using @intFromEnum() on the Field enum
-            ptrs: [fields.len][*]u8,
+            ptrs: [field_names.len][*]u8,
             len: usize,
             capacity: usize,
 
@@ -116,15 +106,15 @@ pub fn MultiArrayList(comptime T: type) type {
                     .@"union" => Elem.fromT(elem),
                     else => unreachable,
                 };
-                inline for (fields, 0..) |field_info, i| {
-                    self.items(@as(Field, @enumFromInt(i)))[index] = @field(e, field_info.name);
+                inline for (field_names, 0..) |field_name, i| {
+                    self.items(@as(Field, @enumFromInt(i)))[index] = @field(e, field_name);
                 }
             }
 
             pub fn get(self: Slice, index: usize) T {
                 var result: Elem = undefined;
-                inline for (fields, 0..) |field_info, i| {
-                    @field(result, field_info.name) = self.items(@as(Field, @enumFromInt(i)))[index];
+                inline for (field_names, 0..) |field_name, i| {
+                    @field(result, field_name) = self.items(@as(Field, @enumFromInt(i)))[index];
                 }
                 return switch (@typeInfo(T)) {
                     .@"struct" => result,
@@ -134,9 +124,9 @@ pub fn MultiArrayList(comptime T: type) type {
             }
 
             pub fn swap(self: Slice, a: usize, b: usize) void {
-                inline for (@typeInfo(Field).@"enum".fields) |field| {
-                    const its = self.items(@field(Field, field.name));
-                    std.mem.swap(@FieldType(T, field.name), &its[a], &its[b]);
+                inline for (@typeInfo(Field).@"enum".field_names) |field_name| {
+                    const its = self.items(@field(Field, field_name));
+                    std.mem.swap(@FieldType(T, field_name), &its[a], &its[b]);
                 }
             }
 
@@ -162,9 +152,9 @@ pub fn MultiArrayList(comptime T: type) type {
             /// Asserts that `off + len <= s.len`.
             pub fn subslice(s: Slice, off: usize, len: usize) Slice {
                 assert(off + len <= s.len);
-                var ptrs: [fields.len][*]u8 = undefined;
-                inline for (s.ptrs, &ptrs, fields) |in, *out, field| {
-                    out.* = in + (off * @sizeOf(field.type));
+                var ptrs: [field_names.len][*]u8 = undefined;
+                inline for (s.ptrs, &ptrs, field_types) |in, *out, field_type| {
+                    out.* = in + (off * @sizeOf(field_type));
                 }
                 return .{
                     .ptrs = ptrs,
@@ -185,7 +175,9 @@ pub fn MultiArrayList(comptime T: type) type {
 
         const Self = @This();
 
-        const fields = meta.fields(Elem);
+        const field_names = @typeInfo(Elem).@"struct".field_names;
+        const field_types = @typeInfo(Elem).@"struct".field_types;
+        const field_attrs = @typeInfo(Elem).@"struct".field_attrs;
         /// `sizes.bytes` is an array of @sizeOf each T field. Sorted by alignment, descending.
         /// `sizes.fields` is an array mapping from `sizes.bytes` array index to field index.
         /// `sizes.big_align` is the overall alignment of the allocation, which equals the maximum field alignment.
@@ -195,13 +187,13 @@ pub fn MultiArrayList(comptime T: type) type {
                 size_index: usize,
                 alignment: usize,
             };
-            var data: [fields.len]Data = undefined;
+            var data: [field_names.len]Data = undefined;
             var big_align: usize = 1;
-            for (fields, 0..) |field_info, i| {
+            for (field_types, field_attrs, 0..) |f_type, f_attrs, i| {
                 data[i] = .{
-                    .size = @sizeOf(field_info.type),
+                    .size = @sizeOf(f_type),
                     .size_index = i,
-                    .alignment = field_info.alignment orelse @alignOf(field_info.type),
+                    .alignment = f_attrs.@"align" orelse @alignOf(f_type),
                 };
                 big_align = @max(big_align, data[i].alignment);
             }
@@ -211,10 +203,10 @@ pub fn MultiArrayList(comptime T: type) type {
                     return lhs.alignment > rhs.alignment;
                 }
             };
-            @setEvalBranchQuota(3 * fields.len * std.math.log2(fields.len));
+            @setEvalBranchQuota(3 * field_names.len * std.math.log2(field_names.len));
             mem.sort(Data, &data, {}, Sort.lessThan);
-            var sizes_bytes: [fields.len]usize = undefined;
-            var field_indexes: [fields.len]usize = undefined;
+            var sizes_bytes: [field_names.len]usize = undefined;
+            var field_indexes: [field_names.len]usize = undefined;
             for (data, 0..) |elem, i| {
                 sizes_bytes[i] = elem.size;
                 field_indexes[i] = elem.size_index;
@@ -368,13 +360,13 @@ pub fn MultiArrayList(comptime T: type) type {
                 else => unreachable,
             };
             const slices = self.slice();
-            inline for (fields, 0..) |field_info, field_index| {
+            inline for (field_names, 0..) |field_name, field_index| {
                 const field_slice = slices.items(@as(Field, @enumFromInt(field_index)));
                 var i: usize = self.len - 1;
                 while (i > index) : (i -= 1) {
                     field_slice[i] = field_slice[i - 1];
                 }
-                field_slice[index] = @field(entry, field_info.name);
+                field_slice[index] = @field(entry, field_name);
             }
         }
 
@@ -394,7 +386,7 @@ pub fn MultiArrayList(comptime T: type) type {
         /// retain list ordering.
         pub fn swapRemove(self: *Self, index: usize) void {
             const slices = self.slice();
-            inline for (fields, 0..) |_, i| {
+            inline for (field_names, 0..) |_, i| {
                 const field_slice = slices.items(@as(Field, @enumFromInt(i)));
                 field_slice[index] = field_slice[self.len - 1];
                 field_slice[self.len - 1] = undefined;
@@ -406,7 +398,7 @@ pub fn MultiArrayList(comptime T: type) type {
         /// after it to preserve order.
         pub fn orderedRemove(self: *Self, index: usize) void {
             const slices = self.slice();
-            inline for (fields, 0..) |_, field_index| {
+            inline for (field_names, 0..) |_, field_index| {
                 const field_slice = slices.items(@as(Field, @enumFromInt(field_index)));
                 var i = index;
                 while (i < self.len - 1) : (i += 1) {
@@ -437,7 +429,7 @@ pub fn MultiArrayList(comptime T: type) type {
                 if (removed == end) continue; // allows duplicates in `sorted_indexes`
                 const start = removed + 1;
                 const len = end - start; // safety checks `sorted_indexes` are sorted
-                inline for (fields, 0..) |_, field_index| {
+                inline for (field_names, 0..) |_, field_index| {
                     const field_slice = slices.items(@enumFromInt(field_index));
                     @memmove(field_slice[start - shift ..][0..len], field_slice[start..][0..len]); // safety checks initial `sorted_indexes` are in range
                 }
@@ -446,7 +438,7 @@ pub fn MultiArrayList(comptime T: type) type {
             const start = sorted_indexes[sorted_indexes.len - 1] + 1;
             const end = self.len;
             const len = end - start; // safety checks final `sorted_indexes` are in range
-            inline for (fields, 0..) |_, field_index| {
+            inline for (field_names, 0..) |_, field_index| {
                 const field_slice = slices.items(@enumFromInt(field_index));
                 @memmove(field_slice[start - shift ..][0..len], field_slice[start..][0..len]);
             }
@@ -471,8 +463,8 @@ pub fn MultiArrayList(comptime T: type) type {
 
             const other_bytes = gpa.alignedAlloc(u8, sizes.big_align, capacityInBytes(new_len)) catch {
                 const self_slice = self.slice();
-                inline for (fields, 0..) |field_info, i| {
-                    if (@sizeOf(field_info.type) != 0) {
+                inline for (field_types, 0..) |field_type, i| {
+                    if (@sizeOf(field_type) != 0) {
                         const field = @as(Field, @enumFromInt(i));
                         const dest_slice = self_slice.items(field)[new_len..];
                         // We use memset here for more efficient codegen in safety-checked,
@@ -492,8 +484,8 @@ pub fn MultiArrayList(comptime T: type) type {
             self.len = new_len;
             const self_slice = self.slice();
             const other_slice = other.slice();
-            inline for (fields, 0..) |field_info, i| {
-                if (@sizeOf(field_info.type) != 0) {
+            inline for (field_types, 0..) |field_type, i| {
+                if (@sizeOf(field_type) != 0) {
                     const field = @as(Field, @enumFromInt(i));
                     @memcpy(other_slice.items(field), self_slice.items(field));
                 }
@@ -529,7 +521,7 @@ pub fn MultiArrayList(comptime T: type) type {
 
         const init_capacity: comptime_int = init: {
             var max: comptime_int = 1;
-            for (fields) |field| max = @max(max, @sizeOf(field.type));
+            for (field_types) |field_type| max = @max(max, @sizeOf(field_type));
             break :init @max(1, std.atomic.cache_line / max);
         };
 
@@ -564,8 +556,8 @@ pub fn MultiArrayList(comptime T: type) type {
             };
             const self_slice = self.slice();
             const other_slice = other.slice();
-            inline for (fields, 0..) |field_info, i| {
-                if (@sizeOf(field_info.type) != 0) {
+            inline for (field_types, 0..) |field_type, i| {
+                if (@sizeOf(field_type) != 0) {
                     const field = @as(Field, @enumFromInt(i));
                     @memcpy(other_slice.items(field), self_slice.items(field));
                 }
@@ -583,8 +575,8 @@ pub fn MultiArrayList(comptime T: type) type {
             result.len = self.len;
             const self_slice = self.slice();
             const result_slice = result.slice();
-            inline for (fields, 0..) |field_info, i| {
-                if (@sizeOf(field_info.type) != 0) {
+            inline for (field_types, 0..) |field_type, i| {
+                if (@sizeOf(field_type) != 0) {
                     const field = @as(Field, @enumFromInt(i));
                     @memcpy(result_slice.items(field), self_slice.items(field));
                 }
@@ -600,11 +592,11 @@ pub fn MultiArrayList(comptime T: type) type {
                 slice: Slice,
 
                 pub fn swap(sc: @This(), a_index: usize, b_index: usize) void {
-                    inline for (fields, 0..) |field_info, i| {
-                        if (@sizeOf(field_info.type) != 0) {
+                    inline for (field_types, 0..) |field_type, i| {
+                        if (@sizeOf(field_type) != 0) {
                             const field: Field = @enumFromInt(i);
                             const ptr = sc.slice.items(field);
-                            mem.swap(field_info.type, &ptr[a_index], &ptr[b_index]);
+                            mem.swap(field_type, &ptr[a_index], &ptr[b_index]);
                         }
                     }
                 }
@@ -676,18 +668,18 @@ pub fn MultiArrayList(comptime T: type) type {
         }
 
         const Entry = entry: {
-            var field_names: [fields.len][]const u8 = undefined;
-            var field_types: [fields.len]type = undefined;
-            var field_attrs: [fields.len]std.builtin.Type.StructField.Attributes = undefined;
-            for (sizes.fields, &field_names, &field_types, &field_attrs) |i, *name, *Type, *attrs| {
-                name.* = fields[i].name ++ "_ptr";
-                Type.* = *fields[i].type;
+            var entry_field_names: [field_names.len][]const u8 = undefined;
+            var entry_field_types: [field_names.len]type = undefined;
+            var entry_field_attrs: [field_names.len]std.builtin.Type.Struct.FieldAttributes = undefined;
+            for (sizes.fields, &entry_field_names, &entry_field_types, &entry_field_attrs) |i, *name, *Type, *attrs| {
+                name.* = field_names[i] ++ "_ptr";
+                Type.* = *field_types[i];
                 attrs.* = .{
-                    .@"comptime" = fields[i].is_comptime,
-                    .@"align" = fields[i].alignment,
+                    .@"comptime" = field_attrs[i].@"comptime",
+                    .@"align" = field_attrs[i].@"align",
                 };
             }
-            break :entry @Struct(.@"extern", null, &field_names, &field_types, &field_attrs);
+            break :entry @Struct(.@"extern", null, &entry_field_names, &entry_field_types, &entry_field_attrs);
         };
         /// This function is used in the debugger pretty formatters in tools/ to fetch the
         /// child field order and entry type to facilitate fancy debug printing for this type.

package/std/os/uefi/protocol/device_path.zig

@@ -82,16 +82,17 @@ pub const DevicePath = extern struct {
     }
 
     pub fn getDevicePath(self: *const DevicePath) ?uefi.DevicePath {
-        inline for (@typeInfo(uefi.DevicePath).@"union".fields) |ufield| {
-            const enum_value = std.meta.stringToEnum(uefi.DevicePath.Type, ufield.name);
+        const u_info = @typeInfo(uefi.DevicePath).@"union";
+        inline for (u_info.field_names, u_info.field_types) |ufield_name, ufield_type| {
+            const enum_value = std.meta.stringToEnum(uefi.DevicePath.Type, ufield_name);
 
             // Got the associated union type for self.type, now
             // we need to initialize it and its subtype
             if (self.type == enum_value) {
-                const subtype = self.initSubtype(ufield.type);
+                const subtype = self.initSubtype(ufield_type);
                 if (subtype) |sb| {
                     // e.g. return .{ .hardware = .{ .pci = @ptrCast(...) } }
-                    return @unionInit(uefi.DevicePath, ufield.name, sb);
+                    return @unionInit(uefi.DevicePath, ufield_name, sb);
                 }
             }
         }
@@ -103,13 +104,13 @@ pub const DevicePath = extern struct {
         const type_info = @typeInfo(TUnion).@"union";
         const TTag = type_info.tag_type.?;
 
-        inline for (type_info.fields) |subtype| {
+        inline for (type_info.field_names, type_info.field_types) |subtype_name, subtype_type| {
             // The tag names match the union names, so just grab that off the enum
-            const tag_val: u8 = @intFromEnum(@field(TTag, subtype.name));
+            const tag_val: u8 = @intFromEnum(@field(TTag, subtype_name));
 
             if (self.subtype == tag_val) {
                 // e.g. expr = .{ .pci = @ptrCast(...) }
-                return @unionInit(TUnion, subtype.name, @as(subtype.type, @ptrCast(self)));
+                return @unionInit(TUnion, subtype_name, @as(subtype_type, @ptrCast(self)));
             }
         }
 

package/std/os/uefi/tables/boot_services.zig

@@ -1271,7 +1271,7 @@ fn ProtocolInterfaces(HandleType: type, Interfaces: type) type {
         @compileError("expected tuple of protocol interfaces, got " ++ @typeName(Interfaces));
     const interfaces_info = interfaces_type_info.@"struct";
 
-    var tuple_types: [interfaces_info.fields.len * 2 + 2]type = undefined;
+    var tuple_types: [interfaces_info.field_names.len * 2 + 2]type = undefined;
     tuple_types[0] = HandleType;
     tuple_types[tuple_types.len - 1] = ?*const Guid;
 

package/std/os/windows.zig

@@ -144,7 +144,7 @@ pub const OBJECT = struct {
         Session = 5,
         _,
 
-        pub const Max: @typeInfo(@This()).@"enum".tag_type = @typeInfo(@This()).@"enum".fields.len;
+        pub const Max: @typeInfo(@This()).@"enum".tag_type = @typeInfo(@This()).@"enum".field_names.len;
     };
 
     pub const NAME_INFORMATION = extern struct {
@@ -575,7 +575,7 @@ pub const FILE = struct {
         MupProvider = 83,
         _,
 
-        pub const Maximum: @typeInfo(@This()).@"enum".tag_type = 1 + @typeInfo(@This()).@"enum".fields.len;
+        pub const Maximum: @typeInfo(@This()).@"enum".tag_type = 1 + @typeInfo(@This()).@"enum".field_names.len;
     };
 
     pub const BASIC_INFORMATION = extern struct {
@@ -881,7 +881,7 @@ pub const DIRECTORY = struct {
         NotifyFull = 3,
         _,
 
-        pub const Maximum: @typeInfo(@This()).@"enum".tag_type = 1 + @typeInfo(@This()).@"enum".fields.len;
+        pub const Maximum: @typeInfo(@This()).@"enum".tag_type = 1 + @typeInfo(@This()).@"enum".field_names.len;
     };
 };
 
@@ -930,14 +930,8 @@ pub const CONSOLE = struct {
 
                     pub const Tag = @typeInfo(WITH).@"union".tag_type.?;
                     pub const Payload = PAYLOAD: {
-                        const with_fields = @typeInfo(WITH).@"union".fields;
-                        var field_names: [with_fields.len][]const u8 = undefined;
-                        var field_types: [with_fields.len]type = undefined;
-                        for (with_fields, &field_names, &field_types) |field, *field_name, *field_type| {
-                            field_name.* = field.name;
-                            field_type.* = field.type;
-                        }
-                        break :PAYLOAD @Union(.@"extern", null, &field_names, &field_types, &@splat(.{}));
+                        const with_info = @typeInfo(WITH).@"union";
+                        break :PAYLOAD @Union(.@"extern", null, with_info.field_names, with_info.field_types[0..], &@splat(.{}));
                     };
                 };
             };
@@ -2122,7 +2116,7 @@ pub const HEAP = opaque {
                     Custom,
                     _,
 
-                    pub const Max: @typeInfo(@This()).@"enum".tag_type = @typeInfo(@This()).@"enum".fields.len;
+                    pub const Max: @typeInfo(@This()).@"enum".tag_type = @typeInfo(@This()).@"enum".field_names.len;
                 };
 
                 pub const VA_CALLBACKS = extern struct {
@@ -3369,7 +3363,7 @@ pub const FS_INFORMATION_CLASS = enum(c_int) {
     Guid = 15,
     _,
 
-    pub const Maximum: @typeInfo(@This()).@"enum".tag_type = 1 + @typeInfo(@This()).@"enum".fields.len;
+    pub const Maximum: @typeInfo(@This()).@"enum".tag_type = 1 + @typeInfo(@This()).@"enum".field_names.len;
 };
 
 pub const SECTION_INHERIT = enum(c_int) {
@@ -3493,7 +3487,7 @@ pub const MEM = struct {
             ImageMachine,
             _,
 
-            pub const Max: @typeInfo(@This()).@"enum".tag_type = @typeInfo(@This()).@"enum".fields.len;
+            pub const Max: @typeInfo(@This()).@"enum".tag_type = @typeInfo(@This()).@"enum".field_names.len;
         };
     };
 };
@@ -4467,7 +4461,7 @@ pub const KEY = struct {
             Layer = 5,
             _,
 
-            pub const Max: @typeInfo(@This()).@"enum".tag_type = @typeInfo(@This()).@"enum".fields.len;
+            pub const Max: @typeInfo(@This()).@"enum".tag_type = @typeInfo(@This()).@"enum".field_names.len;
         };
 
         pub const PARTIAL_INFORMATION = extern struct {

package/std/start.zig

@@ -24,7 +24,7 @@ comptime {
         if (native_os == .windows and !builtin.link_libc and !@hasDecl(root, dll_main_crt_startup)) {
             @export(&DllMainCRTStartup, .{ .name = dll_main_crt_startup });
         } else if (native_os == .windows and builtin.link_libc and @hasDecl(root, "DllMain")) {
-            if (!@typeInfo(@TypeOf(root.DllMain)).@"fn".calling_convention.eql(.winapi)) {
+            if (!@typeInfo(@TypeOf(root.DllMain)).@"fn".attrs.@"callconv".eql(.winapi)) {
                 @export(&DllMain, .{ .name = "DllMain" });
             }
         }
@@ -32,11 +32,11 @@ comptime {
         if (builtin.link_libc and @hasDecl(root, "main")) {
             if (is_wasm) {
                 @export(&mainWithoutEnv, .{ .name = "__main_argc_argv" });
-            } else if (!@typeInfo(@TypeOf(root.main)).@"fn".calling_convention.eql(.c)) {
+            } else if (!@typeInfo(@TypeOf(root.main)).@"fn".attrs.@"callconv".eql(.c)) {
                 @export(&main, .{ .name = "main" });
             }
         } else if (native_os == .windows and builtin.link_libc and @hasDecl(root, "wWinMain")) {
-            if (!@typeInfo(@TypeOf(root.wWinMain)).@"fn".calling_convention.eql(.c)) {
+            if (!@typeInfo(@TypeOf(root.wWinMain)).@"fn".attrs.@"callconv".eql(.c)) {
                 @export(&wWinMain, .{ .name = "wWinMain" });
             }
         } else if (native_os == .windows) {
@@ -728,8 +728,8 @@ var safe_allocator: std.heap.SafeAllocator = .init(std.heap.page_allocator, .{})
 
 inline fn callMain(args: std.process.Args.Vector, environ: std.process.Environ.Block) u8 {
     const fn_info = @typeInfo(@TypeOf(root.main)).@"fn";
-    if (fn_info.params.len == 0) return wrapMain(root.main());
-    if (fn_info.params[0].type.? == std.process.Init.Minimal) return wrapMain(root.main(.{
+    if (fn_info.param_types.len == 0) return wrapMain(root.main());
+    if (fn_info.param_types[0].? == std.process.Init.Minimal) return wrapMain(root.main(.{
         .args = .{ .vector = args },
         .environ = .{ .block = environ },
     }));
@@ -809,7 +809,7 @@ inline fn wrapMain(result: anytype) u8 {
 
 fn call_wWinMain() std.os.windows.INT {
     const peb = std.os.windows.peb();
-    const MAIN_HINSTANCE = @typeInfo(@TypeOf(root.wWinMain)).@"fn".params[0].type.?;
+    const MAIN_HINSTANCE = @typeInfo(@TypeOf(root.wWinMain)).@"fn".param_types[0].?;
     const hInstance: MAIN_HINSTANCE = @ptrCast(peb.ImageBaseAddress);
     const lpCmdLine: [*:0]u16 = @ptrCast(peb.ProcessParameters.CommandLine.Buffer);
 

package/std/testing/Smith.zig

@@ -35,7 +35,12 @@ fn fromExcessK(T: type, x: Backing(T)) T {
     return @as(T, @bitCast(x)) +% std.math.minInt(T);
 }
 
-fn enumFieldLessThan(_: void, a: std.builtin.Type.EnumField, b: std.builtin.Type.EnumField) bool {
+const EnumField = struct {
+    name: [:0]const u8,
+    value: comptime_int,
+};
+
+fn enumFieldLessThan(_: void, a: EnumField, b: EnumField) bool {
     return a.value < b.value;
 }
 
@@ -67,17 +72,26 @@ pub inline fn baselineWeights(T: type) []const Weight {
             baselineWeights(Backing(T))
         else
             @compileError("non-packed unions cannot be weighted"),
-        .@"enum" => |e| if (!e.is_exhaustive)
+        .@"enum" => |e| if (e.mode == .nonexhaustive)
             baselineWeights(e.tag_type)
-        else if (e.fields.len == 0)
+        else if (e.field_names.len == 0)
             // Cannot be included in below branch due to `log2_int_ceil`
             @compileError("exhaustive zero-field enums cannot be weighted")
         else e: {
-            @setEvalBranchQuota(@intCast(4 * e.fields.len *
-                std.math.log2_int_ceil(usize, e.fields.len)));
-
-            var sorted_fields = e.fields[0..e.fields.len].*;
-            std.mem.sortUnstable(std.builtin.Type.EnumField, &sorted_fields, {}, enumFieldLessThan);
+            @setEvalBranchQuota(@intCast(4 * e.field_names.len *
+                std.math.log2_int_ceil(usize, e.field_names.len)));
+
+            var sorted_fields = blk: {
+                var fields: [e.field_names.len]EnumField = undefined;
+                for (e.field_names, e.field_values, &fields) |f_name, f_value, *field| {
+                    field.* = .{
+                        .name = f_name,
+                        .value = f_value,
+                    };
+                }
+                break :blk fields;
+            };
+            std.mem.sortUnstable(EnumField, &sorted_fields, {}, enumFieldLessThan);
 
             var weights: []const Weight = &.{};
             var seq_first: u64 = sorted_fields[0].value;
@@ -316,10 +330,10 @@ fn weightsContain(int: u64, weights: []const Weight) bool {
 inline fn allBitPatternsValid(T: type) bool {
     return comptime switch (@typeInfo(T)) {
         .void, .bool, .int, .float => true,
-        inline .@"struct", .@"union" => |c| c.layout == .@"packed" and for (c.fields) |f| {
-            if (!allBitPatternsValid(f.type)) break false;
+        inline .@"struct", .@"union" => |c| c.layout == .@"packed" and for (c.field_types) |f_type| {
+            if (!allBitPatternsValid(f_type)) break false;
         } else true,
-        .@"enum" => |e| !e.is_exhaustive,
+        .@"enum" => |e| e.mode == .nonexhaustive,
         else => unreachable,
     };
 }
@@ -346,16 +360,16 @@ fn UnionTagWithoutUninitializable(T: type) type {
     const u = @typeInfo(T).@"union";
     const Tag = u.tag_type orelse @compileError("union must have tag");
     const e = @typeInfo(Tag).@"enum";
-    var field_names: [e.fields.len][]const u8 = undefined;
-    var field_values: [e.fields.len]e.tag_type = undefined;
+    var field_names: [e.field_names.len][]const u8 = undefined;
+    var field_values: [e.field_names.len]e.tag_type = undefined;
     var n_fields = 0;
-    for (u.fields) |f| {
-        switch (f.type) {
+    for (u.field_names, u.field_types) |f_name, f_type| {
+        switch (f_type) {
             noreturn => continue,
             else => {},
         }
-        field_names[n_fields] = f.name;
-        field_values[n_fields] = @intFromEnum(@field(Tag, f.name));
+        field_names[n_fields] = f_name;
+        field_values[n_fields] = @intFromEnum(@field(Tag, f_name));
         n_fields += 1;
     }
     return @Enum(e.tag_type, .exhaustive, field_names[0..n_fields], field_values[0..n_fields]);
@@ -381,12 +395,12 @@ pub fn valueWithHash(s: *Smith, T: type, hash: u32) T {
             }
             break :full @bitCast(int);
         },
-        .@"enum" => |e| if (e.is_exhaustive) v: {
+        .@"enum" => |e| if (e.mode == .exhaustive) v: {
             if (@bitSizeOf(e.tag_type) <= 64) {
                 break :v s.valueWeightedWithHash(T, baselineWeights(T), hash);
             }
             break :v std.enums.fromInt(T, s.valueWithHash(e.tag_type, hash)) orelse
-                @enumFromInt(e.fields[0].value);
+                @enumFromInt(e.field_values[0]);
         } else @enumFromInt(s.valueWithHash(e.tag_type, hash)),
         .optional => |o| if (s.valueWithHash(bool, hash))
             null
@@ -406,11 +420,11 @@ pub fn valueWithHash(s: *Smith, T: type, hash: u32) T {
         .@"struct" => |st| if (!allBitPatternsValid(T)) v: {
             var v: T = undefined;
             var rhash = hash;
-            inline for (st.fields) |f| {
+            inline for (st.field_names, st.field_types) |f_name, f_type| {
                 // rhash is incremented in the call so our rhash state is not reused (e.g. with
                 // two nested structs. note that xor cannot work for this case as the bit would
                 // be flipped back here)
-                @field(v, f.name) = s.valueWithHash(f.type, rhash +% 1);
+                @field(v, f_name) = s.valueWithHash(f_type, rhash +% 1);
                 rhash = std.hash.int(rhash);
             }
             break :v v;

package/std/testing.zig

@@ -141,16 +141,16 @@ fn expectEqualInner(comptime T: type, expected: T, actual: T) !void {
         },
 
         .@"struct" => |structType| {
-            inline for (structType.fields) |field| {
-                try expectEqual(@field(expected, field.name), @field(actual, field.name));
+            inline for (structType.field_names) |field_name| {
+                try expectEqual(@field(expected, field_name), @field(actual, field_name));
             }
         },
 
         .@"union" => |union_info| {
             if (union_info.tag_type == null) {
-                const first_size = @bitSizeOf(union_info.fields[0].type);
-                inline for (union_info.fields) |field| {
-                    if (@bitSizeOf(field.type) != first_size) {
+                const first_size = @bitSizeOf(union_info.field_types[0]);
+                inline for (union_info.field_types) |field_type| {
+                    if (@bitSizeOf(field_type) != first_size) {
                         @compileError("Unable to compare untagged unions with varying field sizes for type " ++ @typeName(@TypeOf(actual)));
                     }
                 }
@@ -840,9 +840,9 @@ fn expectEqualDeepInner(comptime T: type, expected: T, actual: T) error{TestExpe
         },
 
         .@"struct" => |structType| {
-            inline for (structType.fields) |field| {
-                expectEqualDeep(@field(expected, field.name), @field(actual, field.name)) catch |e| {
-                    print("Field {s} incorrect. expected {any}, found {any}\n", .{ field.name, @field(expected, field.name), @field(actual, field.name) });
+            inline for (structType.field_names) |field_name| {
+                expectEqualDeep(@field(expected, field_name), @field(actual, field_name)) catch |e| {
+                    print("Field {s} incorrect. expected {any}, found {any}\n", .{ field_name, @field(expected, field_name), @field(actual, field_name) });
                     return e;
                 };
             }
@@ -1165,14 +1165,14 @@ fn CheckAllAllocationFailuresExtraArgs(comptime TestFn: type) type {
 
     const ArgsTuple = std.meta.ArgsTuple(TestFn);
 
-    const fields = @typeInfo(ArgsTuple).@"struct".fields;
-    if (fields.len == 0 or fields[0].type != std.mem.Allocator) {
+    const field_types = @typeInfo(ArgsTuple).@"struct".field_types;
+    if (field_types.len == 0 or field_types[0] != std.mem.Allocator) {
         @compileError("The provided function must have an " ++ @typeName(std.mem.Allocator) ++ " as its first argument");
     }
 
-    var extra_args: [fields.len - 1]type = undefined;
-    for (&extra_args, fields[1..]) |*arg, field| {
-        arg.* = field.type;
+    var extra_args: [field_types.len - 1]type = undefined;
+    for (&extra_args, field_types[1..]) |*arg, field_type| {
+        arg.* = field_type;
     }
 
     return @Tuple(&extra_args);
@@ -1204,8 +1204,8 @@ test "checkAllAllocationFailures provide result type to 'extra_args' argument" {
 /// Given a type, references all the declarations inside, so that the semantic analyzer sees them.
 pub fn refAllDecls(comptime T: type) void {
     if (!builtin.is_test) return;
-    inline for (comptime std.meta.declarations(T)) |decl| {
-        _ = &@field(T, decl.name);
+    inline for (comptime std.meta.declarations(T)) |decl_name| {
+        _ = &@field(T, decl_name);
     }
 }
 

package/std/zig/Ast.zig

@@ -298,17 +298,17 @@ pub fn extraDataSliceWithLen(tree: Ast, start: ExtraIndex, len: u32, comptime T:
 }
 
 pub fn extraData(tree: Ast, index: ExtraIndex, comptime T: type) T {
-    const fields = std.meta.fields(T);
+    const info = @typeInfo(T).@"struct";
     var result: T = undefined;
-    inline for (fields, 0..) |field, i| {
-        @field(result, field.name) = switch (field.type) {
+    inline for (info.field_names, info.field_types, 0..) |field_name, field_type, i| {
+        @field(result, field_name) = switch (field_type) {
             Node.Index,
             Node.OptionalIndex,
             OptionalTokenIndex,
             ExtraIndex,
             => @enumFromInt(tree.extra_data[@intFromEnum(index) + i]),
             TokenIndex => tree.extra_data[@intFromEnum(index) + i],
-            else => @compileError("unexpected field type: " ++ @typeName(field.type)),
+            else => @compileError("unexpected field type: " ++ @typeName(field_type)),
         };
     }
     return result;