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

package/std/crypto/phc_encoding.zig

@@ -115,22 +115,23 @@ pub fn deserialize(comptime HashResult: type, str: []const u8) Error!HashResult
         while (it_params.next()) |params| {
             const param = kvSplit(params) catch break;
             var found = false;
-            inline for (comptime meta.fields(HashResult)) |p| {
-                if (mem.eql(u8, p.name, param.key)) {
-                    switch (@typeInfo(p.type)) {
-                        .int => @field(out, p.name) = fmt.parseUnsigned(
-                            p.type,
+            const info = @typeInfo(HashResult).@"struct";
+            inline for (info.field_names, info.field_types) |p_name, p_type| {
+                if (mem.eql(u8, p_name, param.key)) {
+                    switch (@typeInfo(p_type)) {
+                        .int => @field(out, p_name) = fmt.parseUnsigned(
+                            p_type,
                             param.value,
                             10,
                         ) catch return Error.InvalidEncoding,
                         .pointer => |ptr| {
-                            if (!ptr.is_const) @compileError("Value slice must be constant");
-                            @field(out, p.name) = param.value;
+                            if (!ptr.attrs.@"const") @compileError("Value slice must be constant");
+                            @field(out, p_name) = param.value;
                         },
-                        .@"struct" => try @field(out, p.name).fromB64(param.value),
+                        .@"struct" => try @field(out, p_name).fromB64(param.value),
                         else => std.debug.panic(
                             "Value for [{s}] must be an integer, a constant slice or a BinValue",
-                            .{p.name},
+                            .{p_name},
                         ),
                     }
                     set_fields += 1;
@@ -167,8 +168,9 @@ pub fn deserialize(comptime HashResult: type, str: []const u8) Error!HashResult
     // Check that all the required fields have been set, excluding optional values and parameters
     // with default values
     var expected_fields: usize = 0;
-    inline for (comptime meta.fields(HashResult)) |p| {
-        if (@typeInfo(p.type) != .optional and p.default_value_ptr == null) {
+    const info = @typeInfo(HashResult).@"struct";
+    inline for (info.field_types, info.field_attrs) |p_type, p_attrs| {
+        if (@typeInfo(p_type) != .optional and p_attrs.default_value_ptr == null) {
             expected_fields += 1;
         }
     }
@@ -228,21 +230,22 @@ fn serializeTo(params: anytype, out: *std.Io.Writer) !void {
     }
 
     var has_params = false;
-    inline for (comptime meta.fields(HashResult)) |p| {
-        if (comptime !(mem.eql(u8, p.name, "alg_id") or
-            mem.eql(u8, p.name, "alg_version") or
-            mem.eql(u8, p.name, "hash") or
-            mem.eql(u8, p.name, "salt")))
+    const info = @typeInfo(HashResult).@"struct";
+    inline for (info.field_names, info.field_types) |p_name, p_type| {
+        if (comptime !(mem.eql(u8, p_name, "alg_id") or
+            mem.eql(u8, p_name, "alg_version") or
+            mem.eql(u8, p_name, "hash") or
+            mem.eql(u8, p_name, "salt")))
         {
-            const value = @field(params, p.name);
+            const value = @field(params, p_name);
             try out.writeAll(if (has_params) params_delimiter else fields_delimiter);
-            if (@typeInfo(p.type) == .@"struct") {
+            if (@typeInfo(p_type) == .@"struct") {
                 var buf: [@TypeOf(value).max_encoded_length]u8 = undefined;
-                try out.print("{s}{s}{s}", .{ p.name, kv_delimiter, try value.toB64(&buf) });
+                try out.print("{s}{s}{s}", .{ p_name, kv_delimiter, try value.toB64(&buf) });
             } else {
                 try out.print(
                     if (@typeInfo(@TypeOf(value)) == .pointer) "{s}{s}{s}" else "{s}{s}{}",
-                    .{ p.name, kv_delimiter, value },
+                    .{ p_name, kv_delimiter, value },
                 );
             }
             has_params = true;

package/std/crypto/timing_safe.zig

@@ -135,7 +135,7 @@ fn markSecret(ptr: anytype, comptime action: enum { classify, declassify }) void
     const t = @typeInfo(@TypeOf(ptr));
     if (t != .pointer) @compileError("Pointer expected - Found: " ++ @typeName(@TypeOf(ptr)));
     const p = t.pointer;
-    if (p.is_allowzero) @compileError("A nullable pointer is always assumed to leak information via side channels");
+    if (p.attrs.@"allowzero") @compileError("A nullable pointer is always assumed to leak information via side channels");
     const child = @typeInfo(p.child);
 
     switch (child) {

package/std/crypto/tls/Client.zig

@@ -1338,11 +1338,11 @@ fn failRead(c: *Client, err: ReadError) error{ReadFailed} {
 }
 
 fn logSecrets(w: *Writer, context: anytype, secrets: anytype) void {
-    inline for (@typeInfo(@TypeOf(secrets)).@"struct".fields) |field| w.print("{s}" ++
-        (if (@hasField(@TypeOf(context), "counter")) "_{d}" else "") ++ " {x} {x}\n", .{field.name} ++
+    inline for (@typeInfo(@TypeOf(secrets)).@"struct".field_names) |field_name| w.print("{s}" ++
+        (if (@hasField(@TypeOf(context), "counter")) "_{d}" else "") ++ " {x} {x}\n", .{field_name} ++
         (if (@hasField(@TypeOf(context), "counter")) .{context.counter} else .{}) ++ .{
         context.client_random,
-        @field(secrets, field.name),
+        @field(secrets, field_name),
     }) catch {};
 }
 

package/std/crypto/tls.zig

@@ -710,7 +710,7 @@ pub const Decoder = struct {
                 else => @compileError("unsupported int type: " ++ @typeName(T)),
             },
             .@"enum" => |info| {
-                if (info.is_exhaustive) @compileError("exhaustive enum cannot be used");
+                if (info.mode == .exhaustive) @compileError("exhaustive enum cannot be used");
                 return @enumFromInt(d.decode(info.tag_type));
             },
             else => @compileError("unsupported type: " ++ @typeName(T)),

package/std/debug/Dwarf/Unwind/VirtualMachine.zig

@@ -247,10 +247,15 @@ fn evalInstructions(
                     .val_expr => |len| .{ .val_expression = try takeExprBlock(&fr, len) },
                 };
             },
-            .def_cfa => |cfa| vm.current_row.cfa = .{ .reg_off = .{
-                .register = cfa.register,
-                .offset = @intCast(cfa.offset),
-            } },
+            .def_cfa => |cfa| vm.current_row.cfa = .{
+                .reg_off = .{
+                    .register = cfa.register,
+                    // Unfortunately, LLVM emits negative CFI directives as their unsigned variants
+                    // rather than the signed variants that DWARF has for exactly that purpose, hence
+                    // `@bitCast` instead of `@intCast`.
+                    .offset = @bitCast(cfa.offset),
+                },
+            },
             .def_cfa_sf => |cfa| vm.current_row.cfa = .{ .reg_off = .{
                 .register = cfa.register,
                 .offset = cfa.offset_sf * cie.data_alignment_factor,
@@ -272,7 +277,8 @@ fn evalInstructions(
             },
             .def_cfa_offset => |offset| switch (vm.current_row.cfa) {
                 .none, .expression => return error.InvalidOperation,
-                .reg_off => |*ro| ro.offset = @intCast(offset),
+                // See the comment for `def_cfa` above.
+                .reg_off => |*ro| ro.offset = @bitCast(offset),
             },
             .def_cfa_offset_sf => |offset_sf| switch (vm.current_row.cfa) {
                 .none, .expression => return error.InvalidOperation,

package/std/debug/ElfFile.zig

@@ -219,9 +219,10 @@ pub fn load(
                 break :dwarf null; // debug info not present
             }
             var sections: Dwarf.SectionArray = @splat(null);
-            inline for (@typeInfo(Dwarf.Section.Id).@"enum".fields) |f| {
-                if (result.sections.get(@field(Section.Id, f.name))) |s| {
-                    sections[f.value] = .{ .data = s.bytes, .owned = false };
+            const info = @typeInfo(Dwarf.Section.Id).@"enum";
+            inline for (info.field_names, info.field_values) |f_name, f_value| {
+                if (result.sections.get(@field(Section.Id, f_name))) |s| {
+                    sections[f_value] = .{ .data = s.bytes, .owned = false };
                 }
             }
             break :dwarf .{ .sections = sections };
@@ -408,8 +409,8 @@ fn loadSeparateDebugFile(
         return null;
     }
 
-    inline for (@typeInfo(Dwarf.Section.Id).@"enum".fields) |f| {
-        const id = @field(Section.Id, f.name);
+    inline for (@typeInfo(Dwarf.Section.Id).@"enum".field_names) |f_name| {
+        const id = @field(Section.Id, f_name);
         if (main_loaded.sections.get(id) == null) {
             main_loaded.sections.set(id, result.sections.get(id));
         }
@@ -498,9 +499,12 @@ fn loadInner(
         if (shdr.sh_name > shstrtab.len) return error.TruncatedElfFile;
         const name = std.mem.sliceTo(shstrtab[@intCast(shdr.sh_name)..], 0);
 
-        const section_id: Section.Id = inline for (@typeInfo(Section.Id).@"enum".fields) |s| {
-            if (std.mem.eql(u8, "." ++ s.name, name)) {
-                break @enumFromInt(s.value);
+        const section_id: Section.Id = inline for (
+            @typeInfo(Section.Id).@"enum".field_names,
+            @typeInfo(Section.Id).@"enum".field_values,
+        ) |s_name, s_value| {
+            if (std.mem.eql(u8, "." ++ s_name, name)) {
+                break @enumFromInt(s_value);
             }
         } else continue;
 

package/std/debug/MachOFile.zig

@@ -504,8 +504,8 @@ fn loadOFile(gpa: Allocator, io: Io, o_file_name: []const u8) !OFile {
 
         if (!std.mem.eql(u8, "__DWARF", sect.segName())) continue;
 
-        const section_index: usize = inline for (@typeInfo(Dwarf.Section.Id).@"enum".fields, 0..) |section, i| {
-            if (mem.eql(u8, "__" ++ section.name, sect.sectName())) break i;
+        const section_index: usize = inline for (@typeInfo(Dwarf.Section.Id).@"enum".field_names, 0..) |section_name, i| {
+            if (mem.eql(u8, "__" ++ section_name, sect.sectName())) break i;
         } else continue;
 
         if (mapped_ofile.len < sect.offset + sect.size) return error.InvalidMachO;

package/std/debug/SelfInfo/MachO.zig

@@ -408,8 +408,8 @@ fn unwindFrameInner(si: *SelfInfo, io: Io, context: *UnwindContext) !usize {
                 const ip_ptr = fp + @sizeOf(usize);
 
                 var reg_addr = fp - @sizeOf(usize);
-                inline for (@typeInfo(@TypeOf(frame.x_reg_pairs)).@"struct".fields, 0..) |field, i| {
-                    if (@field(frame.x_reg_pairs, field.name) != 0) {
+                inline for (@typeInfo(@TypeOf(frame.x_reg_pairs)).@"struct".field_names, 0..) |field_name, i| {
+                    if (@field(frame.x_reg_pairs, field_name) != 0) {
                         (try dwarfRegNative(&context.cpu_state, 19 + i)).* = @as(*const usize, @ptrFromInt(reg_addr)).*;
                         reg_addr += @sizeOf(usize);
                         (try dwarfRegNative(&context.cpu_state, 20 + i)).* = @as(*const usize, @ptrFromInt(reg_addr)).*;

package/std/debug/SelfInfo/Windows.zig

@@ -513,8 +513,8 @@ const Module = struct {
             if (coff_obj.getSectionByName(".debug_info") == null) break :dwarf null;
 
             var sections: Dwarf.SectionArray = undefined;
-            inline for (@typeInfo(Dwarf.Section.Id).@"enum".fields, 0..) |section, i| {
-                sections[i] = if (coff_obj.getSectionByName("." ++ section.name)) |section_header| .{
+            inline for (@typeInfo(Dwarf.Section.Id).@"enum".field_names, 0..) |section_name, i| {
+                sections[i] = if (coff_obj.getSectionByName("." ++ section_name)) |section_header| .{
                     .data = try coff_obj.getSectionDataAlloc(section_header, arena),
                     .owned = false,
                 } else null;

package/std/elf.zig

@@ -484,7 +484,7 @@ pub const PT = enum(Word) {
     _,
 
     /// Number of defined types
-    pub const NUM = @typeInfo(PT).@"enum".fields.len;
+    pub const NUM = @typeInfo(PT).@"enum".field_names.len;
 
     /// Start of OS-specific
     pub const LOOS: PT = @enumFromInt(0x60000000);
@@ -552,7 +552,7 @@ pub const SHT = enum(Word) {
     _,
 
     /// Number of defined types
-    pub const NUM = @typeInfo(SHT).@"enum".fields.len;
+    pub const NUM = @typeInfo(SHT).@"enum".field_names.len;
 
     /// Start of OS-specific
     pub const LOOS: SHT = @enumFromInt(0x60000000);
@@ -595,7 +595,7 @@ pub const STB = enum(u4) {
     _,
 
     /// Number of defined types
-    pub const NUM = @typeInfo(STB).@"enum".fields.len;
+    pub const NUM = @typeInfo(STB).@"enum".field_names.len;
 
     /// Start of OS-specific
     pub const LOOS: STB = @enumFromInt(10);
@@ -631,7 +631,7 @@ pub const STT = enum(u4) {
     _,
 
     /// Number of defined types
-    pub const NUM = @typeInfo(STT).@"enum".fields.len;
+    pub const NUM = @typeInfo(STT).@"enum".field_names.len;
 
     /// Start of OS-specific
     pub const LOOS: STT = @enumFromInt(10);
@@ -815,7 +815,7 @@ pub const Header = struct {
 
     pub fn init(hdr: anytype, endian: Endian) Header {
         // Converting integers to exhaustive enums using `@enumFromInt` could cause a panic.
-        comptime assert(!@typeInfo(OSABI).@"enum".is_exhaustive);
+        comptime assert(@typeInfo(OSABI).@"enum".mode == .nonexhaustive);
         return .{
             .is_64 = switch (@TypeOf(hdr)) {
                 Elf32_Ehdr => false,
@@ -1642,7 +1642,7 @@ pub const CLASS = enum(u8) {
     @"64" = 2,
     _,
 
-    pub const NUM = @typeInfo(CLASS).@"enum".fields.len;
+    pub const NUM = @typeInfo(CLASS).@"enum".field_names.len;
 
     pub fn ElfN(comptime class: CLASS) type {
         return switch (class) {
@@ -1667,7 +1667,7 @@ pub const DATA = enum(u8) {
     @"2MSB" = 2,
     _,
 
-    pub const NUM = @typeInfo(DATA).@"enum".fields.len;
+    pub const NUM = @typeInfo(DATA).@"enum".field_names.len;
 };
 
 pub const OSABI = enum(u8) {

package/std/enums.zig

@@ -3,14 +3,13 @@
 const std = @import("std");
 const assert = std.debug.assert;
 const testing = std.testing;
-const EnumField = std.builtin.Type.EnumField;
 
 /// Increment this value when adding APIs that add single backwards branches.
 const eval_branch_quota_cushion = 10;
 
 pub fn fromInt(comptime E: type, integer: anytype) ?E {
     const enum_info = @typeInfo(E).@"enum";
-    if (!enum_info.is_exhaustive) {
+    if (enum_info.mode == .nonexhaustive) {
         if (std.math.cast(enum_info.tag_type, integer)) |tag| {
             return @enumFromInt(tag);
         }
@@ -32,20 +31,19 @@ pub fn fromInt(comptime E: type, integer: anytype) ?E {
 /// the first name is used.  Each field is of type Data and has the provided
 /// default, which may be undefined.
 pub fn EnumFieldStruct(comptime E: type, comptime Data: type, comptime field_default: ?Data) type {
-    @setEvalBranchQuota(@typeInfo(E).@"enum".fields.len + eval_branch_quota_cushion);
+    @setEvalBranchQuota(@typeInfo(E).@"enum".field_names.len + eval_branch_quota_cushion);
     const default_ptr: ?*const anyopaque = if (field_default) |d| @ptrCast(&d) else null;
     return @Struct(.auto, null, std.meta.fieldNames(E), &@splat(Data), &@splat(.{ .default_value_ptr = default_ptr }));
 }
 
-/// Looks up the supplied fields in the given enum type.
-/// Uses only the field names, field values are ignored.
+/// Looks up the supplied field values in the given enum type.
 /// The result array is in the same order as the input.
-pub inline fn valuesFromFields(comptime E: type, comptime fields: []const EnumField) []const E {
+pub inline fn valuesFromFields(comptime E: type, comptime field_values: []const comptime_int) []const E {
     comptime {
-        @setEvalBranchQuota(@typeInfo(E).@"enum".fields.len + eval_branch_quota_cushion);
-        var result: [fields.len]E = undefined;
-        for (&result, fields) |*r, f| {
-            r.* = @enumFromInt(f.value);
+        @setEvalBranchQuota(@typeInfo(E).@"enum".field_names.len + eval_branch_quota_cushion);
+        var result: [field_values.len]E = undefined;
+        for (&result, field_values) |*r, f_value| {
+            r.* = @enumFromInt(f_value);
         }
         const final = result;
         return &final;
@@ -55,17 +53,18 @@ pub inline fn valuesFromFields(comptime E: type, comptime fields: []const EnumFi
 /// Returns the set of all named values in the given enum, in
 /// declaration order.
 pub inline fn values(comptime E: type) []const E {
-    return comptime valuesFromFields(E, @typeInfo(E).@"enum".fields);
+    return comptime valuesFromFields(E, @typeInfo(E).@"enum".field_values);
 }
 
 /// A safe alternative to @tagName() for non-exhaustive enums that doesn't
 /// panic when `e` has no tagged value.
 /// Returns the tag name for `e` or null if no tag exists.
 pub fn tagName(comptime E: type, e: E) ?[:0]const u8 {
-    const fields = @typeInfo(E).@"enum".fields;
-    @setEvalBranchQuota(fields.len);
-    return inline for (fields) |f| {
-        if (@intFromEnum(e) == f.value) break f.name;
+    const field_names = @typeInfo(E).@"enum".field_names;
+    const field_values = @typeInfo(E).@"enum".field_values;
+    @setEvalBranchQuota(field_names.len);
+    return inline for (field_names, field_values) |f_name, f_value| {
+        if (@intFromEnum(e) == f_value) break f_name;
     } else null;
 }
 
@@ -88,20 +87,20 @@ test tagName {
 pub fn directEnumArrayLen(comptime E: type, comptime max_unused_slots: comptime_int) comptime_int {
     var max_value: comptime_int = -1;
     const max_usize: comptime_int = ~@as(usize, 0);
-    const fields = @typeInfo(E).@"enum".fields;
-    for (fields) |f| {
-        if (f.value < 0) {
-            @compileError("Cannot create a direct enum array for " ++ @typeName(E) ++ ", field ." ++ f.name ++ " has a negative value.");
-        }
-        if (f.value > max_value) {
-            if (f.value > max_usize) {
-                @compileError("Cannot create a direct enum array for " ++ @typeName(E) ++ ", field ." ++ f.name ++ " is larger than the max value of usize.");
+    const info = @typeInfo(E).@"enum";
+    for (info.field_names, info.field_values) |f_name, f_value| {
+        if (f_value < 0) {
+            @compileError("Cannot create a direct enum array for " ++ @typeName(E) ++ ", field ." ++ f_name ++ " has a negative value.");
+        }
+        if (f_value > max_value) {
+            if (f_value > max_usize) {
+                @compileError("Cannot create a direct enum array for " ++ @typeName(E) ++ ", field ." ++ f_name ++ " is larger than the max value of usize.");
             }
-            max_value = f.value;
+            max_value = f_value;
         }
     }
 
-    const unused_slots = max_value + 1 - fields.len;
+    const unused_slots = max_value + 1 - info.field_names.len;
     if (unused_slots > max_unused_slots) {
         const unused_str = std.fmt.comptimePrint("{d}", .{unused_slots});
         const allowed_str = std.fmt.comptimePrint("{d}", .{max_unused_slots});
@@ -167,10 +166,10 @@ pub fn directEnumArrayDefault(
 ) [directEnumArrayLen(E, max_unused_slots)]Data {
     const len = comptime directEnumArrayLen(E, max_unused_slots);
     var result: [len]Data = @splat(default orelse undefined);
-    inline for (@typeInfo(@TypeOf(init_values)).@"struct".fields) |f| {
-        const enum_value = @field(E, f.name);
+    inline for (@typeInfo(@TypeOf(init_values)).@"struct".field_names) |f_name| {
+        const enum_value = @field(E, f_name);
         const index = @as(usize, @intCast(@intFromEnum(enum_value)));
-        result[index] = @field(init_values, f.name);
+        result[index] = @field(init_values, f_name);
     }
     return result;
 }
@@ -256,9 +255,9 @@ pub fn EnumSet(comptime E: type) type {
 
         /// Initializes the set using a struct of bools
         pub fn init(init_values: EnumFieldStruct(E, bool, false)) Self {
-            @setEvalBranchQuota(2 * @typeInfo(E).@"enum".fields.len);
+            @setEvalBranchQuota(2 * @typeInfo(E).@"enum".field_names.len);
             var result: Self = .{};
-            if (@typeInfo(E).@"enum".is_exhaustive) {
+            if (@typeInfo(E).@"enum".mode == .exhaustive) {
                 inline for (0..Self.len) |i| {
                     const key = comptime Indexer.keyForIndex(i);
                     const tag = @tagName(key);
@@ -267,9 +266,9 @@ pub fn EnumSet(comptime E: type) type {
                     }
                 }
             } else {
-                inline for (std.meta.fields(E)) |field| {
-                    const key = @field(E, field.name);
-                    if (@field(init_values, field.name)) {
+                inline for (@typeInfo(E).@"enum".field_names) |field_name| {
+                    const key = @field(E, field_name);
+                    if (@field(init_values, field_name)) {
                         const i = comptime Indexer.indexOf(key);
                         result.bits.set(i);
                     }
@@ -443,9 +442,9 @@ pub fn EnumMap(comptime E: type, comptime V: type) type {
 
         /// Initializes the map using a sparse struct of optionals
         pub fn init(init_values: EnumFieldStruct(E, ?Value, @as(?Value, null))) Self {
-            @setEvalBranchQuota(2 * @typeInfo(E).@"enum".fields.len);
+            @setEvalBranchQuota(2 * @typeInfo(E).@"enum".field_names.len);
             var result: Self = .{};
-            if (@typeInfo(E).@"enum".is_exhaustive) {
+            if (@typeInfo(E).@"enum".mode == .exhaustive) {
                 inline for (0..Self.len) |i| {
                     const key = comptime Indexer.keyForIndex(i);
                     const tag = @tagName(key);
@@ -455,9 +454,9 @@ pub fn EnumMap(comptime E: type, comptime V: type) type {
                     }
                 }
             } else {
-                inline for (std.meta.fields(E)) |field| {
-                    const key = @field(E, field.name);
-                    if (@field(init_values, field.name)) |*v| {
+                inline for (std.meta.fieldNames(E)) |field_name| {
+                    const key = @field(E, field_name);
+                    if (@field(init_values, field_name)) |*v| {
                         const i = comptime Indexer.indexOf(key);
                         result.bits.set(i);
                         result.values[i] = v.*;
@@ -487,7 +486,7 @@ pub fn EnumMap(comptime E: type, comptime V: type) type {
         /// Initializes a full mapping with a provided default.
         /// Consider using EnumArray instead if the map will remain full.
         pub fn initFullWithDefault(comptime default: ?Value, init_values: EnumFieldStruct(E, Value, default)) Self {
-            @setEvalBranchQuota(2 * @typeInfo(E).@"enum".fields.len);
+            @setEvalBranchQuota(2 * @typeInfo(E).@"enum".field_names.len);
             var result: Self = .{
                 .bits = .full,
                 .values = undefined,
@@ -673,11 +672,12 @@ pub fn BoundedEnumMultiset(comptime E: type, comptime CountSize: type) type {
 
         /// Initializes the multiset using a struct of counts.
         pub fn init(init_counts: EnumFieldStruct(E, CountSize, 0)) Self {
-            @setEvalBranchQuota(2 * @typeInfo(E).@"enum".fields.len);
+            @setEvalBranchQuota(2 * @typeInfo(E).@"enum".field_names.len);
             var self = initWithCount(0);
-            inline for (@typeInfo(E).@"enum".fields) |field| {
-                const c = @field(init_counts, field.name);
-                const key = @as(E, @enumFromInt(field.value));
+            const info = @typeInfo(E).@"enum";
+            inline for (info.field_names, info.field_values) |field_name, field_value| {
+                const c = @field(init_counts, field_name);
+                const key: E = @enumFromInt(field_value);
                 self.counts.set(key, c);
             }
             return self;
@@ -745,16 +745,16 @@ pub fn BoundedEnumMultiset(comptime E: type, comptime CountSize: type) type {
         /// Increases the all key counts by given multiset. Caller
         /// asserts operation will not overflow any key.
         pub fn addSetAssertSafe(self: *Self, other: Self) void {
-            inline for (@typeInfo(E).@"enum".fields) |field| {
-                const key = @as(E, @enumFromInt(field.value));
+            inline for (@typeInfo(E).@"enum".field_values) |field_value| {
+                const key = @as(E, @enumFromInt(field_value));
                 self.addAssertSafe(key, other.getCount(key));
             }
         }
 
         /// Increases the all key counts by given multiset.
         pub fn addSet(self: *Self, other: Self) error{Overflow}!void {
-            inline for (@typeInfo(E).@"enum".fields) |field| {
-                const key = @as(E, @enumFromInt(field.value));
+            inline for (@typeInfo(E).@"enum".field_values) |field_value| {
+                const key = @as(E, @enumFromInt(field_value));
                 try self.add(key, other.getCount(key));
             }
         }
@@ -763,8 +763,8 @@ pub fn BoundedEnumMultiset(comptime E: type, comptime CountSize: type) type {
         /// the given multiset has more key counts than this,
         /// then that key will have a key count of zero.
         pub fn removeSet(self: *Self, other: Self) void {
-            inline for (@typeInfo(E).@"enum".fields) |field| {
-                const key = @as(E, @enumFromInt(field.value));
+            inline for (@typeInfo(E).@"enum".field_values) |field_value| {
+                const key = @as(E, @enumFromInt(field_value));
                 self.remove(key, other.getCount(key));
             }
         }
@@ -772,8 +772,8 @@ pub fn BoundedEnumMultiset(comptime E: type, comptime CountSize: type) type {
         /// Returns true iff all key counts are the same as
         /// given multiset.
         pub fn eql(self: Self, other: Self) bool {
-            inline for (@typeInfo(E).@"enum".fields) |field| {
-                const key = @as(E, @enumFromInt(field.value));
+            inline for (@typeInfo(E).@"enum".field_values) |field_value| {
+                const key = @as(E, @enumFromInt(field_value));
                 if (self.getCount(key) != other.getCount(key)) {
                     return false;
                 }
@@ -784,8 +784,8 @@ pub fn BoundedEnumMultiset(comptime E: type, comptime CountSize: type) type {
         /// Returns true iff all key counts less than or
         /// equal to the given multiset.
         pub fn subsetOf(self: Self, other: Self) bool {
-            inline for (@typeInfo(E).@"enum".fields) |field| {
-                const key = @as(E, @enumFromInt(field.value));
+            inline for (@typeInfo(E).@"enum".field_values) |field_value| {
+                const key = @as(E, @enumFromInt(field_value));
                 if (self.getCount(key) > other.getCount(key)) {
                     return false;
                 }
@@ -796,8 +796,8 @@ pub fn BoundedEnumMultiset(comptime E: type, comptime CountSize: type) type {
         /// Returns true iff all key counts greater than or
         /// equal to the given multiset.
         pub fn supersetOf(self: Self, other: Self) bool {
-            inline for (@typeInfo(E).@"enum".fields) |field| {
-                const key = @as(E, @enumFromInt(field.value));
+            inline for (@typeInfo(E).@"enum".field_values) |field_value| {
+                const key = @as(E, @enumFromInt(field_value));
                 if (self.getCount(key) < other.getCount(key)) {
                     return false;
                 }
@@ -1075,7 +1075,7 @@ pub fn EnumArray(comptime E: type, comptime V: type) type {
 
         /// Initializes values in the enum array, with the specified default.
         pub fn initDefault(comptime default: ?Value, init_values: EnumFieldStruct(E, Value, default)) Self {
-            @setEvalBranchQuota(2 * @typeInfo(E).@"enum".fields.len);
+            @setEvalBranchQuota(2 * @typeInfo(E).@"enum".field_names.len);
             var result: Self = .{ .values = undefined };
             inline for (0..Self.len) |i| {
                 const key = comptime Indexer.keyForIndex(i);
@@ -1264,10 +1264,10 @@ test "EnumSet non-exhaustive" {
 
 pub fn EnumIndexer(comptime E: type) type {
     // n log n for `std.mem.sortUnstable` call below.
-    const fields_len = @typeInfo(E).@"enum".fields.len;
+    const fields_len = @typeInfo(E).@"enum".field_names.len;
     @setEvalBranchQuota(3 * fields_len * std.math.log2(@max(fields_len, 1)) + eval_branch_quota_cushion);
 
-    if (!@typeInfo(E).@"enum".is_exhaustive) {
+    if (@typeInfo(E).@"enum".mode == .nonexhaustive) {
         const BackingInt = @typeInfo(E).@"enum".tag_type;
         if (@bitSizeOf(BackingInt) > @bitSizeOf(usize))
             @compileError("Cannot create an enum indexer for a given non-exhaustive enum, tag_type is larger than usize.");
@@ -1315,18 +1315,17 @@ pub fn EnumIndexer(comptime E: type) type {
         };
     }
 
-    var fields: [fields_len]EnumField = @typeInfo(E).@"enum".fields[0..].*;
+    var field_values = @typeInfo(E).@"enum".field_values[0..fields_len].*;
 
-    std.mem.sortUnstable(EnumField, &fields, {}, struct {
-        fn lessThan(ctx: void, lhs: EnumField, rhs: EnumField) bool {
-            ctx;
-            return lhs.value < rhs.value;
+    std.mem.sortUnstable(comptime_int, &field_values, {}, struct {
+        fn lessThan(_: void, a: comptime_int, b: comptime_int) bool {
+            return a < b;
         }
     }.lessThan);
 
-    const min = fields[0].value;
-    const max = fields[fields_len - 1].value;
-    if (max - min == fields.len - 1) {
+    const min = field_values[0];
+    const max = field_values[fields_len - 1];
+    if (max - min == field_values.len - 1) {
         return struct {
             pub const Key = E;
             pub const count: comptime_int = fields_len;
@@ -1343,7 +1342,7 @@ pub fn EnumIndexer(comptime E: type) type {
         };
     }
 
-    const keys = valuesFromFields(E, &fields);
+    const keys = valuesFromFields(E, &field_values);
 
     return struct {
         pub const Key = E;

package/std/gpu.zig

@@ -58,7 +58,7 @@ pub const ExecutionMode = union(Tag) {
 
 /// Declare the mode entry point executes in.
 pub fn executionMode(comptime entry_point: anytype, comptime mode: ExecutionMode) void {
-    const cc = @typeInfo(@TypeOf(entry_point)).@"fn".calling_convention;
+    const cc = @typeInfo(@TypeOf(entry_point)).@"fn".attrs.@"callconv";
     switch (mode) {
         .origin_upper_left,
         .origin_lower_left,

package/std/hash/auto_hash.zig

@@ -127,10 +127,10 @@ pub fn hash(hasher: anytype, key: anytype, comptime strat: HashStrategy) void {
         },
 
         .@"struct" => |info| {
-            inline for (info.fields) |field| {
+            inline for (info.field_names) |field_name| {
                 // We reuse the hash of the previous field as the seed for the
                 // next one so that they're dependant.
-                hash(hasher, @field(key, field.name), strat);
+                hash(hasher, @field(key, field_name), strat);
             }
         },
 
@@ -138,10 +138,10 @@ pub fn hash(hasher: anytype, key: anytype, comptime strat: HashStrategy) void {
             if (info.tag_type) |tag_type| {
                 const tag = std.meta.activeTag(key);
                 hash(hasher, tag, strat);
-                inline for (info.fields) |field| {
-                    if (@field(tag_type, field.name) == tag) {
-                        if (field.type != void) {
-                            hash(hasher, @field(key, field.name), strat);
+                inline for (info.field_names, info.field_types) |field_name, field_type| {
+                    if (@field(tag_type, field_name) == tag) {
+                        if (field_type != void) {
+                            hash(hasher, @field(key, field_name), strat);
                         }
                         break :blk;
                     }
@@ -165,8 +165,8 @@ inline fn typeContainsSlice(comptime K: type) bool {
         .pointer => |info| info.size == .slice,
 
         inline .@"struct", .@"union" => |info| {
-            inline for (info.fields) |field| {
-                if (typeContainsSlice(field.type)) {
+            inline for (info.field_types) |field_type| {
+                if (typeContainsSlice(field_type)) {
                     return true;
                 }
             }