std: eradicate u29 and embrace std.mem.Alignment

Author: andrewrk

lib/compiler/aro/aro/Parser.zig

@@ -101,7 +101,7 @@ value_map: Tree.ValueMap,
 
 // buffers used during compilation
 syms: SymbolStack = .{},
-strings: std.ArrayListAligned(u8, 4),
+strings: std.ArrayListAligned(u8, .@"4"),
 labels: std.ArrayList(Label),
 list_buf: NodeList,
 decl_buf: NodeList,
@@ -693,7 +693,7 @@ pub fn parse(pp: *Preprocessor) Compilation.Error!Tree {
         .gpa = pp.comp.gpa,
         .arena = arena.allocator(),
         .tok_ids = pp.tokens.items(.id),
-        .strings = std.ArrayListAligned(u8, 4).init(pp.comp.gpa),
+        .strings = std.ArrayListAligned(u8, .@"4").init(pp.comp.gpa),
         .value_map = Tree.ValueMap.init(pp.comp.gpa),
         .data = NodeList.init(pp.comp.gpa),
         .labels = std.ArrayList(Label).init(pp.comp.gpa),

lib/compiler/aro/aro/Preprocessor.zig

@@ -983,7 +983,7 @@ fn expr(pp: *Preprocessor, tokenizer: *Tokenizer) MacroError!bool {
         .tok_i = @intCast(token_state.tokens_len),
         .arena = pp.arena.allocator(),
         .in_macro = true,
-        .strings = std.ArrayListAligned(u8, 4).init(pp.comp.gpa),
+        .strings = std.ArrayListAligned(u8, .@"4").init(pp.comp.gpa),
 
         .data = undefined,
         .value_map = undefined,

lib/compiler/objcopy.zig

@@ -841,12 +841,12 @@ fn ElfFile(comptime is_64: bool) type {
         arena: std.heap.ArenaAllocator,
 
         const SectionCategory = ElfFileHelper.SectionCategory;
-        const section_memory_align = @alignOf(Elf_Sym); // most restrictive of what we may load in memory
+        const section_memory_align: std.mem.Alignment = .of(Elf_Sym); // most restrictive of what we may load in memory
         const Section = struct {
             section: Elf_Shdr,
             name: []const u8 = "",
             segment: ?*const Elf_Phdr = null, // if the section is used by a program segment (there can be more than one)
-            payload: ?[]align(section_memory_align) const u8 = null, // if we need the data in memory
+            payload: ?[]align(section_memory_align.toByteUnits()) const u8 = null, // if we need the data in memory
             category: SectionCategory = .none, // should the section be kept in the exe or stripped to the debug database, or both.
         };
 
@@ -999,7 +999,7 @@ fn ElfFile(comptime is_64: bool) type {
                 remap_idx: u16,
 
                 // optionally overrides the payload from the source file
-                payload: ?[]align(section_memory_align) const u8 = null,
+                payload: ?[]align(section_memory_align.toByteUnits()) const u8 = null,
                 section: ?Elf_Shdr = null,
             };
             const sections_update = try allocator.alloc(Update, self.sections.len);
@@ -1219,7 +1219,7 @@ fn ElfFile(comptime is_64: bool) type {
                 if (options.debuglink) |link| {
                     const payload = payload: {
                         const crc_offset = std.mem.alignForward(usize, link.name.len + 1, 4);
-                        const buf = try allocator.alignedAlloc(u8, 4, crc_offset + 4);
+                        const buf = try allocator.alignedAlloc(u8, .@"4", crc_offset + 4);
                         @memcpy(buf[0..link.name.len], link.name);
                         @memset(buf[link.name.len..crc_offset], 0);
                         @memcpy(buf[crc_offset..], std.mem.asBytes(&link.crc32));
@@ -1498,7 +1498,7 @@ const ElfFileHelper = struct {
         var section_reader = std.io.limitedReader(in_file.reader(), size);
 
         // allocate as large as decompressed data. if the compression doesn't fit, keep the data uncompressed.
-        const compressed_data = try allocator.alignedAlloc(u8, 8, @intCast(size));
+        const compressed_data = try allocator.alignedAlloc(u8, .@"8", @intCast(size));
         var compressed_stream = std.io.fixedBufferStream(compressed_data);
 
         try compressed_stream.writer().writeAll(prefix);

lib/std/Build/Step/CheckObject.zig

@@ -563,7 +563,7 @@ fn make(step: *Step, make_options: Step.MakeOptions) !void {
         src_path.sub_path,
         check_object.max_bytes,
         null,
-        @alignOf(u64),
+        .of(u64),
         null,
     ) catch |err| return step.fail("unable to read '{'}': {s}", .{ src_path, @errorName(err) });
 

lib/std/Build/Watch.zig

@@ -56,7 +56,7 @@ const Os = switch (builtin.os.tag) {
                 const bytes = lfh.slice();
                 const new_ptr = try gpa.alignedAlloc(
                     u8,
-                    @alignOf(std.os.linux.file_handle),
+                    .of(std.os.linux.file_handle),
                     @sizeOf(std.os.linux.file_handle) + bytes.len,
                 );
                 const new_header: *std.os.linux.file_handle = @ptrCast(new_ptr);

lib/std/array_hash_map.zig

@@ -2129,7 +2129,7 @@ const IndexHeader = struct {
         const len = @as(usize, 1) << @as(math.Log2Int(usize), @intCast(new_bit_index));
         const index_size = hash_map.capacityIndexSize(new_bit_index);
         const nbytes = @sizeOf(IndexHeader) + index_size * len;
-        const bytes = try gpa.alignedAlloc(u8, @alignOf(IndexHeader), nbytes);
+        const bytes = try gpa.alignedAlloc(u8, .of(IndexHeader), nbytes);
         @memset(bytes[@sizeOf(IndexHeader)..], 0xff);
         const result: *IndexHeader = @alignCast(@ptrCast(bytes.ptr));
         result.* = .{

lib/std/array_list.zig

@@ -22,9 +22,9 @@ pub fn ArrayList(comptime T: type) type {
 ///
 /// This struct internally stores a `std.mem.Allocator` for memory management.
 /// To manually specify an allocator with each function call see `ArrayListAlignedUnmanaged`.
-pub fn ArrayListAligned(comptime T: type, comptime alignment: ?u29) type {
+pub fn ArrayListAligned(comptime T: type, comptime alignment: ?mem.Alignment) type {
     if (alignment) |a| {
-        if (a == @alignOf(T)) {
+        if (a.toByteUnits() == @alignOf(T)) {
             return ArrayListAligned(T, null);
         }
     }
@@ -43,10 +43,10 @@ pub fn ArrayListAligned(comptime T: type, comptime alignment: ?u29) type {
         capacity: usize,
         allocator: Allocator,
 
-        pub const Slice = if (alignment) |a| ([]align(a) T) else []T;
+        pub const Slice = if (alignment) |a| ([]align(a.toByteUnits()) T) else []T;
 
         pub fn SentinelSlice(comptime s: T) type {
-            return if (alignment) |a| ([:s]align(a) T) else [:s]T;
+            return if (alignment) |a| ([:s]align(a.toByteUnits()) T) else [:s]T;
         }
 
         /// Deinitialize with `deinit` or use `toOwnedSlice`.
@@ -611,9 +611,9 @@ pub fn ArrayListUnmanaged(comptime T: type) type {
 /// or use `toOwnedSlice`.
 ///
 /// Default initialization of this struct is deprecated; use `.empty` instead.
-pub fn ArrayListAlignedUnmanaged(comptime T: type, comptime alignment: ?u29) type {
+pub fn ArrayListAlignedUnmanaged(comptime T: type, comptime alignment: ?mem.Alignment) type {
     if (alignment) |a| {
-        if (a == @alignOf(T)) {
+        if (a.toByteUnits() == @alignOf(T)) {
             return ArrayListAlignedUnmanaged(T, null);
         }
     }
@@ -637,10 +637,10 @@ pub fn ArrayListAlignedUnmanaged(comptime T: type, comptime alignment: ?u29) typ
             .capacity = 0,
         };
 
-        pub const Slice = if (alignment) |a| ([]align(a) T) else []T;
+        pub const Slice = if (alignment) |a| ([]align(a.toByteUnits()) T) else []T;
 
         pub fn SentinelSlice(comptime s: T) type {
-            return if (alignment) |a| ([:s]align(a) T) else [:s]T;
+            return if (alignment) |a| ([:s]align(a.toByteUnits()) T) else [:s]T;
         }
 
         /// Initialize with capacity to hold `num` elements.
@@ -1913,7 +1913,7 @@ test "ArrayList(u8) implements writer" {
         try testing.expectEqualSlices(u8, "x: 42\ny: 1234\n", buffer.items);
     }
     {
-        var list = ArrayListAligned(u8, 2).init(a);
+        var list = ArrayListAligned(u8, .@"2").init(a);
         defer list.deinit();
 
         const writer = list.writer();
@@ -1940,7 +1940,7 @@ test "ArrayListUnmanaged(u8) implements writer" {
         try testing.expectEqualSlices(u8, "x: 42\ny: 1234\n", buffer.items);
     }
     {
-        var list: ArrayListAlignedUnmanaged(u8, 2) = .empty;
+        var list: ArrayListAlignedUnmanaged(u8, .@"2") = .empty;
         defer list.deinit(a);
 
         const writer = list.writer(a);
@@ -2126,7 +2126,7 @@ test "toOwnedSliceSentinel" {
 test "accepts unaligned slices" {
     const a = testing.allocator;
     {
-        var list = std.ArrayListAligned(u8, 8).init(a);
+        var list = std.ArrayListAligned(u8, .@"8").init(a);
         defer list.deinit();
 
         try list.appendSlice(&.{ 0, 1, 2, 3 });
@@ -2136,7 +2136,7 @@ test "accepts unaligned slices" {
         try testing.expectEqualSlices(u8, list.items, &.{ 0, 8, 9, 6, 7, 2, 3 });
     }
     {
-        var list: std.ArrayListAlignedUnmanaged(u8, 8) = .empty;
+        var list: std.ArrayListAlignedUnmanaged(u8, .@"8") = .empty;
         defer list.deinit(a);
 
         try list.appendSlice(a, &.{ 0, 1, 2, 3 });

lib/std/bounded_array.zig

@@ -2,6 +2,7 @@ const std = @import("std.zig");
 const assert = std.debug.assert;
 const mem = std.mem;
 const testing = std.testing;
+const Alignment = std.mem.Alignment;
 
 /// A structure with an array and a length, that can be used as a slice.
 ///
@@ -16,7 +17,7 @@ const testing = std.testing;
 /// var a_clone = a; // creates a copy - the structure doesn't use any internal pointers
 /// ```
 pub fn BoundedArray(comptime T: type, comptime buffer_capacity: usize) type {
-    return BoundedArrayAligned(T, @alignOf(T), buffer_capacity);
+    return BoundedArrayAligned(T, .of(T), buffer_capacity);
 }
 
 /// A structure with an array, length and alignment, that can be used as a
@@ -34,12 +35,12 @@ pub fn BoundedArray(comptime T: type, comptime buffer_capacity: usize) type {
 /// ```
 pub fn BoundedArrayAligned(
     comptime T: type,
-    comptime alignment: u29,
+    comptime alignment: Alignment,
     comptime buffer_capacity: usize,
 ) type {
     return struct {
         const Self = @This();
-        buffer: [buffer_capacity]T align(alignment) = undefined,
+        buffer: [buffer_capacity]T align(alignment.toByteUnits()) = undefined,
         len: usize = 0,
 
         /// Set the actual length of the slice.
@@ -51,15 +52,15 @@ pub fn BoundedArrayAligned(
 
         /// View the internal array as a slice whose size was previously set.
         pub fn slice(self: anytype) switch (@TypeOf(&self.buffer)) {
-            *align(alignment) [buffer_capacity]T => []align(alignment) T,
-            *align(alignment) const [buffer_capacity]T => []align(alignment) const T,
+            *align(alignment.toByteUnits()) [buffer_capacity]T => []align(alignment.toByteUnits()) T,
+            *align(alignment.toByteUnits()) const [buffer_capacity]T => []align(alignment.toByteUnits()) const T,
             else => unreachable,
         } {
             return self.buffer[0..self.len];
         }
 
         /// View the internal array as a constant slice whose size was previously set.
-        pub fn constSlice(self: *const Self) []align(alignment) const T {
+        pub fn constSlice(self: *const Self) []align(alignment.toByteUnits()) const T {
             return self.slice();
         }
 
@@ -120,15 +121,15 @@ pub fn BoundedArrayAligned(
 
         /// Resize the slice, adding `n` new elements, which have `undefined` values.
         /// The return value is a pointer to the array of uninitialized elements.
-        pub fn addManyAsArray(self: *Self, comptime n: usize) error{Overflow}!*align(alignment) [n]T {
+        pub fn addManyAsArray(self: *Self, comptime n: usize) error{Overflow}!*align(alignment.toByteUnits()) [n]T {
             const prev_len = self.len;
             try self.resize(self.len + n);
             return self.slice()[prev_len..][0..n];
         }
 
         /// Resize the slice, adding `n` new elements, which have `undefined` values.
         /// The return value is a slice pointing to the uninitialized elements.
-        pub fn addManyAsSlice(self: *Self, n: usize) error{Overflow}![]align(alignment) T {
+        pub fn addManyAsSlice(self: *Self, n: usize) error{Overflow}![]align(alignment.toByteUnits()) T {
             const prev_len = self.len;
             try self.resize(self.len + n);
             return self.slice()[prev_len..][0..n];
@@ -146,7 +147,7 @@ pub fn BoundedArrayAligned(
         /// This can be useful for writing directly into it.
         /// Note that such an operation must be followed up with a
         /// call to `resize()`
-        pub fn unusedCapacitySlice(self: *Self) []align(alignment) T {
+        pub fn unusedCapacitySlice(self: *Self) []align(alignment.toByteUnits()) T {
             return self.buffer[self.len..];
         }
 
@@ -399,7 +400,7 @@ test BoundedArray {
 }
 
 test "BoundedArrayAligned" {
-    var a = try BoundedArrayAligned(u8, 16, 4).init(0);
+    var a = try BoundedArrayAligned(u8, .@"16", 4).init(0);
     try a.append(0);
     try a.append(0);
     try a.append(255);

lib/std/crypto/argon2.zig

@@ -14,7 +14,7 @@ const pwhash = crypto.pwhash;
 
 const Thread = std.Thread;
 const Blake2b512 = blake2.Blake2b512;
-const Blocks = std.ArrayListAligned([block_length]u64, 16);
+const Blocks = std.ArrayListAligned([block_length]u64, .@"16");
 const H0 = [Blake2b512.digest_length + 8]u8;
 
 const EncodingError = crypto.errors.EncodingError;

lib/std/crypto/scrypt.zig

@@ -195,11 +195,11 @@ pub fn kdf(
         params.r > max_int / 256 or
         n > max_int / 128 / @as(u64, params.r)) return KdfError.WeakParameters;
 
-    const xy = try allocator.alignedAlloc(u32, 16, 64 * params.r);
+    const xy = try allocator.alignedAlloc(u32, .@"16", 64 * params.r);
     defer allocator.free(xy);
-    const v = try allocator.alignedAlloc(u32, 16, 32 * n * params.r);
+    const v = try allocator.alignedAlloc(u32, .@"16", 32 * n * params.r);
     defer allocator.free(v);
-    var dk = try allocator.alignedAlloc(u8, 16, params.p * 128 * params.r);
+    var dk = try allocator.alignedAlloc(u8, .@"16", params.p * 128 * params.r);
     defer allocator.free(dk);
 
     try pwhash.pbkdf2(dk, password, salt, 1, HmacSha256);