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

package/compiler/resinator/errors.zig

@@ -145,8 +145,8 @@ pub const ErrorDetails = struct {
 
     comptime {
         // all fields in the extra union should be 32 bits or less
-        for (std.meta.fields(Extra)) |field| {
-            std.debug.assert(@bitSizeOf(field.type) <= 32);
+        for (std.meta.fieldTypes(Extra)) |field_type| {
+            std.debug.assert(@bitSizeOf(field_type) <= 32);
         }
     }
 
@@ -257,18 +257,18 @@ pub const ErrorDetails = struct {
 
         pub fn writeCommaSeparated(self: ExpectedTypes, writer: *std.Io.Writer) !void {
             const struct_info = @typeInfo(ExpectedTypes).@"struct";
-            const num_real_fields = struct_info.fields.len - 1;
+            const num_real_fields = struct_info.field_names.len - 1;
             const num_padding_bits = @bitSizeOf(ExpectedTypes) - num_real_fields;
             const mask = std.math.maxInt(struct_info.backing_integer.?) >> num_padding_bits;
             const relevant_bits_only = @as(struct_info.backing_integer.?, @bitCast(self)) & mask;
             const num_set_bits = @popCount(relevant_bits_only);
 
             var i: usize = 0;
-            inline for (struct_info.fields) |field_info| {
-                if (field_info.type != bool) continue;
+            inline for (struct_info.field_names, struct_info.field_types) |field_name, field_type| {
+                if (field_type != bool) continue;
                 if (i == num_set_bits) return;
-                if (@field(self, field_info.name)) {
-                    try writer.writeAll(strings.get(field_info.name).?);
+                if (@field(self, field_name)) {
+                    try writer.writeAll(strings.get(field_name).?);
                     i += 1;
                     if (num_set_bits > 2 and i != num_set_bits) {
                         try writer.writeAll(", ");
@@ -857,24 +857,20 @@ pub const ErrorDetails = struct {
 
 /// Convenience struct only useful when the code page can be inferred from the token
 pub const ErrorDetailsWithoutCodePage = blk: {
-    const details_info = @typeInfo(ErrorDetails);
-    const fields = details_info.@"struct".fields;
-    var field_names: [fields.len - 1][]const u8 = undefined;
-    var field_types: [fields.len - 1]type = undefined;
-    var field_attrs: [fields.len - 1]std.builtin.Type.StructField.Attributes = undefined;
+    const details_info = @typeInfo(ErrorDetails).@"struct";
+    const field_count = details_info.field_names.len;
+    var field_names: [field_count - 1][]const u8 = undefined;
+    var field_types: [field_count - 1]type = undefined;
+    var field_attrs: [field_count - 1]std.builtin.Type.Struct.FieldAttributes = undefined;
     var i: usize = 0;
-    for (fields) |field| {
-        if (std.mem.eql(u8, field.name, "code_page")) continue;
-        field_names[i] = field.name;
-        field_types[i] = field.type;
-        field_attrs[i] = .{
-            .@"comptime" = field.is_comptime,
-            .@"align" = field.alignment,
-            .default_value_ptr = field.default_value_ptr,
-        };
+    for (details_info.field_names, details_info.field_types, details_info.field_attrs) |field_name, field_type, field_attr| {
+        if (std.mem.eql(u8, field_name, "code_page")) continue;
+        field_names[i] = field_name;
+        field_types[i] = field_type;
+        field_attrs[i] = field_attr;
         i += 1;
     }
-    std.debug.assert(i == fields.len - 1);
+    std.debug.assert(i == field_count - 1);
     break :blk @Struct(.auto, null, &field_names, &field_types, &field_attrs);
 };
 

package/compiler/resinator/lang.zig

@@ -87,8 +87,8 @@ pub fn tagToId(tag: []const u8) error{InvalidLanguageTag}!?LanguageId {
     if (parsed.multiple_suffixes) return null;
     const longest_known_tag = comptime blk: {
         var len = 0;
-        for (@typeInfo(LanguageId).@"enum".fields) |field| {
-            if (field.name.len > len) len = field.name.len;
+        for (@typeInfo(LanguageId).@"enum".field_names) |field_name| {
+            if (field_name.len > len) len = field_name.len;
         }
         break :blk len;
     };
@@ -120,13 +120,13 @@ test tagToId {
 
 test "exhaustive tagToId" {
     @setEvalBranchQuota(2000);
-    inline for (@typeInfo(LanguageId).@"enum".fields) |field| {
-        const id = tagToId(field.name) catch |err| {
-            std.debug.print("tag: {s}\n", .{field.name});
+    inline for (@typeInfo(LanguageId).@"enum".field_names) |field_name| {
+        const id = tagToId(field_name) catch |err| {
+            std.debug.print("tag: {s}\n", .{field_name});
             return err;
         };
-        try std.testing.expectEqual(@field(LanguageId, field.name), id orelse {
-            std.debug.print("tag: {s}, got null\n", .{field.name});
+        try std.testing.expectEqual(@field(LanguageId, field_name), id orelse {
+            std.debug.print("tag: {s}, got null\n", .{field_name});
             return error.TestExpectedEqual;
         });
     }

package/compiler/resinator/parse.zig

@@ -137,7 +137,7 @@ pub const Parser = struct {
     fn parseOptionalStatements(self: *Self, resource: ResourceType) ![]*Node {
         var optional_statements: std.ArrayList(*Node) = .empty;
 
-        const num_statement_types = @typeInfo(rc.OptionalStatements).@"enum".fields.len;
+        const num_statement_types = @typeInfo(rc.OptionalStatements).@"enum".field_names.len;
         var statement_type_has_duplicates: [num_statement_types]bool = @splat(false);
         var last_statement_per_type: [num_statement_types]?*Node = @splat(null);
 

package/compiler/translate-c/ast.zig

@@ -925,18 +925,18 @@ const Context = struct {
     }
 
     fn addExtra(c: *Context, extra: anytype) Allocator.Error!std.zig.Ast.ExtraIndex {
-        const fields = std.meta.fields(@TypeOf(extra));
-        try c.extra_data.ensureUnusedCapacity(c.gpa, fields.len);
+        const info = @typeInfo(@TypeOf(extra)).@"struct";
+        try c.extra_data.ensureUnusedCapacity(c.gpa, info.field_names.len);
         const result: std.zig.Ast.ExtraIndex = @enumFromInt(c.extra_data.items.len);
-        inline for (fields) |field| {
-            const data: u32 = switch (field.type) {
+        inline for (info.field_names, info.field_types) |field_name, field_type| {
+            const data: u32 = switch (field_type) {
                 NodeIndex,
                 std.zig.Ast.Node.OptionalIndex,
                 std.zig.Ast.OptionalTokenIndex,
                 std.zig.Ast.ExtraIndex,
-                => @intFromEnum(@field(extra, field.name)),
+                => @intFromEnum(@field(extra, field_name)),
                 TokenIndex,
-                => @field(extra, field.name),
+                => @field(extra, field_name),
                 else => @compileError("unexpected field type"),
             };
             c.extra_data.appendAssumeCapacity(data);

package/docs/wasm/markdown/Document.zig

@@ -170,11 +170,11 @@ pub fn ExtraData(comptime T: type) type {
 }
 
 pub fn extraData(doc: Document, comptime T: type, index: ExtraIndex) ExtraData(T) {
-    const fields = @typeInfo(T).@"struct".fields;
+    const info = @typeInfo(T).@"struct";
     var i: usize = @intFromEnum(index);
     var result: T = undefined;
-    inline for (fields) |field| {
-        @field(result, field.name) = switch (field.type) {
+    inline for (info.field_names, info.field_types) |field_name, field_type| {
+        @field(result, field_name) = switch (field_type) {
             u32 => doc.extra[i],
             else => @compileError("bad field type"),
         };

package/docs/wasm/markdown/Parser.zig

@@ -1574,11 +1574,11 @@ fn parseInlines(p: *Parser, content: []const u8) !ExtraIndex {
 }
 
 pub fn extraData(p: Parser, comptime T: type, index: ExtraIndex) ExtraData(T) {
-    const fields = @typeInfo(T).@"struct".fields;
+    const info = @typeInfo(T).@"struct";
     var i: usize = @intFromEnum(index);
     var result: T = undefined;
-    inline for (fields) |field| {
-        @field(result, field.name) = switch (field.type) {
+    inline for (info.field_names, info.field_types) |field_name, field_type| {
+        @field(result, field_name) = switch (field_type) {
             u32 => p.extra.items[i],
             else => @compileError("bad field type"),
         };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zigc/lib",
-  "version": "0.17.0-dev.644",
+  "version": "0.17.0-dev.657",
   "description": "Zig standard library and libc headers (shared across all platforms)",
   "repository": {
     "type": "git",

package/std/Build/Cache.zig

@@ -1241,7 +1241,7 @@ pub const Manifest = struct {
     }
 
     pub fn populateFileSystemInputs(man: *Manifest, buf: *std.ArrayList(u8)) Allocator.Error!void {
-        assert(@typeInfo(std.zig.Server.Message.PathPrefix).@"enum".fields.len == man.cache.prefixes_len);
+        assert(@typeInfo(std.zig.Server.Message.PathPrefix).@"enum".field_names.len == man.cache.prefixes_len);
         buf.clearRetainingCapacity();
         const gpa = man.cache.gpa;
         const files = man.files.keys();
@@ -1259,7 +1259,7 @@ pub const Manifest = struct {
 
     pub fn populateOtherManifest(man: *Manifest, other: *Manifest, prefix_map: [4]u8) Allocator.Error!void {
         const gpa = other.cache.gpa;
-        assert(@typeInfo(std.zig.Server.Message.PathPrefix).@"enum".fields.len == man.cache.prefixes_len);
+        assert(@typeInfo(std.zig.Server.Message.PathPrefix).@"enum".field_names.len == man.cache.prefixes_len);
         assert(man.cache.prefixes_len == 4);
         for (man.files.keys()) |file| {
             const prefixed_path: PrefixedPath = .{

package/std/Build/Configuration.zig

@@ -2884,7 +2884,10 @@ pub const Storage = enum {
             }
 
             pub fn cast(this: @This(), c: *const Configuration, comptime S: type) ?S {
-                const wanted_tag = @typeInfo(S.Flags).@"struct".fields[0].defaultValue().?;
+                const wanted_tag = blk: {
+                    const info = @typeInfo(S.Flags).@"struct";
+                    break :blk info.field_attrs[0].defaultValue(info.field_types[0]).?;
+                };
                 const base_flags: BaseFlags = @bitCast(c.extra[@intFromEnum(this)]);
                 if (base_flags.tag != wanted_tag) return null;
                 var i: usize = @intFromEnum(this);
@@ -3047,8 +3050,8 @@ pub const Storage = enum {
         switch (@typeInfo(T)) {
             .@"struct" => |info| {
                 var result: T = undefined;
-                inline for (info.fields) |field| {
-                    @field(result, field.name) = dataField(buffer, i, &result, field.type);
+                inline for (info.field_names, info.field_types) |field_name, field_type| {
+                    @field(result, field_name) = dataField(buffer, i, &result, field_type);
                 }
                 return result;
             },
@@ -3058,7 +3061,7 @@ pub const Storage = enum {
                     inline else => |comptime_tag| @unionInit(
                         T,
                         @tagName(comptime_tag),
-                        data(buffer, i, info.fields[@intFromEnum(comptime_tag)].type),
+                        data(buffer, i, info.field_types[@intFromEnum(comptime_tag)]),
                     ),
                 };
             },
@@ -3125,7 +3128,7 @@ pub const Storage = enum {
                                             buffer,
                                             i,
                                             container,
-                                            @typeInfo(Field.Union).@"union".fields[@intFromEnum(comptime_tag)].type,
+                                            @typeInfo(Field.Union).@"union".field_types[@intFromEnum(comptime_tag)],
                                         ),
                                     ),
                                 },
@@ -3167,7 +3170,7 @@ pub const Storage = enum {
                         .multi_list => {
                             const data_start = i.* + 1;
                             const len = buffer[data_start - 1];
-                            defer i.* = data_start + len * @typeInfo(Field.Elem).@"struct".fields.len;
+                            defer i.* = data_start + len * @typeInfo(Field.Elem).@"struct".field_names.len;
                             return .{ .mal = .{
                                 .bytes = @ptrCast(@constCast(buffer[data_start..][0..len])),
                                 .len = len,
@@ -3205,10 +3208,10 @@ pub const Storage = enum {
 
     /// Returns new end index.
     fn setExtra(buffer: []u32, index: usize, extra: anytype) usize {
-        const fields = @typeInfo(@TypeOf(extra)).@"struct".fields;
+        const info = @typeInfo(@TypeOf(extra)).@"struct";
         var i = index;
-        inline for (fields) |field| {
-            i += setExtraField(buffer, i, field.type, @field(extra, field.name));
+        inline for (info.field_names, info.field_types) |field_name, field_type| {
+            i += setExtraField(buffer, i, field_type, @field(extra, field_name));
         }
         return i;
     }
@@ -3236,7 +3239,7 @@ pub const Storage = enum {
                     .flag_length_prefixed_list,
                     .flag_list,
                     => 1 + @divExact(@sizeOf(Field.Elem), @sizeOf(u32)) * field.slice.len,
-                    .multi_list => 1 + field.mal.len * @typeInfo(Field.Elem).@"struct".fields.len,
+                    .multi_list => 1 + field.mal.len * @typeInfo(Field.Elem).@"struct".field_names.len,
                     .union_list => Field.extraLen(field.len),
                     .flag_union => switch (field.u) {
                         inline else => |v| extraFieldLen(v),
@@ -3249,10 +3252,10 @@ pub const Storage = enum {
     }
 
     fn extraLen(extra: anytype) usize {
-        const fields = @typeInfo(@TypeOf(extra)).@"struct".fields;
+        const field_names = @typeInfo(@TypeOf(extra)).@"struct".field_names;
         var i: usize = 0;
-        inline for (fields) |field| {
-            i += Storage.extraFieldLen(@field(extra, field.name));
+        inline for (field_names) |name| {
+            i += Storage.extraFieldLen(@field(extra, name));
         }
         return i;
     }
@@ -3324,12 +3327,12 @@ pub const Storage = enum {
                         .multi_list => {
                             const len: u32 = @intCast(value.mal.len);
                             buffer[i] = len;
-                            const fields = @typeInfo(Field.Elem).@"struct".fields;
-                            inline for (0..fields.len) |field_i| @memcpy(
+                            const field_names = @typeInfo(Field.Elem).@"struct".field_names;
+                            inline for (0..field_names.len) |field_i| @memcpy(
                                 buffer[i + 1 + field_i * len ..][0..len],
                                 @as([]const u32, @ptrCast(value.mal.items(@enumFromInt(field_i)))),
                             );
-                            return 1 + fields.len * len;
+                            return 1 + field_names.len * len;
                         },
                         .union_list => {
                             if (value.len == 0) return 0;

package/std/Build/Step/ConfigHeader.zig

@@ -173,8 +173,9 @@ fn addValueInner(config_header: *ConfigHeader, name: []const u8, comptime T: typ
 }
 
 pub fn addValues(config_header: *ConfigHeader, values: anytype) void {
-    inline for (@typeInfo(@TypeOf(values)).@"struct".fields) |field| {
-        addValue(config_header, field.name, field.type, @field(values, field.name));
+    const info = @typeInfo(@TypeOf(values)).@"struct";
+    inline for (info.field_names, info.field_types) |field_name, field_type| {
+        addValue(config_header, field_name, field_type, @field(values, field_name));
     }
 }
 

package/std/Build/Step/Options.zig

@@ -299,14 +299,14 @@ fn printEnum(
     try out.appendNTimes(gpa, ' ', indent);
     try out.print(gpa, "pub const {f} = enum ({s}) {{\n", .{ std.zig.fmtId(@typeName(T)), @typeName(val.tag_type) });
 
-    inline for (val.fields) |field| {
+    inline for (val.field_names, val.field_values) |field_name, field_value| {
         try out.appendNTimes(gpa, ' ', indent);
         try out.print(gpa, "    {f} = {d},\n", .{
-            std.zig.fmtIdFlags(field.name, .{ .allow_primitive = true }), field.value,
+            std.zig.fmtIdFlags(field_name, .{ .allow_primitive = true }), field_value,
         });
     }
 
-    if (!val.is_exhaustive) {
+    if (val.mode == .nonexhaustive) {
         try out.appendNTimes(gpa, ' ', indent);
         try out.appendSlice(gpa, "    _,\n");
     }
@@ -315,7 +315,13 @@ fn printEnum(
     try out.appendSlice(gpa, "};\n");
 }
 
-fn printStruct(options: *Options, out: *std.ArrayList(u8), comptime T: type, comptime val: std.builtin.Type.Struct, indent: u8) !void {
+fn printStruct(
+    options: *Options,
+    out: *std.ArrayList(u8),
+    comptime T: type,
+    comptime val: std.builtin.Type.Struct,
+    indent: u8,
+) !void {
     const gpa = options.step.owner.allocator;
     const gop = try options.encountered_types.getOrPut(gpa, @typeName(T));
     if (gop.found_existing) return;
@@ -331,32 +337,32 @@ fn printStruct(options: *Options, out: *std.ArrayList(u8), comptime T: type, com
 
     try out.appendSlice(gpa, " {\n");
 
-    inline for (val.fields) |field| {
+    inline for (val.field_names, val.field_types, val.field_attrs) |field_name, field_type, field_attrs| {
         try out.appendNTimes(gpa, ' ', indent);
 
-        const type_name = @typeName(field.type);
+        const type_name = @typeName(field_type);
 
         // If the type name doesn't contains a '.' the type is from zig builtins.
         if (std.mem.containsAtLeast(u8, type_name, 1, ".")) {
             try out.print(gpa, "    {f}: {f}", .{
-                std.zig.fmtIdFlags(field.name, .{ .allow_underscore = true, .allow_primitive = true }),
+                std.zig.fmtIdFlags(field_name, .{ .allow_underscore = true, .allow_primitive = true }),
                 std.zig.fmtId(type_name),
             });
         } else {
             try out.print(gpa, "    {f}: {s}", .{
-                std.zig.fmtIdFlags(field.name, .{ .allow_underscore = true, .allow_primitive = true }),
+                std.zig.fmtIdFlags(field_name, .{ .allow_underscore = true, .allow_primitive = true }),
                 type_name,
             });
         }
 
-        if (field.defaultValue()) |default_value| {
+        if (field_attrs.defaultValue(field_type)) |default_value| {
             try out.appendSlice(gpa, " = ");
-            switch (@typeInfo(@TypeOf(default_value))) {
+            switch (@typeInfo(field_type)) {
                 .@"enum" => try out.print(gpa, ".{s},\n", .{@tagName(default_value)}),
                 .@"struct" => |info| {
                     try printStructValue(options, out, info, default_value, indent + 4);
                 },
-                else => try printType(options, out, @TypeOf(default_value), default_value, indent, null),
+                else => try printType(options, out, field_type, default_value, indent, null),
             }
         } else {
             try out.appendSlice(gpa, ",\n");
@@ -368,8 +374,8 @@ fn printStruct(options: *Options, out: *std.ArrayList(u8), comptime T: type, com
     try out.appendNTimes(gpa, ' ', indent);
     try out.appendSlice(gpa, "};\n");
 
-    inline for (val.fields) |field| {
-        try printUserDefinedType(options, out, field.type, 0);
+    inline for (val.field_types) |field_type| {
+        try printUserDefinedType(options, out, field_type, 0);
     }
 }
 
@@ -384,24 +390,24 @@ fn printStructValue(
     try out.appendSlice(gpa, ".{\n");
 
     if (struct_val.is_tuple) {
-        inline for (struct_val.fields) |field| {
+        inline for (struct_val.field_names) |field_name| {
             try out.appendNTimes(gpa, ' ', indent);
-            try printType(options, out, @TypeOf(@field(val, field.name)), @field(val, field.name), indent, null);
+            try printType(options, out, @TypeOf(@field(val, field_name)), @field(val, field_name), indent, null);
         }
     } else {
-        inline for (struct_val.fields) |field| {
+        inline for (struct_val.field_names) |field_name| {
             try out.appendNTimes(gpa, ' ', indent);
             try out.print(gpa, "    .{f} = ", .{
-                std.zig.fmtIdFlags(field.name, .{ .allow_primitive = true, .allow_underscore = true }),
+                std.zig.fmtIdFlags(field_name, .{ .allow_primitive = true, .allow_underscore = true }),
             });
 
-            const field_name = @field(val, field.name);
-            switch (@typeInfo(@TypeOf(field_name))) {
-                .@"enum" => try out.print(gpa, ".{s},\n", .{@tagName(field_name)}),
+            const field_val = @field(val, field_name);
+            switch (@typeInfo(@TypeOf(field_val))) {
+                .@"enum" => try out.print(gpa, ".{s},\n", .{@tagName(field_val)}),
                 .@"struct" => |struct_info| {
-                    try printStructValue(options, out, struct_info, field_name, indent + 4);
+                    try printStructValue(options, out, struct_info, field_val, indent + 4);
                 },
-                else => try printType(options, out, @TypeOf(field_name), field_name, indent, null),
+                else => try printType(options, out, @TypeOf(field_val), field_val, indent, null),
             }
         }
     }