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

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

package/std/lang.zig

@@ -596,13 +596,8 @@ pub const Type = union(enum) {
     /// therefore must be kept in sync with the compiler implementation.
     pub const Pointer = struct {
         size: Size,
-        is_const: bool,
-        is_volatile: bool,
-        /// `null` means implicit alignment, which is equivalent to `@alignOf(child)`.
-        alignment: ?usize,
-        address_space: AddressSpace,
+        attrs: Attributes,
         child: type,
-        is_allowzero: bool,
 
         /// The type of the sentinel is the element type of the pointer, which is
         /// the value of the `child` field in this struct. However there is no way
@@ -667,44 +662,40 @@ pub const Type = union(enum) {
 
     /// This data structure is used by the Zig language code generation and
     /// therefore must be kept in sync with the compiler implementation.
-    pub const StructField = struct {
-        name: [:0]const u8,
-        type: type,
-        /// The type of the default value is the type of this struct field, which
-        /// is the value of the `type` field in this struct. However there is no
-        /// way to refer to that type here, so we use `*const anyopaque`.
-        /// See also: `defaultValue`.
-        default_value_ptr: ?*const anyopaque,
-        is_comptime: bool,
-        /// `null` means the field alignment was not explicitly specified. The
-        /// field will still be aligned to at least `@alignOf` its `type`.
-        alignment: ?usize,
-
-        /// Loads the field's default value from `default_value_ptr`.
-        /// Returns `null` if the field has no default value.
-        pub inline fn defaultValue(comptime sf: StructField) ?sf.type {
-            const dp: *const sf.type = @ptrCast(@alignCast(sf.default_value_ptr orelse return null));
-            return dp.*;
-        }
+    pub const Struct = struct {
+        is_tuple: bool,
+        layout: ContainerLayout,
+        /// Always `null` if `layout != .@"packed"`.
+        backing_integer: ?type,
 
-        /// This data structure is used by the Zig language code generation and
-        /// therefore must be kept in sync with the compiler implementation.
-        pub const Attributes = struct {
+        field_names: []const [:0]const u8,
+        /// Guaranteed to have the same length as `field_names`.
+        field_types: []const type,
+        /// Guaranteed to have the same length as `field_names`.
+        field_attrs: []const FieldAttributes,
+
+        decl_names: []const [:0]const u8,
+
+        pub const FieldAttributes = struct {
             @"comptime": bool = false,
+            /// `null` means the field alignment is not explicitly specified. The field will still
+            /// be aligned to at least `@alignOf` the field type.
             @"align": ?usize = null,
+            /// The type of the default value is the type of this struct field. However, that type
+            /// is not known here, so we use a type-erased pointer instead, which must be cast to
+            /// a pointer to the field type.
+            ///
+            /// See also: `defaultValue`.
             default_value_ptr: ?*const anyopaque = null,
-        };
-    };
 
-    /// This data structure is used by the Zig language code generation and
-    /// therefore must be kept in sync with the compiler implementation.
-    pub const Struct = struct {
-        layout: ContainerLayout,
-        /// Only valid if layout is .@"packed"
-        backing_integer: ?type = null,
-        fields: []const StructField,
-        decls: []const Declaration,
-        is_tuple: bool,
+            /// Loads the field's default value from `default_value_ptr`.
+            /// `FieldType` must exactly match the corresponding element of `Struct.field_types`.
+            /// Returns `null` if the field has no default value.
+            pub inline fn defaultValue(comptime attrs: FieldAttributes, comptime FieldType: type) ?FieldType {
+                const dp: *const FieldType = @ptrCast(@alignCast(attrs.default_value_ptr orelse return null));
+                return dp.*;
+            }
+        };
     };
 
     /// This data structure is used by the Zig language code generation and
@@ -722,48 +713,25 @@ pub const Type = union(enum) {
 
     /// This data structure is used by the Zig language code generation and
     /// therefore must be kept in sync with the compiler implementation.
-    pub const Error = struct {
-        name: [:0]const u8,
-    };
-
-    /// This data structure is used by the Zig language code generation and
-    /// therefore must be kept in sync with the compiler implementation.
-    pub const ErrorSet = ?[]const Error;
-
-    /// This data structure is used by the Zig language code generation and
-    /// therefore must be kept in sync with the compiler implementation.
-    pub const EnumField = struct {
-        name: [:0]const u8,
-        value: comptime_int,
+    pub const ErrorSet = struct {
+        error_names: ?[]const [:0]const u8,
     };
 
     /// This data structure is used by the Zig language code generation and
     /// therefore must be kept in sync with the compiler implementation.
     pub const Enum = struct {
         tag_type: type,
-        fields: []const EnumField,
-        decls: []const Declaration,
-        is_exhaustive: bool,
+        mode: Mode,
 
-        /// This data structure is used by the Zig language code generation and
-        /// therefore must be kept in sync with the compiler implementation.
-        pub const Mode = enum { exhaustive, nonexhaustive };
-    };
+        field_names: []const [:0]const u8,
+        /// Guaranteed to have the same length as `field_names`.
+        field_values: []const comptime_int,
 
-    /// This data structure is used by the Zig language code generation and
-    /// therefore must be kept in sync with the compiler implementation.
-    pub const UnionField = struct {
-        name: [:0]const u8,
-        type: type,
-        /// `null` means the field alignment was not explicitly specified. The
-        /// field will still be aligned to at least `@alignOf` its `type`.
-        alignment: ?usize,
+        decl_names: []const [:0]const u8,
 
         /// This data structure is used by the Zig language code generation and
         /// therefore must be kept in sync with the compiler implementation.
-        pub const Attributes = struct {
-            @"align": ?usize = null,
-        };
+        pub const Mode = enum { exhaustive, nonexhaustive };
     };
 
     /// This data structure is used by the Zig language code generation and
@@ -771,36 +739,42 @@ pub const Type = union(enum) {
     pub const Union = struct {
         layout: ContainerLayout,
         tag_type: ?type,
-        fields: []const UnionField,
-        decls: []const Declaration,
+        /// Always `null` if `layout != .@"packed"`.
+        backing_integer: ?type,
+
+        field_names: []const [:0]const u8,
+        /// Guaranteed to have the same length as `field_names`.
+        field_types: []const type,
+        /// Guaranteed to have the same length as `field_names`.
+        field_attrs: []const FieldAttributes,
+
+        decl_names: []const [:0]const u8,
+
+        pub const FieldAttributes = struct {
+            /// `null` means the field alignment is not explicitly specified. The field will still
+            /// be aligned to at least `@alignOf` the field type.
+            @"align": ?usize = null,
+        };
     };
 
     /// This data structure is used by the Zig language code generation and
     /// therefore must be kept in sync with the compiler implementation.
     pub const Fn = struct {
-        calling_convention: CallingConvention,
+        attrs: Attributes,
         is_generic: bool,
-        is_var_args: bool,
-        /// TODO change the language spec to make this not optional.
+        /// `null` means the return type is generic, i.e. it depends on a function argument.
         return_type: ?type,
-        params: []const Param,
 
-        /// This data structure is used by the Zig language code generation and
-        /// therefore must be kept in sync with the compiler implementation.
-        pub const Param = struct {
-            is_generic: bool,
-            is_noalias: bool,
-            type: ?type,
-
-            /// This data structure is used by the Zig language code generation and
-            /// therefore must be kept in sync with the compiler implementation.
-            pub const Attributes = struct {
-                @"noalias": bool = false,
-            };
+        /// A `null` element represents either an `anytype` parameter, or a parameter with a generic
+        /// type, i.e. where the type depends on a previous function argument.
+        param_types: []const ?type,
+        /// Guaranteed to have the same length as `param_types`.
+        param_attrs: []const ParamAttributes,
+
+        pub const ParamAttributes = struct {
+            @"noalias": bool = false,
         };
 
-        /// This data structure is used by the Zig language code generation and
-        /// therefore must be kept in sync with the compiler implementation.
         pub const Attributes = struct {
             @"callconv": CallingConvention = .auto,
             varargs: bool = false,
@@ -810,7 +784,7 @@ pub const Type = union(enum) {
     /// This data structure is used by the Zig language code generation and
     /// therefore must be kept in sync with the compiler implementation.
     pub const Opaque = struct {
-        decls: []const Declaration,
+        decl_names: []const [:0]const u8,
     };
 
     /// This data structure is used by the Zig language code generation and
@@ -831,12 +805,6 @@ pub const Type = union(enum) {
         len: comptime_int,
         child: type,
     };
-
-    /// This data structure is used by the Zig language code generation and
-    /// therefore must be kept in sync with the compiler implementation.
-    pub const Declaration = struct {
-        name: [:0]const u8,
-    };
 };
 
 /// This data structure is used by the Zig language code generation and

package/std/math.zig

@@ -1648,8 +1648,8 @@ pub const CompareOperator = enum {
     }
 
     test reverse {
-        inline for (@typeInfo(CompareOperator).@"enum".fields) |op_field| {
-            const op = @as(CompareOperator, @enumFromInt(op_field.value));
+        inline for (@typeInfo(CompareOperator).@"enum".field_values) |op_field_value| {
+            const op = @as(CompareOperator, @enumFromInt(op_field_value));
             try testing.expect(compare(2, op, 3) == compare(3, op.reverse(), 2));
             try testing.expect(compare(3, op, 3) == compare(3, op.reverse(), 3));
             try testing.expect(compare(4, op, 3) == compare(3, op.reverse(), 4));

package/std/mem/Allocator.zig

@@ -183,7 +183,7 @@ pub fn destroy(self: Allocator, ptr: anytype) void {
     const non_const_ptr = @as([*]u8, @ptrCast(@constCast(ptr)));
     self.rawFree(
         non_const_ptr[0..@sizeOf(T)],
-        .fromByteUnits(info.alignment orelse @alignOf(T)),
+        .fromByteUnits(info.attrs.@"align" orelse @alignOf(T)),
         @returnAddress(),
     );
 }
@@ -331,7 +331,7 @@ pub fn resize(self: Allocator, allocation: anytype, new_len: usize) bool {
     const new_len_bytes = math.mul(usize, @sizeOf(T), new_len) catch return false;
     return self.rawResize(
         old_memory,
-        .fromByteUnits(slice_info.alignment orelse @alignOf(T)),
+        .fromByteUnits(slice_info.attrs.@"align" orelse @alignOf(T)),
         new_len_bytes,
         @returnAddress(),
     );
@@ -377,7 +377,7 @@ pub fn remap(self: Allocator, allocation: anytype, new_len: usize) ?@TypeOf(allo
     const new_len_bytes = math.mul(usize, @sizeOf(T), new_len) catch return null;
     const new_ptr = self.rawRemap(
         old_memory,
-        .fromByteUnits(slice_info.alignment orelse @alignOf(T)),
+        .fromByteUnits(slice_info.attrs.@"align" orelse @alignOf(T)),
         new_len_bytes,
         @returnAddress(),
     ) orelse return null;
@@ -412,11 +412,11 @@ pub fn reallocAdvanced(
     comptime assert(slice_info.size == .slice);
     const T = slice_info.child;
     if (old_mem.len == 0) {
-        return self.allocAdvancedWithRetAddr(T, .fromByteUnitsOptional(slice_info.alignment), new_n, return_address);
+        return self.allocAdvancedWithRetAddr(T, .fromByteUnitsOptional(slice_info.attrs.@"align"), new_n, return_address);
     }
     if (new_n == 0) {
         self.free(old_mem);
-        const alignment = slice_info.alignment orelse @alignOf(T);
+        const alignment = slice_info.attrs.@"align" orelse @alignOf(T);
         const addr = comptime std.mem.alignBackward(usize, math.maxInt(usize), alignment);
         const ptr: *align(alignment) [0]T = @ptrFromInt(addr);
         return ptr;
@@ -425,16 +425,16 @@ pub fn reallocAdvanced(
     const old_byte_slice: []u8 = @ptrCast(@constCast(mem.absorbSentinel(old_mem)));
     const byte_count = math.mul(usize, @sizeOf(T), new_n) catch return error.OutOfMemory;
     // Note: can't set shrunk memory to undefined as memory shouldn't be modified on realloc failure
-    if (self.rawRemap(old_byte_slice, .fromByteUnits(slice_info.alignment orelse @alignOf(T)), byte_count, return_address)) |p| {
+    if (self.rawRemap(old_byte_slice, .fromByteUnits(slice_info.attrs.@"align" orelse @alignOf(T)), byte_count, return_address)) |p| {
         return @ptrCast(@alignCast(p[0..byte_count]));
     }
 
-    const new_mem = self.rawAlloc(byte_count, .fromByteUnits(slice_info.alignment orelse @alignOf(T)), return_address) orelse
+    const new_mem = self.rawAlloc(byte_count, .fromByteUnits(slice_info.attrs.@"align" orelse @alignOf(T)), return_address) orelse
         return error.OutOfMemory;
     const copy_len = @min(byte_count, old_byte_slice.len);
     @memcpy(new_mem[0..copy_len], old_byte_slice[0..copy_len]);
     @memset(old_byte_slice, undefined);
-    self.rawFree(old_byte_slice, .fromByteUnits(slice_info.alignment orelse @alignOf(T)), return_address);
+    self.rawFree(old_byte_slice, .fromByteUnits(slice_info.attrs.@"align" orelse @alignOf(T)), return_address);
 
     return @ptrCast(@alignCast(new_mem[0..byte_count]));
 }
@@ -448,7 +448,7 @@ pub fn free(self: Allocator, memory: anytype) void {
     const bytes: []u8 = @ptrCast(@constCast(mem.absorbSentinel(memory)));
     if (bytes.len == 0) return;
     @memset(bytes, undefined);
-    self.rawFree(bytes, .fromByteUnits(slice_info.alignment orelse @alignOf(slice_info.child)), @returnAddress());
+    self.rawFree(bytes, .fromByteUnits(slice_info.attrs.@"align" orelse @alignOf(slice_info.child)), @returnAddress());
 }
 
 /// Copies `m` to newly allocated memory. Caller owns the memory.