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

package/compiler/Maker/ScannedConfig.zig

@@ -49,9 +49,10 @@ pub fn print(sc: *const ScannedConfig, w: *Writer) Writer.Error!void {
 }
 
 fn printStruct(sc: *const ScannedConfig, s: *Serializer.Struct, comptime S: type, v: S) !void {
-    inline for (@typeInfo(S).@"struct".fields) |field| {
-        try s.fieldPrefix(field.name);
-        try printValue(sc, s.container.serializer, field.type, @field(v, field.name));
+    const info = @typeInfo(S).@"struct";
+    inline for (info.field_names, info.field_types) |field_name, field_type| {
+        try s.fieldPrefix(field_name);
+        try printValue(sc, s.container.serializer, field_type, @field(v, field_name));
     }
 }
 

package/compiler/Maker/Step/FindProgram.zig

@@ -113,8 +113,8 @@ fn checkCandidate(
 }
 
 fn supportedWindowsProgramExtension(ext: []const u8) bool {
-    inline for (@typeInfo(std.process.WindowsExtension).@"enum".fields) |field| {
-        if (std.ascii.eqlIgnoreCase(ext, "." ++ field.name)) return true;
+    inline for (@typeInfo(std.process.WindowsExtension).@"enum".field_names) |field_name| {
+        if (std.ascii.eqlIgnoreCase(ext, "." ++ field_name)) return true;
     }
     return false;
 }

package/compiler/Maker/Watch/FsEvents.zig

@@ -87,8 +87,9 @@ pub fn init(cwd_path: []const u8) error{ OpenFrameworkFailed, MissingCoreService
     errdefer core_services.close();
 
     var resolved_symbols: ResolvedSymbols = undefined;
-    inline for (@typeInfo(ResolvedSymbols).@"struct".fields) |f| {
-        @field(resolved_symbols, f.name) = core_services.lookup(f.type, f.name) orelse return error.MissingCoreServicesSymbol;
+    const info = @typeInfo(ResolvedSymbols).@"struct";
+    inline for (info.field_names, info.field_types) |f_name, f_type| {
+        @field(resolved_symbols, f_name) = core_services.lookup(f_type, f_name) orelse return error.MissingCoreServicesSymbol;
     }
 
     return .{

package/compiler/aro/aro/Attribute.zig

@@ -89,9 +89,9 @@ pub fn requiredArgCount(attr: Tag) u32 {
         inline else => |tag| {
             comptime var needed = 0;
             comptime {
-                const fields = @typeInfo(@field(attributes, @tagName(tag))).@"struct".fields;
-                for (fields) |arg_field| {
-                    if (!mem.eql(u8, arg_field.name, "__name_tok") and @typeInfo(arg_field.type) != .optional) needed += 1;
+                const info = @typeInfo(@field(attributes, @tagName(tag))).@"struct";
+                for (info.field_names, info.field_types) |arg_field_name, arg_field_type| {
+                    if (!mem.eql(u8, arg_field_name, "__name_tok") and @typeInfo(arg_field_type) != .optional) needed += 1;
                 }
             }
             return needed;
@@ -105,9 +105,9 @@ pub fn maxArgCount(attr: Tag) u32 {
         inline else => |tag| {
             comptime var max = 0;
             comptime {
-                const fields = @typeInfo(@field(attributes, @tagName(tag))).@"struct".fields;
-                for (fields) |arg_field| {
-                    if (!mem.eql(u8, arg_field.name, "__name_tok")) max += 1;
+                const field_names = @typeInfo(@field(attributes, @tagName(tag))).@"struct".field_names;
+                for (field_names) |arg_field_name| {
+                    if (!mem.eql(u8, arg_field_name, "__name_tok")) max += 1;
                 }
             }
             return max;
@@ -130,10 +130,10 @@ pub const Formatting = struct {
         switch (attr) {
             .calling_convention => unreachable,
             inline else => |tag| {
-                const fields = @typeInfo(@field(attributes, @tagName(tag))).@"struct".fields;
+                const field_types = @typeInfo(@field(attributes, @tagName(tag))).@"struct".field_types;
 
-                if (fields.len == 0) unreachable;
-                const Unwrapped = UnwrapOptional(fields[0].type);
+                if (field_types.len == 0) unreachable;
+                const Unwrapped = UnwrapOptional(field_types[0]);
                 if (@typeInfo(Unwrapped) != .@"enum") unreachable;
 
                 return if (Unwrapped.opts.enum_kind == .identifier) "'" else "\"";
@@ -147,18 +147,18 @@ pub const Formatting = struct {
         switch (attr) {
             .calling_convention => unreachable,
             inline else => |tag| {
-                const fields = @typeInfo(@field(attributes, @tagName(tag))).@"struct".fields;
+                const field_types = @typeInfo(@field(attributes, @tagName(tag))).@"struct".field_types;
 
-                if (fields.len == 0) unreachable;
-                const Unwrapped = UnwrapOptional(fields[0].type);
+                if (field_types.len == 0) unreachable;
+                const Unwrapped = UnwrapOptional(field_types[0]);
                 if (@typeInfo(Unwrapped) != .@"enum") unreachable;
 
-                const enum_fields = @typeInfo(Unwrapped).@"enum".fields;
+                const enum_field_names = @typeInfo(Unwrapped).@"enum".field_names;
                 const quote = comptime quoteChar(@enumFromInt(@intFromEnum(tag)));
-                comptime var values: []const u8 = quote ++ enum_fields[0].name ++ quote;
-                inline for (enum_fields[1..]) |enum_field| {
+                comptime var values: []const u8 = quote ++ enum_field_names[0] ++ quote;
+                inline for (enum_field_names[1..]) |enum_field_name| {
                     values = values ++ ", ";
-                    values = values ++ quote ++ enum_field.name ++ quote;
+                    values = values ++ quote ++ enum_field_name ++ quote;
                 }
                 return values;
             },
@@ -171,10 +171,10 @@ pub fn wantsIdentEnum(attr: Tag) bool {
     switch (attr) {
         .calling_convention => return false,
         inline else => |tag| {
-            const fields = @typeInfo(@field(attributes, @tagName(tag))).@"struct".fields;
+            const field_types = @typeInfo(@field(attributes, @tagName(tag))).@"struct".field_types;
 
-            if (fields.len == 0) return false;
-            const Unwrapped = UnwrapOptional(fields[0].type);
+            if (field_types.len == 0) return false;
+            const Unwrapped = UnwrapOptional(field_types[0]);
             if (@typeInfo(Unwrapped) != .@"enum") return false;
 
             return Unwrapped.opts.enum_kind == .identifier;
@@ -185,12 +185,12 @@ pub fn wantsIdentEnum(attr: Tag) bool {
 pub fn diagnoseIdent(attr: Tag, arguments: *Arguments, ident: TokenIndex, p: *Parser) !bool {
     switch (attr) {
         inline else => |tag| {
-            const fields = @typeInfo(@field(attributes, @tagName(tag))).@"struct".fields;
-            if (fields.len == 0) unreachable;
-            const Unwrapped = UnwrapOptional(fields[0].type);
+            const info = @typeInfo(@field(attributes, @tagName(tag))).@"struct";
+            if (info.field_names.len == 0) unreachable;
+            const Unwrapped = UnwrapOptional(info.field_types[0]);
             if (@typeInfo(Unwrapped) != .@"enum") unreachable;
             if (std.meta.stringToEnum(Unwrapped, normalize(p.tokSlice(ident)))) |enum_val| {
-                @field(@field(arguments, @tagName(tag)), fields[0].name) = enum_val;
+                @field(@field(arguments, @tagName(tag)), info.field_names[0]) = enum_val;
                 return false;
             }
 
@@ -203,11 +203,11 @@ pub fn diagnoseIdent(attr: Tag, arguments: *Arguments, ident: TokenIndex, p: *Pa
 pub fn wantsAlignment(attr: Tag, idx: usize) bool {
     switch (attr) {
         inline else => |tag| {
-            const fields = @typeInfo(@field(attributes, @tagName(tag))).@"struct".fields;
-            if (fields.len == 0) return false;
+            const field_types = @typeInfo(@field(attributes, @tagName(tag))).@"struct".field_types;
+            if (field_types.len == 0) return false;
 
             return switch (idx) {
-                inline 0...fields.len - 1 => |i| UnwrapOptional(fields[i].type) == Alignment,
+                inline 0...field_types.len - 1 => |i| UnwrapOptional(field_types[i]) == Alignment,
                 else => false,
             };
         },
@@ -217,12 +217,12 @@ pub fn wantsAlignment(attr: Tag, idx: usize) bool {
 pub fn diagnoseAlignment(attr: Tag, arguments: *Arguments, arg_idx: u32, res: Parser.Result, arg_start: TokenIndex, p: *Parser) !bool {
     switch (attr) {
         inline else => |tag| {
-            const arg_fields = @typeInfo(@field(attributes, @tagName(tag))).@"struct".fields;
-            if (arg_fields.len == 0) unreachable;
+            const arg_info = @typeInfo(@field(attributes, @tagName(tag))).@"struct";
+            if (arg_info.field_names.len == 0) unreachable;
 
             switch (arg_idx) {
-                inline 0...arg_fields.len - 1 => |arg_i| {
-                    if (UnwrapOptional(arg_fields[arg_i].type) != Alignment) unreachable;
+                inline 0...arg_info.field_names.len - 1 => |arg_i| {
+                    if (UnwrapOptional(arg_info.field_types[arg_i]) != Alignment) unreachable;
 
                     if (!res.val.is(.int, p.comp)) {
                         try p.err(arg_start, .alignas_unavailable, .{});
@@ -241,7 +241,7 @@ pub fn diagnoseAlignment(attr: Tag, arguments: *Arguments, arg_idx: u32, res: Pa
                         return true;
                     }
 
-                    @field(@field(arguments, @tagName(tag)), arg_fields[arg_i].name) = .{ .requested = requested };
+                    @field(@field(arguments, @tagName(tag)), arg_info.field_names[arg_i]) = .{ .requested = requested };
                     return false;
                 },
                 else => unreachable,
@@ -251,8 +251,8 @@ pub fn diagnoseAlignment(attr: Tag, arguments: *Arguments, arg_idx: u32, res: Pa
 }
 
 fn diagnoseField(
-    comptime decl: ZigType.Declaration,
-    comptime field: ZigType.StructField,
+    comptime decl_name: []const u8,
+    comptime field_name: []const u8,
     comptime Wanted: type,
     arguments: *Arguments,
     res: Parser.Result,
@@ -283,7 +283,7 @@ fn diagnoseField(
 
     if (res.val.opt_ref == .none) {
         if (Wanted == Identifier and node == .decl_ref_expr) {
-            @field(@field(arguments, decl.name), field.name) = .{ .tok = node.decl_ref_expr.name_tok };
+            @field(@field(arguments, decl_name), field_name) = .{ .tok = node.decl_ref_expr.name_tok };
             return false;
         }
 
@@ -294,7 +294,7 @@ fn diagnoseField(
     switch (key) {
         .int => {
             if (@typeInfo(Wanted) == .int) {
-                @field(@field(arguments, decl.name), field.name) = res.val.toInt(Wanted, p.comp) orelse {
+                @field(@field(arguments, decl_name), field_name) = res.val.toInt(Wanted, p.comp) orelse {
                     try p.err(arg_start, .attribute_int_out_of_range, .{res});
                     return true;
                 };
@@ -310,20 +310,20 @@ fn diagnoseField(
                         .char, .uchar, .schar => {},
                         else => break :validate,
                     }
-                    @field(@field(arguments, decl.name), field.name) = try p.removeNull(res.val);
+                    @field(@field(arguments, decl_name), field_name) = try p.removeNull(res.val);
                     return false;
                 }
 
-                try p.err(arg_start, .attribute_requires_string, .{decl.name});
+                try p.err(arg_start, .attribute_requires_string, .{decl_name});
                 return true;
             } else if (@typeInfo(Wanted) == .@"enum" and @hasDecl(Wanted, "opts") and Wanted.opts.enum_kind == .string) {
                 const str = bytes[0 .. bytes.len - 1];
                 if (std.meta.stringToEnum(Wanted, str)) |enum_val| {
-                    @field(@field(arguments, decl.name), field.name) = enum_val;
+                    @field(@field(arguments, decl_name), field_name) = enum_val;
                     return false;
                 }
 
-                try p.err(arg_start, .unknown_attr_enum, .{ decl.name, Formatting.choices(@field(Tag, decl.name)) });
+                try p.err(arg_start, .unknown_attr_enum, .{ decl_name, Formatting.choices(@field(Tag, decl_name)) });
                 return true;
             }
         },
@@ -344,17 +344,18 @@ fn diagnoseField(
 pub fn diagnose(attr: Tag, arguments: *Arguments, arg_idx: u32, res: Parser.Result, arg_start: TokenIndex, node: Tree.Node, p: *Parser) !bool {
     switch (attr) {
         inline else => |tag| {
-            const decl = @typeInfo(attributes).@"struct".decls[@intFromEnum(tag)];
+            const decl_name = @typeInfo(attributes).@"struct".decl_names[@intFromEnum(tag)];
             const max_arg_count = comptime maxArgCount(tag);
             if (arg_idx >= max_arg_count) {
                 try p.err(arg_start, .attribute_too_many_args, .{ @tagName(attr), max_arg_count });
                 return true;
             }
 
-            const arg_fields = @typeInfo(@field(attributes, decl.name)).@"struct".fields;
+            const arg_field_names = @typeInfo(@field(attributes, decl_name)).@"struct".field_names;
+            const arg_field_types = @typeInfo(@field(attributes, decl_name)).@"struct".field_types;
             switch (arg_idx) {
-                inline 0...arg_fields.len - 1 => |arg_i| {
-                    return diagnoseField(decl, arg_fields[arg_i], UnwrapOptional(arg_fields[arg_i].type), arguments, res, arg_start, node, p);
+                inline 0...arg_field_names.len - 1 => |arg_i| {
+                    return diagnoseField(decl_name, arg_field_names[arg_i], UnwrapOptional(arg_field_types[arg_i]), arguments, res, arg_start, node, p);
                 },
                 else => unreachable,
             }
@@ -722,20 +723,20 @@ const attributes = struct {
 pub const Tag = std.meta.DeclEnum(attributes);
 
 pub const Arguments = blk: {
-    const decls = @typeInfo(attributes).@"struct".decls;
-    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);
+    const decl_names = @typeInfo(attributes).@"struct".decl_names;
+    var names: [decl_names.len][]const u8 = undefined;
+    var types: [decl_names.len]type = undefined;
+    for (decl_names, &names, &types) |decl_name, *name, *T| {
+        name.* = decl_name;
+        T.* = @field(attributes, decl_name);
     }
 
     break :blk @Union(.auto, null, &names, &types, &@splat(.{}));
 };
 
 pub fn ArgumentsForTag(comptime tag: Tag) type {
-    const decl = @typeInfo(attributes).@"struct".decls[@intFromEnum(tag)];
-    return @field(attributes, decl.name);
+    const decl_name = @typeInfo(attributes).@"struct".decl_names[@intFromEnum(tag)];
+    return @field(attributes, decl_name);
 }
 
 pub fn initArguments(tag: Tag, name_tok: TokenIndex) Arguments {

package/compiler/aro/aro/Compilation.zig

@@ -78,12 +78,12 @@ pub const Environment = struct {
     pub fn loadAll(environ_map: *const std.process.Environ.Map) Environment {
         var env: Environment = .{};
 
-        inline for (@typeInfo(@TypeOf(env)).@"struct".fields) |field| {
-            std.debug.assert(@field(env, field.name) == null);
+        inline for (@typeInfo(@TypeOf(env)).@"struct".field_names) |field_name| {
+            std.debug.assert(@field(env, field_name) == null);
 
-            var env_var_buf: [field.name.len]u8 = undefined;
-            const env_var_name = std.ascii.upperString(&env_var_buf, field.name);
-            @field(env, field.name) = environ_map.get(env_var_name);
+            var env_var_buf: [field_name.len]u8 = undefined;
+            const env_var_name = std.ascii.upperString(&env_var_buf, field_name);
+            @field(env, field_name) = environ_map.get(env_var_name);
         }
         return env;
     }

package/compiler/aro/aro/Diagnostics.zig

@@ -333,8 +333,8 @@ pub fn deinit(d: *Diagnostics) void {
 /// Used by the __has_warning builtin macro.
 pub fn warningExists(name: []const u8) bool {
     if (std.mem.eql(u8, name, "pedantic")) return true;
-    inline for (comptime std.meta.declarations(Option)) |group| {
-        if (std.mem.eql(u8, name, group.name)) return true;
+    inline for (comptime std.meta.declarations(Option)) |group_name| {
+        if (std.mem.eql(u8, name, group_name)) return true;
     }
     return std.meta.stringToEnum(Option, name) != null;
 }
@@ -349,9 +349,9 @@ pub fn set(d: *Diagnostics, name: []const u8, to: Message.Kind) Compilation.Erro
         return;
     }
 
-    inline for (comptime std.meta.declarations(Option)) |group| {
-        if (std.mem.eql(u8, name, group.name)) {
-            for (@field(Option, group.name)) |option| {
+    inline for (comptime std.meta.declarations(Option)) |group_name| {
+        if (std.mem.eql(u8, name, group_name)) {
+            for (@field(Option, group_name)) |option| {
                 d.state.options.put(option, to);
             }
             return;
@@ -494,8 +494,8 @@ pub fn addWithLocation(
 
 pub fn formatArgs(w: *std.Io.Writer, fmt: []const u8, args: anytype) std.Io.Writer.Error!void {
     var i: usize = 0;
-    inline for (std.meta.fields(@TypeOf(args))) |arg_info| {
-        const arg = @field(args, arg_info.name);
+    inline for (comptime std.meta.fieldNames(@TypeOf(args))) |arg_name| {
+        const arg = @field(args, arg_name);
         i += switch (@TypeOf(arg)) {
             []const u8 => try formatString(w, fmt[i..], arg),
             else => switch (@typeInfo(@TypeOf(arg))) {

package/compiler/aro/aro/Parser.zig

@@ -456,8 +456,8 @@ pub fn err(p: *Parser, tok_i: TokenIndex, diagnostic: Diagnostic, args: anytype)
 
 fn formatArgs(p: *Parser, w: *std.Io.Writer, fmt: []const u8, args: anytype) !void {
     var i: usize = 0;
-    inline for (std.meta.fields(@TypeOf(args))) |arg_info| {
-        const arg = @field(args, arg_info.name);
+    inline for (comptime std.meta.fieldNames(@TypeOf(args))) |arg_name| {
+        const arg = @field(args, arg_name);
         i += switch (@TypeOf(arg)) {
             []const u8 => try Diagnostics.formatString(w, fmt[i..], arg),
             Tree.Token.Id => try formatTokenId(w, fmt[i..], arg),

package/compiler/aro/aro/Tree.zig

@@ -3048,25 +3048,25 @@ fn dumpAttribute(tree: *const Tree, attr: Attribute, w: *std.Io.Writer) !void {
     switch (attr.tag) {
         inline else => |tag| {
             const args = @field(attr.args, @tagName(tag));
-            const fields = @typeInfo(@TypeOf(args)).@"struct".fields;
-            if (fields.len == 0) {
+            const args_info = @typeInfo(@TypeOf(args)).@"struct";
+            if (args_info.field_names.len == 0) {
                 try w.writeByte('\n');
                 return;
             }
             try w.writeByte(' ');
-            inline for (fields, 0..) |f, i| {
-                if (comptime std.mem.eql(u8, f.name, "__name_tok")) continue;
+            inline for (args_info.field_names, args_info.field_types, 0..) |f_name, f_type, i| {
+                if (comptime std.mem.eql(u8, f_name, "__name_tok")) continue;
                 if (i != 0) {
                     try w.writeAll(", ");
                 }
-                try w.writeAll(f.name);
+                try w.writeAll(f_name);
                 try w.writeAll(": ");
-                switch (f.type) {
-                    Interner.Ref => try w.print("\"{s}\"", .{tree.interner.get(@field(args, f.name)).bytes}),
-                    ?Interner.Ref => try w.print("\"{?s}\"", .{if (@field(args, f.name)) |str| tree.interner.get(str).bytes else null}),
-                    else => switch (@typeInfo(f.type)) {
-                        .@"enum" => try w.writeAll(@tagName(@field(args, f.name))),
-                        else => try w.print("{any}", .{@field(args, f.name)}),
+                switch (f_type) {
+                    Interner.Ref => try w.print("\"{s}\"", .{tree.interner.get(@field(args, f_name)).bytes}),
+                    ?Interner.Ref => try w.print("\"{?s}\"", .{if (@field(args, f_name)) |str| tree.interner.get(str).bytes else null}),
+                    else => switch (@typeInfo(f_type)) {
+                        .@"enum" => try w.writeAll(@tagName(@field(args, f_name))),
+                        else => try w.print("{any}", .{@field(args, f_name)}),
                     },
                 }
             }

package/compiler/aro/aro/features.zig

@@ -46,8 +46,8 @@ pub fn hasFeature(comp: *Compilation, ext: []const u8) bool {
         .c_thread_local = comp.langopts.standard.atLeast(.c11) and comp.target.isTlsSupported(),
         .bounds_attributes = comp.langopts.bounds_safety == .clang,
     };
-    inline for (@typeInfo(@TypeOf(list)).@"struct".fields) |f| {
-        if (std.mem.eql(u8, f.name, ext)) return @field(list, f.name);
+    inline for (@typeInfo(@TypeOf(list)).@"struct".field_names) |f_name| {
+        if (std.mem.eql(u8, f_name, ext)) return @field(list, f_name);
     }
     return false;
 }
@@ -70,8 +70,8 @@ pub fn hasExtension(comp: *Compilation, ext: []const u8) bool {
         .matrix_types = false, // TODO
         .matrix_types_scalar_division = false, // TODO
     };
-    inline for (@typeInfo(@TypeOf(list)).@"struct".fields) |f| {
-        if (std.mem.eql(u8, f.name, ext)) return @field(list, f.name);
+    inline for (@typeInfo(@TypeOf(list)).@"struct".field_names) |f_name| {
+        if (std.mem.eql(u8, f_name, ext)) return @field(list, f_name);
     }
     return false;
 }

package/compiler/aro/aro/text_literal.zig

@@ -335,8 +335,8 @@ pub const Parser = struct {
 
     fn formatArgs(w: *std.Io.Writer, fmt: []const u8, args: anytype) !void {
         var i: usize = 0;
-        inline for (std.meta.fields(@TypeOf(args))) |arg_info| {
-            const arg = @field(args, arg_info.name);
+        inline for (comptime std.meta.fieldNames(@TypeOf(args))) |arg_name| {
+            const arg = @field(args, arg_name);
             i += switch (@TypeOf(arg)) {
                 []const u8 => try Diagnostics.formatString(w, fmt[i..], arg),
                 Ascii => try arg.format(w, fmt[i..]),

package/compiler/aro/backend/Interner.zig

@@ -733,7 +733,7 @@ pub fn put(i: *Interner, gpa: Allocator, key: Key) !Ref {
             });
         },
         .record_ty => |elems| {
-            try i.extra.ensureUnusedCapacity(gpa, @typeInfo(Tag.Record).@"struct".fields.len +
+            try i.extra.ensureUnusedCapacity(gpa, @typeInfo(Tag.Record).@"struct".field_names.len +
                 elems.len);
             i.items.appendAssumeCapacity(.{
                 .tag = .record_ty,
@@ -755,18 +755,19 @@ pub fn put(i: *Interner, gpa: Allocator, key: Key) !Ref {
 }
 
 fn addExtra(i: *Interner, gpa: Allocator, extra: anytype) Allocator.Error!u32 {
-    const fields = @typeInfo(@TypeOf(extra)).@"struct".fields;
-    try i.extra.ensureUnusedCapacity(gpa, fields.len);
+    const field_count = @typeInfo(@TypeOf(extra)).@"struct".field_names.len;
+    try i.extra.ensureUnusedCapacity(gpa, field_count);
     return i.addExtraAssumeCapacity(extra);
 }
 
 fn addExtraAssumeCapacity(i: *Interner, extra: anytype) u32 {
     const result = @as(u32, @intCast(i.extra.items.len));
-    inline for (@typeInfo(@TypeOf(extra)).@"struct".fields) |field| {
-        i.extra.appendAssumeCapacity(switch (field.type) {
-            Ref => @intFromEnum(@field(extra, field.name)),
-            u32 => @field(extra, field.name),
-            else => @compileError("bad field type: " ++ @typeName(field.type)),
+    const info = @typeInfo(@TypeOf(extra)).@"struct";
+    inline for (info.field_names, info.field_types) |field_name, field_type| {
+        i.extra.appendAssumeCapacity(switch (field_type) {
+            Ref => @intFromEnum(@field(extra, field_name)),
+            u32 => @field(extra, field_name),
+            else => @compileError("bad field type: " ++ @typeName(field_type)),
         });
     }
     return result;
@@ -891,17 +892,17 @@ fn extraData(i: *const Interner, comptime T: type, index: usize) T {
 
 fn extraDataTrail(i: *const Interner, comptime T: type, index: usize) struct { data: T, end: u32 } {
     var result: T = undefined;
-    const fields = @typeInfo(T).@"struct".fields;
-    inline for (fields, 0..) |field, field_i| {
+    const info = @typeInfo(T).@"struct";
+    inline for (info.field_names, info.field_types, 0..) |field_name, field_type, field_i| {
         const int32 = i.extra.items[field_i + index];
-        @field(result, field.name) = switch (field.type) {
+        @field(result, field_name) = switch (field_type) {
             Ref => @enumFromInt(int32),
             u32 => int32,
-            else => @compileError("bad field type: " ++ @typeName(field.type)),
+            else => @compileError("bad field type: " ++ @typeName(field_type)),
         };
     }
     return .{
         .data = result,
-        .end = @intCast(index + fields.len),
+        .end = @intCast(index + info.field_names.len),
     };
 }

package/compiler/configurer.zig

@@ -601,8 +601,8 @@ const Serialize = struct {
             dest_module.* = try addModule(s, src_module);
         }
 
-        comptime assert(std.mem.eql(u8, @typeInfo(Configuration.Module).@"struct".fields[2].name, "import_table"));
-        comptime assert(@typeInfo(Configuration.Module).@"struct".fields[2].type == Configuration.ImportTable.Index);
+        comptime assert(std.mem.eql(u8, @typeInfo(Configuration.Module).@"struct".field_names[2], "import_table"));
+        comptime assert(@typeInfo(Configuration.Module).@"struct".field_types[2] == Configuration.ImportTable.Index);
         assert(wc.extra.items[@intFromEnum(module_index) + 2] == @intFromEnum(Configuration.ImportTable.Index.invalid));
         const import_table_index = try wc.addDeduped(Configuration.ImportTable, .{
             .imports = .{ .mal = imports },

package/compiler/resinator/bmp.zig

@@ -241,8 +241,9 @@ pub const Compression = enum(u32) {
 };
 
 fn structFieldsLittleToNative(comptime T: type, x: *T) void {
-    inline for (@typeInfo(T).@"struct".fields) |field| {
-        @field(x, field.name) = std.mem.littleToNative(field.type, @field(x, field.name));
+    const info = @typeInfo(T).@"struct";
+    inline for (info.field_names, info.field_types) |field_name, field_type| {
+        @field(x, field_name) = std.mem.littleToNative(field_type, @field(x, field_name));
     }
 }
 

package/compiler/resinator/code_pages.zig

@@ -178,19 +178,20 @@ pub const UnsupportedCodePage = enum(u16) {
 };
 
 pub const CodePage = blk: {
-    const fields = @typeInfo(SupportedCodePage).@"enum".fields ++ @typeInfo(UnsupportedCodePage).@"enum".fields;
-    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;
+    const field_names = @typeInfo(SupportedCodePage).@"enum".field_names ++ @typeInfo(UnsupportedCodePage).@"enum".field_names;
+    const field_values = @typeInfo(SupportedCodePage).@"enum".field_values ++ @typeInfo(UnsupportedCodePage).@"enum".field_values;
+    var cp_field_names: [field_names.len][]const u8 = undefined;
+    var cp_field_values: [field_names.len]u16 = undefined;
+    for (field_names, field_values, &cp_field_names, &cp_field_values) |field_name, field_value, *name, *val| {
+        name.* = field_name;
+        val.* = field_value;
     }
-    break :blk @Enum(u16, .exhaustive, &field_names, &field_values);
+    break :blk @Enum(u16, .exhaustive, &cp_field_names, &cp_field_values);
 };
 
 pub fn isSupported(code_page: CodePage) bool {
-    inline for (@typeInfo(SupportedCodePage).@"enum".fields) |enumField| {
-        if (@intFromEnum(code_page) == @intFromEnum(@field(SupportedCodePage, enumField.name))) {
+    inline for (@typeInfo(SupportedCodePage).@"enum".field_names) |field_name| {
+        if (@intFromEnum(code_page) == @intFromEnum(@field(SupportedCodePage, field_name))) {
             return true;
         }
     }
@@ -200,9 +201,10 @@ pub fn isSupported(code_page: CodePage) bool {
 pub fn getByIdentifier(identifier: u16) !CodePage {
     // There's probably a more efficient way to do this (e.g. ComptimeHashMap?) but
     // this should be fine, especially since this function likely won't be called much.
-    inline for (@typeInfo(CodePage).@"enum".fields) |enumField| {
-        if (identifier == enumField.value) {
-            return @field(CodePage, enumField.name);
+    const info = @typeInfo(CodePage).@"enum";
+    inline for (info.field_names, info.field_values) |field_name, field_value| {
+        if (identifier == field_value) {
+            return @field(CodePage, field_name);
         }
     }
     return error.InvalidCodePage;

package/compiler/resinator/cvtres.zig

@@ -1054,17 +1054,18 @@ pub const supported_targets = struct {
             .ebc,
         };
         comptime {
-            for (@typeInfo(Arch).@"enum".fields) |enum_field| {
-                _ = std.mem.indexOfScalar(Arch, ordered_for_display, @enumFromInt(enum_field.value)) orelse {
-                    @compileError(std.fmt.comptimePrint("'{s}' missing from ordered_for_display", .{enum_field.name}));
+            const info = @typeInfo(Arch).@"enum";
+            for (info.field_names, info.field_values) |field_name, field_value| {
+                _ = std.mem.indexOfScalar(Arch, ordered_for_display, @enumFromInt(field_value)) orelse {
+                    @compileError(std.fmt.comptimePrint("'{s}' missing from ordered_for_display", .{field_name}));
                 };
             }
         }
 
         pub const longest_name = blk: {
             var len = 0;
-            for (@typeInfo(Arch).@"enum".fields) |field| {
-                if (field.name.len > len) len = field.name.len;
+            for (@typeInfo(Arch).@"enum".field_names) |field_name| {
+                if (field_name.len > len) len = field_name.len;
             }
             break :blk len;
         };
@@ -1106,14 +1107,14 @@ pub const supported_targets = struct {
         // Enforce two things:
         // 1. Arch enum field names are all lowercase (necessary for how fromStringIgnoreCase is implemented)
         // 2. All enum fields in Arch have an associated RVA relocation type when converted to a coff.IMAGE.FILE.MACHINE
-        for (@typeInfo(Arch).@"enum".fields) |enum_field| {
-            const all_lower = all_lower: for (enum_field.name) |c| {
+        for (@typeInfo(Arch).@"enum".field_names) |field_name| {
+            const all_lower = all_lower: for (field_name) |c| {
                 if (std.ascii.isUpper(c)) break :all_lower false;
             } else break :all_lower true;
-            if (!all_lower) @compileError(std.fmt.comptimePrint("Arch field is not all lowercase: {s}", .{enum_field.name}));
-            const coff_machine = @field(Arch, enum_field.name).toCoffMachineType();
+            if (!all_lower) @compileError(std.fmt.comptimePrint("Arch field is not all lowercase: {s}", .{field_name}));
+            const coff_machine = @field(Arch, field_name).toCoffMachineType();
             _ = rvaRelocationTypeIndicator(coff_machine) orelse {
-                @compileError(std.fmt.comptimePrint("No RVA relocation for Arch: {s}", .{enum_field.name}));
+                @compileError(std.fmt.comptimePrint("No RVA relocation for Arch: {s}", .{field_name}));
             };
         }
     }