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

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;
                 }
             }

package/std/hash/verify.zig

@@ -2,8 +2,8 @@ const std = @import("std");
 
 fn hashMaybeSeed(comptime hash_fn: anytype, seed: anytype, buf: []const u8) @typeInfo(@TypeOf(hash_fn)).@"fn".return_type.? {
     const HashFn = @typeInfo(@TypeOf(hash_fn)).@"fn";
-    if (HashFn.params.len > 1) {
-        if (@typeInfo(HashFn.params[0].type.?) == .int) {
+    if (HashFn.param_types.len > 1) {
+        if (@typeInfo(HashFn.param_types[0].?) == .int) {
             return hash_fn(@intCast(seed), buf);
         } else {
             return hash_fn(buf, @intCast(seed));
@@ -15,7 +15,7 @@ fn hashMaybeSeed(comptime hash_fn: anytype, seed: anytype, buf: []const u8) @typ
 
 fn initMaybeSeed(comptime Hash: anytype, seed: anytype) Hash {
     const HashFn = @typeInfo(@TypeOf(Hash.init)).@"fn";
-    if (HashFn.params.len == 1) {
+    if (HashFn.param_types.len == 1) {
         return Hash.init(@intCast(seed));
     } else {
         return Hash.init();

package/std/http/Client.zig

@@ -823,8 +823,8 @@ pub const Request = struct {
     /// Externally-owned; must outlive the Request.
     privileged_headers: []const http.Header,
 
-    pub const default_accept_encoding: [@typeInfo(http.ContentEncoding).@"enum".fields.len]bool = b: {
-        var result: [@typeInfo(http.ContentEncoding).@"enum".fields.len]bool = @splat(false);
+    pub const default_accept_encoding: [@typeInfo(http.ContentEncoding).@"enum".field_names.len]bool = b: {
+        var result: [@typeInfo(http.ContentEncoding).@"enum".field_names.len]bool = @splat(false);
         result[@intFromEnum(http.ContentEncoding.gzip)] = true;
         result[@intFromEnum(http.ContentEncoding.deflate)] = true;
         result[@intFromEnum(http.ContentEncoding.identity)] = true;

package/std/json/Stringify.zig

@@ -401,9 +401,9 @@ pub fn write(self: *Stringify, v: anytype) Error!void {
                 return v.jsonStringify(self);
             }
 
-            if (!enum_info.is_exhaustive) {
-                inline for (enum_info.fields) |field| {
-                    if (v == @field(T, field.name)) {
+            if (enum_info.mode == .nonexhaustive) {
+                inline for (enum_info.field_names) |field_name| {
+                    if (v == @field(T, field_name)) {
                         break;
                     }
                 } else {
@@ -424,15 +424,15 @@ pub fn write(self: *Stringify, v: anytype) Error!void {
             const info = @typeInfo(T).@"union";
             if (info.tag_type) |UnionTagType| {
                 try self.beginObject();
-                inline for (info.fields) |u_field| {
-                    if (v == @field(UnionTagType, u_field.name)) {
-                        try self.objectField(u_field.name);
-                        if (u_field.type == void) {
+                inline for (info.field_names, info.field_types) |u_field_name, u_field_type| {
+                    if (v == @field(UnionTagType, u_field_name)) {
+                        try self.objectField(u_field_name);
+                        if (u_field_type == void) {
                             // void v is {}
                             try self.beginObject();
                             try self.endObject();
                         } else {
-                            try self.write(@field(v, u_field.name));
+                            try self.write(@field(v, u_field_name));
                         }
                         break;
                     }
@@ -455,16 +455,16 @@ pub fn write(self: *Stringify, v: anytype) Error!void {
             } else {
                 try self.beginObject();
             }
-            inline for (S.fields) |Field| {
+            inline for (S.field_names, S.field_types) |field_name, field_type| {
                 // don't include void fields
-                if (Field.type == void) continue;
+                if (field_type == void) continue;
 
                 var emit_field = true;
 
                 // don't include optional fields that are null when emit_null_optional_fields is set to false
-                if (@typeInfo(Field.type) == .optional) {
+                if (@typeInfo(field_type) == .optional) {
                     if (self.options.emit_null_optional_fields == false) {
-                        if (@field(v, Field.name) == null) {
+                        if (@field(v, field_name) == null) {
                             emit_field = false;
                         }
                     }
@@ -472,9 +472,9 @@ pub fn write(self: *Stringify, v: anytype) Error!void {
 
                 if (emit_field) {
                     if (!S.is_tuple) {
-                        try self.objectField(Field.name);
+                        try self.objectField(field_name);
                     }
-                    try self.write(@field(v, Field.name));
+                    try self.write(@field(v, field_name));
                 }
             }
             if (S.is_tuple) {

package/std/json/static.zig

@@ -286,20 +286,20 @@ pub fn innerParse(
                 },
             };
 
-            inline for (unionInfo.fields) |u_field| {
-                if (std.mem.eql(u8, u_field.name, field_name)) {
+            inline for (unionInfo.field_names, unionInfo.field_types) |u_field_name, u_field_type| {
+                if (std.mem.eql(u8, u_field_name, field_name)) {
                     // Free the name token now in case we're using an allocator that optimizes freeing the last allocated object.
                     // (Recursing into innerParse() might trigger more allocations.)
                     freeAllocated(allocator, name_token.?);
                     name_token = null;
-                    if (u_field.type == void) {
+                    if (u_field_type == void) {
                         // void isn't really a json type, but we can support void payload union tags with {} as a value.
                         if (.object_begin != try source.next()) return error.UnexpectedToken;
                         if (.object_end != try source.next()) return error.UnexpectedToken;
-                        result = @unionInit(T, u_field.name, {});
+                        result = @unionInit(T, u_field_name, {});
                     } else {
                         // Recurse.
-                        result = @unionInit(T, u_field.name, try innerParse(u_field.type, allocator, source, options));
+                        result = @unionInit(T, u_field_name, try innerParse(u_field_type, allocator, source, options));
                     }
                     break;
                 }
@@ -318,8 +318,8 @@ pub fn innerParse(
                 if (.array_begin != try source.next()) return error.UnexpectedToken;
 
                 var r: T = undefined;
-                inline for (0..structInfo.fields.len) |i| {
-                    r[i] = try innerParse(structInfo.fields[i].type, allocator, source, options);
+                inline for (structInfo.field_types, 0..) |field_type, i| {
+                    r[i] = try innerParse(field_type, allocator, source, options);
                 }
 
                 if (.array_end != try source.next()) return error.UnexpectedToken;
@@ -334,7 +334,7 @@ pub fn innerParse(
             if (.object_begin != try source.next()) return error.UnexpectedToken;
 
             var r: T = undefined;
-            var fields_seen: [structInfo.fields.len]bool = @splat(false);
+            var fields_seen: [structInfo.field_names.len]bool = @splat(false);
 
             while (true) {
                 var name_token: ?Token = try source.nextAllocMax(allocator, .alloc_if_needed, options.max_value_len.?);
@@ -348,9 +348,14 @@ pub fn innerParse(
                     },
                 };
 
-                inline for (structInfo.fields, 0..) |field, i| {
-                    if (field.is_comptime) @compileError("comptime fields are not supported: " ++ @typeName(T) ++ "." ++ field.name);
-                    if (std.mem.eql(u8, field.name, field_name)) {
+                inline for (
+                    structInfo.field_names,
+                    structInfo.field_types,
+                    structInfo.field_attrs,
+                    0..,
+                ) |f_name, f_type, f_attrs, i| {
+                    if (f_attrs.@"comptime") @compileError("comptime fields are not supported: " ++ @typeName(T) ++ "." ++ f_name);
+                    if (std.mem.eql(u8, f_name, field_name)) {
                         // Free the name token now in case we're using an allocator that optimizes freeing the last allocated object.
                         // (Recursing into innerParse() might trigger more allocations.)
                         freeAllocated(allocator, name_token.?);
@@ -360,14 +365,14 @@ pub fn innerParse(
                                 .use_first => {
                                     // Parse and ignore the redundant value.
                                     // We don't want to skip the value, because we want type checking.
-                                    _ = try innerParse(field.type, allocator, source, options);
+                                    _ = try innerParse(f_type, allocator, source, options);
                                     break;
                                 },
                                 .@"error" => return error.DuplicateField,
                                 .use_last => {},
                             }
                         }
-                        @field(r, field.name) = try innerParse(field.type, allocator, source, options);
+                        @field(r, f_name) = try innerParse(f_type, allocator, source, options);
                         fields_seen[i] = true;
                         break;
                     }
@@ -493,7 +498,7 @@ pub fn innerParse(
                                 _ = try source.allocNextIntoArrayList(&value_list, .alloc_always);
                                 return try value_list.toOwnedSliceSentinel(s);
                             }
-                            if (ptrInfo.is_const) {
+                            if (ptrInfo.attrs.@"const") {
                                 switch (try source.nextAllocMax(allocator, options.allocate.?, options.max_value_len.?)) {
                                     inline .string, .allocated_string => |slice| return slice,
                                     else => unreachable,
@@ -613,16 +618,16 @@ pub fn innerParseFromValue(
             const kv = it.next().?;
             const field_name = kv.key_ptr.*;
 
-            inline for (unionInfo.fields) |u_field| {
-                if (std.mem.eql(u8, u_field.name, field_name)) {
-                    if (u_field.type == void) {
+            inline for (unionInfo.field_names, unionInfo.field_types) |u_field_name, u_field_type| {
+                if (std.mem.eql(u8, u_field_name, field_name)) {
+                    if (u_field_type == void) {
                         // void isn't really a json type, but we can support void payload union tags with {} as a value.
                         if (kv.value_ptr.* != .object) return error.UnexpectedToken;
                         if (kv.value_ptr.*.object.count() != 0) return error.UnexpectedToken;
-                        return @unionInit(T, u_field.name, {});
+                        return @unionInit(T, u_field_name, {});
                     }
                     // Recurse.
-                    return @unionInit(T, u_field.name, try innerParseFromValue(u_field.type, allocator, kv.value_ptr.*, options));
+                    return @unionInit(T, u_field_name, try innerParseFromValue(u_field_type, allocator, kv.value_ptr.*, options));
                 }
             }
             // Didn't match anything.
@@ -632,11 +637,11 @@ pub fn innerParseFromValue(
         .@"struct" => |structInfo| {
             if (structInfo.is_tuple) {
                 if (source != .array) return error.UnexpectedToken;
-                if (source.array.items.len != structInfo.fields.len) return error.UnexpectedToken;
+                if (source.array.items.len != structInfo.field_names.len) return error.UnexpectedToken;
 
                 var r: T = undefined;
-                inline for (0..structInfo.fields.len, source.array.items) |i, item| {
-                    r[i] = try innerParseFromValue(structInfo.fields[i].type, allocator, item, options);
+                inline for (0..structInfo.field_names.len, source.array.items) |i, item| {
+                    r[i] = try innerParseFromValue(structInfo.field_types[i], allocator, item, options);
                 }
 
                 return r;
@@ -649,17 +654,22 @@ pub fn innerParseFromValue(
             if (source != .object) return error.UnexpectedToken;
 
             var r: T = undefined;
-            var fields_seen: [structInfo.fields.len]bool = @splat(false);
+            var fields_seen: [structInfo.field_names.len]bool = @splat(false);
 
             var it = source.object.iterator();
             while (it.next()) |kv| {
                 const field_name = kv.key_ptr.*;
 
-                inline for (structInfo.fields, 0..) |field, i| {
-                    if (field.is_comptime) @compileError("comptime fields are not supported: " ++ @typeName(T) ++ "." ++ field.name);
-                    if (std.mem.eql(u8, field.name, field_name)) {
+                inline for (
+                    structInfo.field_names,
+                    structInfo.field_types,
+                    structInfo.field_attrs,
+                    0..,
+                ) |f_name, f_type, f_attrs, i| {
+                    if (f_attrs.@"comptime") @compileError("comptime fields are not supported: " ++ @typeName(T) ++ "." ++ f_name);
+                    if (std.mem.eql(u8, f_name, field_name)) {
                         assert(!fields_seen[i]); // Can't have duplicate keys in a Value.object.
-                        @field(r, field.name) = try innerParseFromValue(field.type, allocator, kv.value_ptr.*, options);
+                        @field(r, f_name) = try innerParseFromValue(f_type, allocator, kv.value_ptr.*, options);
                         fields_seen[i] = true;
                         break;
                     }
@@ -782,11 +792,17 @@ fn sliceToEnum(comptime T: type, slice: []const u8) !T {
     return std.enums.fromInt(T, n) orelse return error.InvalidEnumTag;
 }
 
-fn fillDefaultStructValues(comptime T: type, r: *T, fields_seen: *[@typeInfo(T).@"struct".fields.len]bool) !void {
-    inline for (@typeInfo(T).@"struct".fields, 0..) |field, i| {
+fn fillDefaultStructValues(comptime T: type, r: *T, fields_seen: *[@typeInfo(T).@"struct".field_names.len]bool) !void {
+    const info = @typeInfo(T).@"struct";
+    inline for (
+        info.field_names,
+        info.field_types,
+        info.field_attrs,
+        0..,
+    ) |field_name, field_type, field_attrs, i| {
         if (!fields_seen[i]) {
-            if (field.defaultValue()) |default| {
-                @field(r, field.name) = default;
+            if (field_attrs.defaultValue(field_type)) |default| {
+                @field(r, field_name) = default;
             } else {
                 return error.MissingField;
             }