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

package/std/crypto/codecs/asn1/der/Encoder.zig

@@ -29,16 +29,18 @@ fn anyTag(self: *Encoder, tag_: Tag, val: anytype) !void {
 
     switch (@typeInfo(T)) {
         .@"struct" => |info| {
-            inline for (0..info.fields.len) |i| {
-                const f = info.fields[info.fields.len - i - 1];
-                const field_val = @field(val, f.name);
-                const field_tag = FieldTag.fromContainer(T, f.name);
+            inline for (0..info.field_names.len) |i| {
+                const f_idx = info.field_names.len - i - 1;
+                const f_name = info.field_names[f_idx];
+                const f_type = info.field_types[f_idx];
+                const f_attrs = info.field_attrs[f_idx];
+                const field_val = @field(val, f_name);
+                const field_tag = FieldTag.fromContainer(T, f_name);
 
                 // > The encoding of a set value or sequence value shall not include an encoding for any
                 // > component value which is equal to its default value.
-                const is_default = if (f.is_comptime) false else if (f.default_value_ptr) |v| brk: {
-                    const default_val: *const f.type = @ptrCast(@alignCast(v));
-                    break :brk std.mem.eql(u8, std.mem.asBytes(default_val), std.mem.asBytes(&field_val));
+                const is_default = if (f_attrs.@"comptime") false else if (f_attrs.defaultValue(f_type)) |default_val| brk: {
+                    break :brk std.mem.eql(u8, std.mem.asBytes(&default_val), std.mem.asBytes(&field_val));
                 } else false;
 
                 if (!is_default) {
@@ -46,7 +48,7 @@ fn anyTag(self: *Encoder, tag_: Tag, val: anytype) !void {
                     self.field_tag = field_tag;
                     // will merge with self.field_tag.
                     // may mutate self.field_tag.
-                    try self.anyTag(Tag.fromZig(f.type), field_val);
+                    try self.anyTag(Tag.fromZig(f_type), field_val);
                     if (field_tag) |ft| {
                         if (ft.explicit) {
                             try self.length(self.buffer.data.len - start2);

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

@@ -93,12 +93,28 @@ pub fn getSymbols(
 pub fn getModuleName(si: *SelfInfo, io: Io, address: usize) Error![]const u8 {
     _ = si;
     _ = io;
-    // This function is marked as deprecated; however, it is significantly more
-    // performant than `dladdr` (since the latter also does a very slow symbol
-    // lookup), so let's use it since it's still available.
-    return std.mem.span(std.c.dyld_image_path_containing_address(
-        @ptrFromInt(address),
-    ) orelse return error.MissingDebugInfo);
+    return getModuleNameInner(address) orelse return error.MissingDebugInfo;
+}
+fn getModuleNameInner(address: usize) ?[]const u8 {
+    switch (builtin.target.os.tag) {
+        .macos => {
+            // This function is marked as deprecated; however, it is significantly more performant
+            // than `dladdr` (since the latter also does a very slow symbol lookup), so let's just
+            // use it for the better performance since it's still available.
+            return std.mem.span(std.c.dyld_image_path_containing_address(
+                @ptrFromInt(address),
+            ) orelse return null);
+        },
+        else => {
+            // On other Darwin systems, the function used above is entirely unavailable, so we have
+            // no choice but to use the slow `dladdr`.
+            var info: std.c.dl_info = undefined;
+            if (std.c.dladdr(@ptrFromInt(address), &info) == 0) {
+                return null;
+            }
+            return std.mem.span(info.fname);
+        },
+    }
 }
 pub fn getModuleSlide(si: *SelfInfo, io: Io, address: usize) Error!usize {
     const gpa = std.debug.getDebugInfoAllocator();
@@ -408,8 +424,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)).*;
@@ -446,12 +462,25 @@ fn unwindFrameInner(si: *SelfInfo, io: Io, context: *UnwindContext) !usize {
 
 /// Acquires the mutex on success.
 fn findModule(si: *SelfInfo, gpa: Allocator, io: Io, address: usize) Error!*Module {
-    // This function is marked as deprecated; however, it is significantly more
-    // performant than `dladdr` (since the latter also does a very slow symbol
-    // lookup), so let's use it since it's still available.
-    const text_base = std.c._dyld_get_image_header_containing_address(
-        @ptrFromInt(address),
-    ) orelse return error.MissingDebugInfo;
+    const text_base: *anyopaque = switch (builtin.target.os.tag) {
+        .macos => base: {
+            // This function is marked as deprecated; however, it is significantly more performant
+            // than `dladdr` (since the latter also does a very slow symbol lookup), so let's just
+            // use it for the better performance since it's still available.
+            break :base std.c._dyld_get_image_header_containing_address(
+                @ptrFromInt(address),
+            ) orelse return error.MissingDebugInfo;
+        },
+        else => base: {
+            // On other Darwin systems, the function used above is entirely unavailable, so we have
+            // no choice but to use the slow `dladdr`.
+            var info: std.c.dl_info = undefined;
+            if (std.c.dladdr(@ptrFromInt(address), &info) == 0) {
+                return error.MissingDebugInfo;
+            }
+            break :base info.fbase;
+        },
+    };
     try si.mutex.lock(io);
     errdefer si.mutex.unlock(io);
     const gop = try si.modules.getOrPutAdapted(gpa, @intFromPtr(text_base), Module.Adapter{});
@@ -563,9 +592,7 @@ const Module = struct {
 
     fn getFile(module: *Module, gpa: Allocator, io: Io) Error!*MachOFile {
         if (module.file == null) {
-            const path = std.mem.span(
-                std.c.dyld_image_path_containing_address(@ptrFromInt(module.text_base)).?,
-            );
+            const path = getModuleNameInner(module.text_base).?;
             module.file = MachOFile.load(gpa, io, path, builtin.cpu.arch) catch |err| switch (err) {
                 error.InvalidMachO, error.InvalidDwarf => error.InvalidDebugInfo,
                 error.MissingDebugInfo, error.OutOfMemory, error.UnsupportedDebugInfo, error.ReadFailed => |e| e,

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) {