Merge pull request #21287 from linusg/deprecated-default-init

Replace deprecated default initializations with decl literals

28 files changed, 119 insertions, 119 deletions

diff --git a/lib/std/Build.zig b/lib/std/Build.zig
index 109ebc8be2..236ac16c47 100644
--- a/lib/std/Build.zig
+++ b/lib/std/Build.zig
@@ -111,7 +111,7 @@ pub const ReleaseMode = enum {
 /// Settings that are here rather than in Build are not configurable per-package.
 pub const Graph = struct {
     arena: Allocator,
-    system_library_options: std.StringArrayHashMapUnmanaged(SystemLibraryMode) = .{},
+    system_library_options: std.StringArrayHashMapUnmanaged(SystemLibraryMode) = .empty,
     system_package_mode: bool = false,
     debug_compiler_runtime_libs: bool = false,
     cache: Cache,
@@ -119,7 +119,7 @@ pub const Graph = struct {
     env_map: EnvMap,
     global_cache_root: Cache.Directory,
     zig_lib_directory: Cache.Directory,
-    needed_lazy_dependencies: std.StringArrayHashMapUnmanaged(void) = .{},
+    needed_lazy_dependencies: std.StringArrayHashMapUnmanaged(void) = .empty,
     /// Information about the native target. Computed before build() is invoked.
     host: ResolvedTarget,
     incremental: ?bool = null,
diff --git a/lib/std/Build/Fuzz.zig b/lib/std/Build/Fuzz.zig
index 6258f4cdda..6e837ebec2 100644
--- a/lib/std/Build/Fuzz.zig
+++ b/lib/std/Build/Fuzz.zig
@@ -30,7 +30,7 @@ pub fn start(
         defer rebuild_node.end();
         var wait_group: std.Thread.WaitGroup = .{};
         defer wait_group.wait();
-        var fuzz_run_steps: std.ArrayListUnmanaged(*Step.Run) = .{};
+        var fuzz_run_steps: std.ArrayListUnmanaged(*Step.Run) = .empty;
         defer fuzz_run_steps.deinit(gpa);
         for (all_steps) |step| {
             const run = step.cast(Step.Run) orelse continue;
diff --git a/lib/std/Build/Fuzz/WebServer.zig b/lib/std/Build/Fuzz/WebServer.zig
index fb78e96abb..ac4336476e 100644
--- a/lib/std/Build/Fuzz/WebServer.zig
+++ b/lib/std/Build/Fuzz/WebServer.zig
@@ -236,7 +236,7 @@ fn buildWasmBinary(
         .sub_path = "docs/wasm/html_render.zig",
     };
 
-    var argv: std.ArrayListUnmanaged([]const u8) = .{};
+    var argv: std.ArrayListUnmanaged([]const u8) = .empty;
 
     try argv.appendSlice(arena, &.{
         ws.zig_exe_path, "build-exe", //
diff --git a/lib/std/Build/Step.zig b/lib/std/Build/Step.zig
index b8fb42a959..421c8fa579 100644
--- a/lib/std/Build/Step.zig
+++ b/lib/std/Build/Step.zig
@@ -714,7 +714,7 @@ pub fn allocPrintCmd2(
     opt_env: ?*const std.process.EnvMap,
     argv: []const []const u8,
 ) Allocator.Error![]u8 {
-    var buf: std.ArrayListUnmanaged(u8) = .{};
+    var buf: std.ArrayListUnmanaged(u8) = .empty;
     if (opt_cwd) |cwd| try buf.writer(arena).print("cd {s} && ", .{cwd});
     if (opt_env) |env| {
         const process_env_map = std.process.getEnvMap(arena) catch std.process.EnvMap.init(arena);
diff --git a/lib/std/Build/Step/CheckObject.zig b/lib/std/Build/Step/CheckObject.zig
index ce33003117..54f7bc7412 100644
--- a/lib/std/Build/Step/CheckObject.zig
+++ b/lib/std/Build/Step/CheckObject.zig
@@ -713,12 +713,12 @@ const MachODumper = struct {
         gpa: Allocator,
         data: []const u8,
         header: macho.mach_header_64,
-        segments: std.ArrayListUnmanaged(macho.segment_command_64) = .{},
-        sections: std.ArrayListUnmanaged(macho.section_64) = .{},
-        symtab: std.ArrayListUnmanaged(macho.nlist_64) = .{},
-        strtab: std.ArrayListUnmanaged(u8) = .{},
-        indsymtab: std.ArrayListUnmanaged(u32) = .{},
-        imports: std.ArrayListUnmanaged([]const u8) = .{},
+        segments: std.ArrayListUnmanaged(macho.segment_command_64) = .empty,
+        sections: std.ArrayListUnmanaged(macho.section_64) = .empty,
+        symtab: std.ArrayListUnmanaged(macho.nlist_64) = .empty,
+        strtab: std.ArrayListUnmanaged(u8) = .empty,
+        indsymtab: std.ArrayListUnmanaged(u32) = .empty,
+        imports: std.ArrayListUnmanaged([]const u8) = .empty,
 
         fn parse(ctx: *ObjectContext) !void {
             var it = ctx.getLoadCommandIterator();
@@ -1797,9 +1797,9 @@ const ElfDumper = struct {
     const ArchiveContext = struct {
         gpa: Allocator,
         data: []const u8,
-        symtab: std.ArrayListUnmanaged(ArSymtabEntry) = .{},
+        symtab: std.ArrayListUnmanaged(ArSymtabEntry) = .empty,
         strtab: []const u8,
-        objects: std.ArrayListUnmanaged(struct { name: []const u8, off: usize, len: usize }) = .{},
+        objects: std.ArrayListUnmanaged(struct { name: []const u8, off: usize, len: usize }) = .empty,
 
         fn parseSymtab(ctx: *ArchiveContext, raw: []const u8, ptr_width: enum { p32, p64 }) !void {
             var stream = std.io.fixedBufferStream(raw);
diff --git a/lib/std/Build/Step/Compile.zig b/lib/std/Build/Step/Compile.zig
index 922d64c728..0f0b5d3201 100644
--- a/lib/std/Build/Step/Compile.zig
+++ b/lib/std/Build/Step/Compile.zig
@@ -1070,8 +1070,8 @@ fn getZigArgs(compile: *Compile, fuzz: bool) ![][]const u8 {
         // Stores system libraries that have already been seen for at least one
         // module, along with any arguments that need to be passed to the
         // compiler for each module individually.
-        var seen_system_libs: std.StringHashMapUnmanaged([]const []const u8) = .{};
-        var frameworks: std.StringArrayHashMapUnmanaged(Module.LinkFrameworkOptions) = .{};
+        var seen_system_libs: std.StringHashMapUnmanaged([]const []const u8) = .empty;
+        var frameworks: std.StringArrayHashMapUnmanaged(Module.LinkFrameworkOptions) = .empty;
 
         var prev_has_cflags = false;
         var prev_has_rcflags = false;
diff --git a/lib/std/Build/Step/Fmt.zig b/lib/std/Build/Step/Fmt.zig
index 576aeb1d21..a364dfa6f4 100644
--- a/lib/std/Build/Step/Fmt.zig
+++ b/lib/std/Build/Step/Fmt.zig
@@ -48,7 +48,7 @@ fn make(step: *Step, options: Step.MakeOptions) !void {
     const arena = b.allocator;
     const fmt: *Fmt = @fieldParentPtr("step", step);
 
-    var argv: std.ArrayListUnmanaged([]const u8) = .{};
+    var argv: std.ArrayListUnmanaged([]const u8) = .empty;
     try argv.ensureUnusedCapacity(arena, 2 + 1 + fmt.paths.len + 2 * fmt.exclude_paths.len);
 
     argv.appendAssumeCapacity(b.graph.zig_exe);
diff --git a/lib/std/Build/Step/Run.zig b/lib/std/Build/Step/Run.zig
index e37b97ddb3..c35ba00b79 100644
--- a/lib/std/Build/Step/Run.zig
+++ b/lib/std/Build/Step/Run.zig
@@ -856,7 +856,7 @@ pub fn rerunInFuzzMode(
     const step = &run.step;
     const b = step.owner;
     const arena = b.allocator;
-    var argv_list: std.ArrayListUnmanaged([]const u8) = .{};
+    var argv_list: std.ArrayListUnmanaged([]const u8) = .empty;
     for (run.argv.items) |arg| {
         switch (arg) {
             .bytes => |bytes| {
diff --git a/lib/std/array_hash_map.zig b/lib/std/array_hash_map.zig
index 1b96be472a..bf411b3798 100644
--- a/lib/std/array_hash_map.zig
+++ b/lib/std/array_hash_map.zig
@@ -130,7 +130,7 @@ pub fn ArrayHashMap(
         }
         pub fn initContext(allocator: Allocator, ctx: Context) Self {
             return .{
-                .unmanaged = .{},
+                .unmanaged = .empty,
                 .allocator = allocator,
                 .ctx = ctx,
             };
@@ -429,7 +429,7 @@ pub fn ArrayHashMap(
         pub fn move(self: *Self) Self {
             self.unmanaged.pointer_stability.assertUnlocked();
             const result = self.*;
-            self.unmanaged = .{};
+            self.unmanaged = .empty;
             return result;
         }
 
@@ -1290,7 +1290,7 @@ pub fn ArrayHashMapUnmanaged(
         pub fn move(self: *Self) Self {
             self.pointer_stability.assertUnlocked();
             const result = self.*;
-            self.* = .{};
+            self.* = .empty;
             return result;
         }
 
diff --git a/lib/std/array_list.zig b/lib/std/array_list.zig
index 24098a01f6..ac1b144690 100644
--- a/lib/std/array_list.zig
+++ b/lib/std/array_list.zig
@@ -710,7 +710,7 @@ pub fn ArrayListAlignedUnmanaged(comptime T: type, comptime alignment: ?u29) typ
             const old_memory = self.allocatedSlice();
             if (allocator.resize(old_memory, self.items.len)) {
                 const result = self.items;
-                self.* = .{};
+                self.* = .empty;
                 return result;
             }
 
@@ -1267,7 +1267,7 @@ test "init" {
     }
 
     {
-        const list = ArrayListUnmanaged(i32){};
+        const list: ArrayListUnmanaged(i32) = .empty;
 
         try testing.expect(list.items.len == 0);
         try testing.expect(list.capacity == 0);
@@ -1312,7 +1312,7 @@ test "clone" {
         try testing.expectEqual(@as(i32, 5), cloned.items[2]);
     }
     {
-        var array = ArrayListUnmanaged(i32){};
+        var array: ArrayListUnmanaged(i32) = .empty;
         try array.append(a, -1);
         try array.append(a, 3);
         try array.append(a, 5);
@@ -1384,7 +1384,7 @@ test "basic" {
         try testing.expect(list.pop() == 33);
     }
     {
-        var list = ArrayListUnmanaged(i32){};
+        var list: ArrayListUnmanaged(i32) = .empty;
         defer list.deinit(a);
 
         {
@@ -1448,7 +1448,7 @@ test "appendNTimes" {
         }
     }
     {
-        var list = ArrayListUnmanaged(i32){};
+        var list: ArrayListUnmanaged(i32) = .empty;
         defer list.deinit(a);
 
         try list.appendNTimes(a, 2, 10);
@@ -1467,7 +1467,7 @@ test "appendNTimes with failing allocator" {
         try testing.expectError(error.OutOfMemory, list.appendNTimes(2, 10));
     }
     {
-        var list = ArrayListUnmanaged(i32){};
+        var list: ArrayListUnmanaged(i32) = .empty;
         defer list.deinit(a);
         try testing.expectError(error.OutOfMemory, list.appendNTimes(a, 2, 10));
     }
@@ -1502,7 +1502,7 @@ test "orderedRemove" {
         try testing.expectEqual(@as(usize, 4), list.items.len);
     }
     {
-        var list = ArrayListUnmanaged(i32){};
+        var list: ArrayListUnmanaged(i32) = .empty;
         defer list.deinit(a);
 
         try list.append(a, 1);
@@ -1537,7 +1537,7 @@ test "orderedRemove" {
     }
     {
         // remove last item
-        var list = ArrayListUnmanaged(i32){};
+        var list: ArrayListUnmanaged(i32) = .empty;
         defer list.deinit(a);
         try list.append(a, 1);
         try testing.expectEqual(@as(i32, 1), list.orderedRemove(0));
@@ -1574,7 +1574,7 @@ test "swapRemove" {
         try testing.expect(list.items.len == 4);
     }
     {
-        var list = ArrayListUnmanaged(i32){};
+        var list: ArrayListUnmanaged(i32) = .empty;
         defer list.deinit(a);
 
         try list.append(a, 1);
@@ -1617,7 +1617,7 @@ test "insert" {
         try testing.expect(list.items[3] == 3);
     }
     {
-        var list = ArrayListUnmanaged(i32){};
+        var list: ArrayListUnmanaged(i32) = .empty;
         defer list.deinit(a);
 
         try list.insert(a, 0, 1);
@@ -1655,7 +1655,7 @@ test "insertSlice" {
         try testing.expect(list.items[0] == 1);
     }
     {
-        var list = ArrayListUnmanaged(i32){};
+        var list: ArrayListUnmanaged(i32) = .empty;
         defer list.deinit(a);
 
         try list.append(a, 1);
@@ -1789,7 +1789,7 @@ test "ArrayListUnmanaged.replaceRange" {
     const a = testing.allocator;
 
     {
-        var list = ArrayListUnmanaged(i32){};
+        var list: ArrayListUnmanaged(i32) = .empty;
         defer list.deinit(a);
         try list.appendSlice(a, &[_]i32{ 1, 2, 3, 4, 5 });
 
@@ -1798,7 +1798,7 @@ test "ArrayListUnmanaged.replaceRange" {
         try testing.expectEqualSlices(i32, &[_]i32{ 1, 0, 0, 0, 2, 3, 4, 5 }, list.items);
     }
     {
-        var list = ArrayListUnmanaged(i32){};
+        var list: ArrayListUnmanaged(i32) = .empty;
         defer list.deinit(a);
         try list.appendSlice(a, &[_]i32{ 1, 2, 3, 4, 5 });
 
@@ -1811,7 +1811,7 @@ test "ArrayListUnmanaged.replaceRange" {
         );
     }
     {
-        var list = ArrayListUnmanaged(i32){};
+        var list: ArrayListUnmanaged(i32) = .empty;
         defer list.deinit(a);
         try list.appendSlice(a, &[_]i32{ 1, 2, 3, 4, 5 });
 
@@ -1820,7 +1820,7 @@ test "ArrayListUnmanaged.replaceRange" {
         try testing.expectEqualSlices(i32, &[_]i32{ 1, 0, 0, 0, 4, 5 }, list.items);
     }
     {
-        var list = ArrayListUnmanaged(i32){};
+        var list: ArrayListUnmanaged(i32) = .empty;
         defer list.deinit(a);
         try list.appendSlice(a, &[_]i32{ 1, 2, 3, 4, 5 });
 
@@ -1829,7 +1829,7 @@ test "ArrayListUnmanaged.replaceRange" {
         try testing.expectEqualSlices(i32, &[_]i32{ 1, 0, 0, 0, 5 }, list.items);
     }
     {
-        var list = ArrayListUnmanaged(i32){};
+        var list: ArrayListUnmanaged(i32) = .empty;
         defer list.deinit(a);
         try list.appendSlice(a, &[_]i32{ 1, 2, 3, 4, 5 });
 
@@ -1843,7 +1843,7 @@ test "ArrayListUnmanaged.replaceRangeAssumeCapacity" {
     const a = testing.allocator;
 
     {
-        var list = ArrayListUnmanaged(i32){};
+        var list: ArrayListUnmanaged(i32) = .empty;
         defer list.deinit(a);
         try list.appendSlice(a, &[_]i32{ 1, 2, 3, 4, 5 });
 
@@ -1852,7 +1852,7 @@ test "ArrayListUnmanaged.replaceRangeAssumeCapacity" {
         try testing.expectEqualSlices(i32, &[_]i32{ 1, 0, 0, 0, 2, 3, 4, 5 }, list.items);
     }
     {
-        var list = ArrayListUnmanaged(i32){};
+        var list: ArrayListUnmanaged(i32) = .empty;
         defer list.deinit(a);
         try list.appendSlice(a, &[_]i32{ 1, 2, 3, 4, 5 });
 
@@ -1865,7 +1865,7 @@ test "ArrayListUnmanaged.replaceRangeAssumeCapacity" {
         );
     }
     {
-        var list = ArrayListUnmanaged(i32){};
+        var list: ArrayListUnmanaged(i32) = .empty;
         defer list.deinit(a);
         try list.appendSlice(a, &[_]i32{ 1, 2, 3, 4, 5 });
 
@@ -1874,7 +1874,7 @@ test "ArrayListUnmanaged.replaceRangeAssumeCapacity" {
         try testing.expectEqualSlices(i32, &[_]i32{ 1, 0, 0, 0, 4, 5 }, list.items);
     }
     {
-        var list = ArrayListUnmanaged(i32){};
+        var list: ArrayListUnmanaged(i32) = .empty;
         defer list.deinit(a);
         try list.appendSlice(a, &[_]i32{ 1, 2, 3, 4, 5 });
 
@@ -1883,7 +1883,7 @@ test "ArrayListUnmanaged.replaceRangeAssumeCapacity" {
         try testing.expectEqualSlices(i32, &[_]i32{ 1, 0, 0, 0, 5 }, list.items);
     }
     {
-        var list = ArrayListUnmanaged(i32){};
+        var list: ArrayListUnmanaged(i32) = .empty;
         defer list.deinit(a);
         try list.appendSlice(a, &[_]i32{ 1, 2, 3, 4, 5 });
 
@@ -1906,15 +1906,15 @@ const ItemUnmanaged = struct {
 test "ArrayList(T) of struct T" {
     const a = std.testing.allocator;
     {
-        var root = Item{ .integer = 1, .sub_items = ArrayList(Item).init(a) };
+        var root = Item{ .integer = 1, .sub_items = .init(a) };
         defer root.sub_items.deinit();
-        try root.sub_items.append(Item{ .integer = 42, .sub_items = ArrayList(Item).init(a) });
+        try root.sub_items.append(Item{ .integer = 42, .sub_items = .init(a) });
         try testing.expect(root.sub_items.items[0].integer == 42);
     }
     {
-        var root = ItemUnmanaged{ .integer = 1, .sub_items = ArrayListUnmanaged(ItemUnmanaged){} };
+        var root = ItemUnmanaged{ .integer = 1, .sub_items = .empty };
         defer root.sub_items.deinit(a);
-        try root.sub_items.append(a, ItemUnmanaged{ .integer = 42, .sub_items = ArrayListUnmanaged(ItemUnmanaged){} });
+        try root.sub_items.append(a, ItemUnmanaged{ .integer = 42, .sub_items = .empty });
         try testing.expect(root.sub_items.items[0].integer == 42);
     }
 }
@@ -1950,7 +1950,7 @@ test "ArrayListUnmanaged(u8) implements writer" {
     const a = testing.allocator;
 
     {
-        var buffer: ArrayListUnmanaged(u8) = .{};
+        var buffer: ArrayListUnmanaged(u8) = .empty;
         defer buffer.deinit(a);
 
         const x: i32 = 42;
@@ -1960,7 +1960,7 @@ test "ArrayListUnmanaged(u8) implements writer" {
         try testing.expectEqualSlices(u8, "x: 42\ny: 1234\n", buffer.items);
     }
     {
-        var list: ArrayListAlignedUnmanaged(u8, 2) = .{};
+        var list: ArrayListAlignedUnmanaged(u8, 2) = .empty;
         defer list.deinit(a);
 
         const writer = list.writer(a);
@@ -1989,7 +1989,7 @@ test "shrink still sets length when resizing is disabled" {
         try testing.expect(list.items.len == 1);
     }
     {
-        var list = ArrayListUnmanaged(i32){};
+        var list: ArrayListUnmanaged(i32) = .empty;
         defer list.deinit(a);
 
         try list.append(a, 1);
@@ -2026,7 +2026,7 @@ test "addManyAsArray" {
         try testing.expectEqualSlices(u8, list.items, "aoeuasdf");
     }
     {
-        var list = ArrayListUnmanaged(u8){};
+        var list: ArrayListUnmanaged(u8) = .empty;
         defer list.deinit(a);
 
         (try list.addManyAsArray(a, 4)).* = "aoeu".*;
@@ -2056,7 +2056,7 @@ test "growing memory preserves contents" {
         try testing.expectEqualSlices(u8, list.items, "abcdijklefgh");
     }
     {
-        var list = ArrayListUnmanaged(u8){};
+        var list: ArrayListUnmanaged(u8) = .empty;
         defer list.deinit(a);
 
         (try list.addManyAsArray(a, 4)).* = "abcd".*;
@@ -2132,7 +2132,7 @@ test "toOwnedSliceSentinel" {
         try testing.expectEqualStrings(result, mem.sliceTo(result.ptr, 0));
     }
     {
-        var list = ArrayListUnmanaged(u8){};
+        var list: ArrayListUnmanaged(u8) = .empty;
         defer list.deinit(a);
 
         try list.appendSlice(a, "foobar");
@@ -2156,7 +2156,7 @@ test "accepts unaligned slices" {
         try testing.expectEqualSlices(u8, list.items, &.{ 0, 8, 9, 6, 7, 2, 3 });
     }
     {
-        var list = std.ArrayListAlignedUnmanaged(u8, 8){};
+        var list: std.ArrayListAlignedUnmanaged(u8, 8) = .empty;
         defer list.deinit(a);
 
         try list.appendSlice(a, &.{ 0, 1, 2, 3 });
diff --git a/lib/std/crypto/Certificate/Bundle.zig b/lib/std/crypto/Certificate/Bundle.zig
index 92a6d43ac6..627cd4172b 100644
--- a/lib/std/crypto/Certificate/Bundle.zig
+++ b/lib/std/crypto/Certificate/Bundle.zig
@@ -6,8 +6,8 @@
 //! certificate within `bytes`.
 
 /// The key is the contents slice of the subject.
-map: std.HashMapUnmanaged(der.Element.Slice, u32, MapContext, std.hash_map.default_max_load_percentage) = .{},
-bytes: std.ArrayListUnmanaged(u8) = .{},
+map: std.HashMapUnmanaged(der.Element.Slice, u32, MapContext, std.hash_map.default_max_load_percentage) = .empty,
+bytes: std.ArrayListUnmanaged(u8) = .empty,
 
 pub const VerifyError = Certificate.Parsed.VerifyError || error{
     CertificateIssuerNotFound,
diff --git a/lib/std/debug/Dwarf.zig b/lib/std/debug/Dwarf.zig
index 1bc47a3e38..d36e4f961d 100644
--- a/lib/std/debug/Dwarf.zig
+++ b/lib/std/debug/Dwarf.zig
@@ -42,20 +42,20 @@ sections: SectionArray = null_section_array,
 is_macho: bool,
 
 /// Filled later by the initializer
-abbrev_table_list: std.ArrayListUnmanaged(Abbrev.Table) = .{},
+abbrev_table_list: std.ArrayListUnmanaged(Abbrev.Table) = .empty,
 /// Filled later by the initializer
-compile_unit_list: std.ArrayListUnmanaged(CompileUnit) = .{},
+compile_unit_list: std.ArrayListUnmanaged(CompileUnit) = .empty,
 /// Filled later by the initializer
-func_list: std.ArrayListUnmanaged(Func) = .{},
+func_list: std.ArrayListUnmanaged(Func) = .empty,
 
 eh_frame_hdr: ?ExceptionFrameHeader = null,
 /// These lookup tables are only used if `eh_frame_hdr` is null
-cie_map: std.AutoArrayHashMapUnmanaged(u64, CommonInformationEntry) = .{},
+cie_map: std.AutoArrayHashMapUnmanaged(u64, CommonInformationEntry) = .empty,
 /// Sorted by start_pc
-fde_list: std.ArrayListUnmanaged(FrameDescriptionEntry) = .{},
+fde_list: std.ArrayListUnmanaged(FrameDescriptionEntry) = .empty,
 
 /// Populated by `populateRanges`.
-ranges: std.ArrayListUnmanaged(Range) = .{},
+ranges: std.ArrayListUnmanaged(Range) = .empty,
 
 pub const Range = struct {
     start: u64,
@@ -1464,9 +1464,9 @@ fn runLineNumberProgram(d: *Dwarf, gpa: Allocator, compile_unit: *CompileUnit) !
 
     const standard_opcode_lengths = try fbr.readBytes(opcode_base - 1);
 
-    var directories: std.ArrayListUnmanaged(FileEntry) = .{};
+    var directories: std.ArrayListUnmanaged(FileEntry) = .empty;
     defer directories.deinit(gpa);
-    var file_entries: std.ArrayListUnmanaged(FileEntry) = .{};
+    var file_entries: std.ArrayListUnmanaged(FileEntry) = .empty;
     defer file_entries.deinit(gpa);
 
     if (version < 5) {
diff --git a/lib/std/debug/Dwarf/expression.zig b/lib/std/debug/Dwarf/expression.zig
index f71a4e02c1..38bce2614c 100644
--- a/lib/std/debug/Dwarf/expression.zig
+++ b/lib/std/debug/Dwarf/expression.zig
@@ -153,7 +153,7 @@ pub fn StackMachine(comptime options: Options) type {
             }
         };
 
-        stack: std.ArrayListUnmanaged(Value) = .{},
+        stack: std.ArrayListUnmanaged(Value) = .empty,
 
         pub fn reset(self: *Self) void {
             self.stack.clearRetainingCapacity();
diff --git a/lib/std/debug/SelfInfo.zig b/lib/std/debug/SelfInfo.zig
index 5e7aefef38..76c0505e96 100644
--- a/lib/std/debug/SelfInfo.zig
+++ b/lib/std/debug/SelfInfo.zig
@@ -1933,8 +1933,8 @@ pub const VirtualMachine = struct {
         len: u8 = 0,
     };
 
-    columns: std.ArrayListUnmanaged(Column) = .{},
-    stack: std.ArrayListUnmanaged(ColumnRange) = .{},
+    columns: std.ArrayListUnmanaged(Column) = .empty,
+    stack: std.ArrayListUnmanaged(ColumnRange) = .empty,
     current_row: Row = .{},
 
     /// The result of executing the CIE's initial_instructions
diff --git a/lib/std/fs/Dir.zig b/lib/std/fs/Dir.zig
index d4ea8a0109..2e84d1097f 100644
--- a/lib/std/fs/Dir.zig
+++ b/lib/std/fs/Dir.zig
@@ -750,7 +750,7 @@ pub const Walker = struct {
 ///
 /// `self` will not be closed after walking it.
 pub fn walk(self: Dir, allocator: Allocator) Allocator.Error!Walker {
-    var stack: std.ArrayListUnmanaged(Walker.StackItem) = .{};
+    var stack: std.ArrayListUnmanaged(Walker.StackItem) = .empty;
 
     try stack.append(allocator, .{
         .iter = self.iterate(),
diff --git a/lib/std/fs/wasi.zig b/lib/std/fs/wasi.zig
index 040dd4ca3e..5d729c9da1 100644
--- a/lib/std/fs/wasi.zig
+++ b/lib/std/fs/wasi.zig
@@ -24,7 +24,7 @@ pub const Preopens = struct {
 };
 
 pub fn preopensAlloc(gpa: Allocator) Allocator.Error!Preopens {
-    var names: std.ArrayListUnmanaged([]const u8) = .{};
+    var names: std.ArrayListUnmanaged([]const u8) = .empty;
     defer names.deinit(gpa);
 
     try names.ensureUnusedCapacity(gpa, 3);
diff --git a/lib/std/hash/benchmark.zig b/lib/std/hash/benchmark.zig
index 0798e26d6f..0a73be39ce 100644
--- a/lib/std/hash/benchmark.zig
+++ b/lib/std/hash/benchmark.zig
@@ -410,7 +410,7 @@ pub fn main() !void {
         }
     }
 
-    var gpa = std.heap.GeneralPurposeAllocator(.{}){};
+    var gpa: std.heap.GeneralPurposeAllocator(.{}) = .init;
     defer std.testing.expect(gpa.deinit() == .ok) catch @panic("leak");
     const allocator = gpa.allocator();
 
diff --git a/lib/std/hash_map.zig b/lib/std/hash_map.zig
index 54b85e4b3d..9c436320b7 100644
--- a/lib/std/hash_map.zig
+++ b/lib/std/hash_map.zig
@@ -401,7 +401,7 @@ pub fn HashMap(
                 @compileError("Context must be specified! Call initContext(allocator, ctx) instead.");
             }
             return .{
-                .unmanaged = .{},
+                .unmanaged = .empty,
                 .allocator = allocator,
                 .ctx = undefined, // ctx is zero-sized so this is safe.
             };
@@ -410,7 +410,7 @@ pub fn HashMap(
         /// Create a managed hash map with a context
         pub fn initContext(allocator: Allocator, ctx: Context) Self {
             return .{
-                .unmanaged = .{},
+                .unmanaged = .empty,
                 .allocator = allocator,
                 .ctx = ctx,
             };
@@ -691,7 +691,7 @@ pub fn HashMap(
         pub fn move(self: *Self) Self {
             self.unmanaged.pointer_stability.assertUnlocked();
             const result = self.*;
-            self.unmanaged = .{};
+            self.unmanaged = .empty;
             return result;
         }
 
@@ -1543,7 +1543,7 @@ pub fn HashMapUnmanaged(
             return self.cloneContext(allocator, @as(Context, undefined));
         }
         pub fn cloneContext(self: Self, allocator: Allocator, new_ctx: anytype) Allocator.Error!HashMapUnmanaged(K, V, @TypeOf(new_ctx), max_load_percentage) {
-            var other = HashMapUnmanaged(K, V, @TypeOf(new_ctx), max_load_percentage){};
+            var other: HashMapUnmanaged(K, V, @TypeOf(new_ctx), max_load_percentage) = .empty;
             if (self.size == 0)
                 return other;
 
@@ -1572,7 +1572,7 @@ pub fn HashMapUnmanaged(
         pub fn move(self: *Self) Self {
             self.pointer_stability.assertUnlocked();
             const result = self.*;
-            self.* = .{};
+            self.* = .empty;
             return result;
         }
 
@@ -2360,7 +2360,7 @@ test "removeByPtr 0 sized key" {
 }
 
 test "repeat fetchRemove" {
-    var map = AutoHashMapUnmanaged(u64, void){};
+    var map: AutoHashMapUnmanaged(u64, void) = .empty;
     defer map.deinit(testing.allocator);
 
     try map.ensureTotalCapacity(testing.allocator, 4);
@@ -2384,7 +2384,7 @@ test "repeat fetchRemove" {
 }
 
 test "getOrPut allocation failure" {
-    var map: std.StringHashMapUnmanaged(void) = .{};
+    var map: std.StringHashMapUnmanaged(void) = .empty;
     try testing.expectError(error.OutOfMemory, map.getOrPut(std.testing.failing_allocator, "hello"));
 }
 
diff --git a/lib/std/json/hashmap.zig b/lib/std/json/hashmap.zig
index b40fb5e4c7..be4e9bd2dd 100644
--- a/lib/std/json/hashmap.zig
+++ b/lib/std/json/hashmap.zig
@@ -12,14 +12,14 @@ const Value = @import("dynamic.zig").Value;
 /// instead of comptime-known struct field names.
 pub fn ArrayHashMap(comptime T: type) type {
     return struct {
-        map: std.StringArrayHashMapUnmanaged(T) = .{},
+        map: std.StringArrayHashMapUnmanaged(T) = .empty,
 
         pub fn deinit(self: *@This(), allocator: Allocator) void {
             self.map.deinit(allocator);
         }
 
         pub fn jsonParse(allocator: Allocator, source: anytype, options: ParseOptions) !@This() {
-            var map = std.StringArrayHashMapUnmanaged(T){};
+            var map: std.StringArrayHashMapUnmanaged(T) = .empty;
             errdefer map.deinit(allocator);
 
             if (.object_begin != try source.next()) return error.UnexpectedToken;
@@ -52,7 +52,7 @@ pub fn ArrayHashMap(comptime T: type) type {
         pub fn jsonParseFromValue(allocator: Allocator, source: Value, options: ParseOptions) !@This() {
             if (source != .object) return error.UnexpectedToken;
 
-            var map = std.StringArrayHashMapUnmanaged(T){};
+            var map: std.StringArrayHashMapUnmanaged(T) = .empty;
             errdefer map.deinit(allocator);
 
             var it = source.object.iterator();
diff --git a/lib/std/process/Child.zig b/lib/std/process/Child.zig
index 2002bad20e..3a54ede2ad 100644
--- a/lib/std/process/Child.zig
+++ b/lib/std/process/Child.zig
@@ -907,12 +907,12 @@ fn spawnWindows(self: *ChildProcess) SpawnError!void {
         var cmd_line_cache = WindowsCommandLineCache.init(self.allocator, self.argv);
         defer cmd_line_cache.deinit();
 
-        var app_buf = std.ArrayListUnmanaged(u16){};
+        var app_buf: std.ArrayListUnmanaged(u16) = .empty;
         defer app_buf.deinit(self.allocator);
 
         try app_buf.appendSlice(self.allocator, app_name_w);
 
-        var dir_buf = std.ArrayListUnmanaged(u16){};
+        var dir_buf: std.ArrayListUnmanaged(u16) = .empty;
         defer dir_buf.deinit(self.allocator);
 
         if (cwd_path_w.len > 0) {
diff --git a/lib/std/tar.zig b/lib/std/tar.zig
index 491d11af2a..f15a5e8c8a 100644
--- a/lib/std/tar.zig
+++ b/lib/std/tar.zig
@@ -27,7 +27,7 @@ pub const writer = @import("tar/writer.zig").writer;
 /// the errors in diagnostics to know whether the operation succeeded or failed.
 pub const Diagnostics = struct {
     allocator: std.mem.Allocator,
-    errors: std.ArrayListUnmanaged(Error) = .{},
+    errors: std.ArrayListUnmanaged(Error) = .empty,
 
     entries: usize = 0,
     root_dir: []const u8 = "",
diff --git a/lib/std/testing.zig b/lib/std/testing.zig
index 2cc38749eb..91caa7d922 100644
--- a/lib/std/testing.zig
+++ b/lib/std/testing.zig
@@ -11,10 +11,10 @@ pub const FailingAllocator = @import("testing/failing_allocator.zig").FailingAll
 
 /// This should only be used in temporary test programs.
 pub const allocator = allocator_instance.allocator();
-pub var allocator_instance = b: {
+pub var allocator_instance: std.heap.GeneralPurposeAllocator(.{}) = b: {
     if (!builtin.is_test)
         @compileError("Cannot use testing allocator outside of test block");
-    break :b std.heap.GeneralPurposeAllocator(.{}){};
+    break :b .init;
 };
 
 pub const failing_allocator = failing_allocator_instance.allocator();
diff --git a/lib/std/zig/AstGen.zig b/lib/std/zig/AstGen.zig
index 675fe095a2..79ab85f6db 100644
--- a/lib/std/zig/AstGen.zig
+++ b/lib/std/zig/AstGen.zig
@@ -22,8 +22,8 @@ tree: *const Ast,
 /// sub-expressions. See `AstRlAnnotate` for details.
 nodes_need_rl: *const AstRlAnnotate.RlNeededSet,
 instructions: std.MultiArrayList(Zir.Inst) = .{},
-extra: ArrayListUnmanaged(u32) = .{},
-string_bytes: ArrayListUnmanaged(u8) = .{},
+extra: ArrayListUnmanaged(u32) = .empty,
+string_bytes: ArrayListUnmanaged(u8) = .empty,
 /// Tracks the current byte offset within the source file.
 /// Used to populate line deltas in the ZIR. AstGen maintains
 /// this "cursor" throughout the entire AST lowering process in order
@@ -39,8 +39,8 @@ source_column: u32 = 0,
 /// Used for temporary allocations; freed after AstGen is complete.
 /// The resulting ZIR code has no references to anything in this arena.
 arena: Allocator,
-string_table: std.HashMapUnmanaged(u32, void, StringIndexContext, std.hash_map.default_max_load_percentage) = .{},
-compile_errors: ArrayListUnmanaged(Zir.Inst.CompileErrors.Item) = .{},
+string_table: std.HashMapUnmanaged(u32, void, StringIndexContext, std.hash_map.default_max_load_percentage) = .empty,
+compile_errors: ArrayListUnmanaged(Zir.Inst.CompileErrors.Item) = .empty,
 /// The topmost block of the current function.
 fn_block: ?*GenZir = null,
 fn_var_args: bool = false,
@@ -52,9 +52,9 @@ within_fn: bool = false,
 fn_ret_ty: Zir.Inst.Ref = .none,
 /// Maps string table indexes to the first `@import` ZIR instruction
 /// that uses this string as the operand.
-imports: std.AutoArrayHashMapUnmanaged(Zir.NullTerminatedString, Ast.TokenIndex) = .{},
+imports: std.AutoArrayHashMapUnmanaged(Zir.NullTerminatedString, Ast.TokenIndex) = .empty,
 /// Used for temporary storage when building payloads.
-scratch: std.ArrayListUnmanaged(u32) = .{},
+scratch: std.ArrayListUnmanaged(u32) = .empty,
 /// Whenever a `ref` instruction is needed, it is created and saved in this
 /// table instead of being immediately appended to the current block body.
 /// Then, when the instruction is being added to the parent block (typically from
@@ -65,7 +65,7 @@ scratch: std.ArrayListUnmanaged(u32) = .{},
 /// 2. `ref` instructions will dominate their uses. This is a required property
 ///    of ZIR.
 /// The key is the ref operand; the value is the ref instruction.
-ref_table: std.AutoHashMapUnmanaged(Zir.Inst.Index, Zir.Inst.Index) = .{},
+ref_table: std.AutoHashMapUnmanaged(Zir.Inst.Index, Zir.Inst.Index) = .empty,
 /// Any information which should trigger invalidation of incremental compilation
 /// data should be used to update this hasher. The result is the final source
 /// hash of the enclosing declaration/etc.
@@ -159,7 +159,7 @@ pub fn generate(gpa: Allocator, tree: Ast) Allocator.Error!Zir {
 
     var top_scope: Scope.Top = .{};
 
-    var gz_instructions: std.ArrayListUnmanaged(Zir.Inst.Index) = .{};
+    var gz_instructions: std.ArrayListUnmanaged(Zir.Inst.Index) = .empty;
     var gen_scope: GenZir = .{
         .is_comptime = true,
         .parent = &top_scope.base,
@@ -5854,7 +5854,7 @@ fn errorSetDecl(gz: *GenZir, ri: ResultInfo, node: Ast.Node.Index) InnerError!Zi
     const payload_index = try reserveExtra(astgen, @typeInfo(Zir.Inst.ErrorSetDecl).@"struct".fields.len);
     var fields_len: usize = 0;
     {
-        var idents: std.AutoHashMapUnmanaged(Zir.NullTerminatedString, Ast.TokenIndex) = .{};
+        var idents: std.AutoHashMapUnmanaged(Zir.NullTerminatedString, Ast.TokenIndex) = .empty;
         defer idents.deinit(gpa);
 
         const error_token = main_tokens[node];
@@ -11259,7 +11259,7 @@ fn identifierTokenString(astgen: *AstGen, token: Ast.TokenIndex) InnerError![]co
     if (!mem.startsWith(u8, ident_name, "@")) {
         return ident_name;
     }
-    var buf: ArrayListUnmanaged(u8) = .{};
+    var buf: ArrayListUnmanaged(u8) = .empty;
     defer buf.deinit(astgen.gpa);
     try astgen.parseStrLit(token, &buf, ident_name, 1);
     if (mem.indexOfScalar(u8, buf.items, 0) != null) {
@@ -11881,7 +11881,7 @@ const Scope = struct {
         parent: *Scope,
         /// Maps string table index to the source location of declaration,
         /// for the purposes of reporting name shadowing compile errors.
-        decls: std.AutoHashMapUnmanaged(Zir.NullTerminatedString, Ast.Node.Index) = .{},
+        decls: std.AutoHashMapUnmanaged(Zir.NullTerminatedString, Ast.Node.Index) = .empty,
         node: Ast.Node.Index,
         inst: Zir.Inst.Index,
         maybe_generic: bool,
@@ -11891,7 +11891,7 @@ const Scope = struct {
         declaring_gz: ?*GenZir,
 
         /// Set of captures used by this namespace.
-        captures: std.AutoArrayHashMapUnmanaged(Zir.Inst.Capture, void) = .{},
+        captures: std.AutoArrayHashMapUnmanaged(Zir.Inst.Capture, void) = .empty,
 
         fn deinit(self: *Namespace, gpa: Allocator) void {
             self.decls.deinit(gpa);
@@ -13607,9 +13607,9 @@ fn scanContainer(
     var sfba_state = std.heap.stackFallback(512, astgen.gpa);
     const sfba = sfba_state.get();
 
-    var names: std.AutoArrayHashMapUnmanaged(Zir.NullTerminatedString, NameEntry) = .{};
-    var test_names: std.AutoArrayHashMapUnmanaged(Zir.NullTerminatedString, NameEntry) = .{};
-    var decltest_names: std.AutoArrayHashMapUnmanaged(Zir.NullTerminatedString, NameEntry) = .{};
+    var names: std.AutoArrayHashMapUnmanaged(Zir.NullTerminatedString, NameEntry) = .empty;
+    var test_names: std.AutoArrayHashMapUnmanaged(Zir.NullTerminatedString, NameEntry) = .empty;
+    var decltest_names: std.AutoArrayHashMapUnmanaged(Zir.NullTerminatedString, NameEntry) = .empty;
     defer {
         names.deinit(sfba);
         test_names.deinit(sfba);
@@ -13796,7 +13796,7 @@ fn scanContainer(
 
     for (names.keys(), names.values()) |name, first| {
         if (first.next == null) continue;
-        var notes: std.ArrayListUnmanaged(u32) = .{};
+        var notes: std.ArrayListUnmanaged(u32) = .empty;
         var prev: NameEntry = first;
         while (prev.next) |cur| : (prev = cur.*) {
             try notes.append(astgen.arena, try astgen.errNoteTok(cur.tok, "duplicate name here", .{}));
@@ -13808,7 +13808,7 @@ fn scanContainer(
 
     for (test_names.keys(), test_names.values()) |name, first| {
         if (first.next == null) continue;
-        var notes: std.ArrayListUnmanaged(u32) = .{};
+        var notes: std.ArrayListUnmanaged(u32) = .empty;
         var prev: NameEntry = first;
         while (prev.next) |cur| : (prev = cur.*) {
             try notes.append(astgen.arena, try astgen.errNoteTok(cur.tok, "duplicate test here", .{}));
@@ -13820,7 +13820,7 @@ fn scanContainer(
 
     for (decltest_names.keys(), decltest_names.values()) |name, first| {
         if (first.next == null) continue;
-        var notes: std.ArrayListUnmanaged(u32) = .{};
+        var notes: std.ArrayListUnmanaged(u32) = .empty;
         var prev: NameEntry = first;
         while (prev.next) |cur| : (prev = cur.*) {
             try notes.append(astgen.arena, try astgen.errNoteTok(cur.tok, "duplicate decltest here", .{}));
@@ -13949,10 +13949,10 @@ fn lowerAstErrors(astgen: *AstGen) !void {
     const gpa = astgen.gpa;
     const parse_err = tree.errors[0];
 
-    var msg: std.ArrayListUnmanaged(u8) = .{};
+    var msg: std.ArrayListUnmanaged(u8) = .empty;
     defer msg.deinit(gpa);
 
-    var notes: std.ArrayListUnmanaged(u32) = .{};
+    var notes: std.ArrayListUnmanaged(u32) = .empty;
     defer notes.deinit(gpa);
 
     for (tree.errors[1..]) |note| {
diff --git a/lib/std/zig/ErrorBundle.zig b/lib/std/zig/ErrorBundle.zig
index 63e0748d8d..3f3c7ff9e3 100644
--- a/lib/std/zig/ErrorBundle.zig
+++ b/lib/std/zig/ErrorBundle.zig
@@ -571,7 +571,7 @@ pub const Wip = struct {
         if (index == .none) return .none;
         const other_sl = other.getSourceLocation(index);
 
-        var ref_traces: std.ArrayListUnmanaged(ReferenceTrace) = .{};
+        var ref_traces: std.ArrayListUnmanaged(ReferenceTrace) = .empty;
         defer ref_traces.deinit(wip.gpa);
 
         if (other_sl.reference_trace_len > 0) {
diff --git a/lib/std/zig/WindowsSdk.zig b/lib/std/zig/WindowsSdk.zig
index 1e1f0f1629..8fe37affc0 100644
--- a/lib/std/zig/WindowsSdk.zig
+++ b/lib/std/zig/WindowsSdk.zig
@@ -751,7 +751,7 @@ const MsvcLibDir = struct {
         defer instances_dir.close();
 
         var state_subpath_buf: [std.fs.max_name_bytes + 32]u8 = undefined;
-        var latest_version_lib_dir = std.ArrayListUnmanaged(u8){};
+        var latest_version_lib_dir: std.ArrayListUnmanaged(u8) = .empty;
         errdefer latest_version_lib_dir.deinit(allocator);
 
         var latest_version: u64 = 0;
diff --git a/lib/std/zig/Zir.zig b/lib/std/zig/Zir.zig
index a918bb769c..8f86dabb5d 100644
--- a/lib/std/zig/Zir.zig
+++ b/lib/std/zig/Zir.zig
@@ -3711,7 +3711,7 @@ pub fn findDecls(zir: Zir, gpa: Allocator, list: *std.ArrayListUnmanaged(Inst.In
 
     // `defer` instructions duplicate the same body arbitrarily many times, but we only want to traverse
     // their contents once per defer. So, we store the extra index of the body here to deduplicate.
-    var found_defers: std.AutoHashMapUnmanaged(u32, void) = .{};
+    var found_defers: std.AutoHashMapUnmanaged(u32, void) = .empty;
     defer found_defers.deinit(gpa);
 
     try zir.findDeclsBody(gpa, list, &found_defers, bodies.value_body);
@@ -3725,7 +3725,7 @@ pub fn findDecls(zir: Zir, gpa: Allocator, list: *std.ArrayListUnmanaged(Inst.In
 pub fn findDeclsRoot(zir: Zir, gpa: Allocator, list: *std.ArrayListUnmanaged(Inst.Index)) !void {
     list.clearRetainingCapacity();
 
-    var found_defers: std.AutoHashMapUnmanaged(u32, void) = .{};
+    var found_defers: std.AutoHashMapUnmanaged(u32, void) = .empty;
     defer found_defers.deinit(gpa);
 
     try zir.findDeclsInner(gpa, list, &found_defers, .main_struct_inst);
diff --git a/lib/std/zig/render.zig b/lib/std/zig/render.zig
index c0391b4faf..c78a8cb07d 100644
--- a/lib/std/zig/render.zig
+++ b/lib/std/zig/render.zig
@@ -17,21 +17,21 @@ const Ais = AutoIndentingStream(std.ArrayList(u8).Writer);
 pub const Fixups = struct {
     /// The key is the mut token (`var`/`const`) of the variable declaration
     /// that should have a `_ = foo;` inserted afterwards.
-    unused_var_decls: std.AutoHashMapUnmanaged(Ast.TokenIndex, void) = .{},
+    unused_var_decls: std.AutoHashMapUnmanaged(Ast.TokenIndex, void) = .empty,
     /// The functions in this unordered set of AST fn decl nodes will render
     /// with a function body of `@trap()` instead, with all parameters
     /// discarded.
-    gut_functions: std.AutoHashMapUnmanaged(Ast.Node.Index, void) = .{},
+    gut_functions: std.AutoHashMapUnmanaged(Ast.Node.Index, void) = .empty,
     /// These global declarations will be omitted.
-    omit_nodes: std.AutoHashMapUnmanaged(Ast.Node.Index, void) = .{},
+    omit_nodes: std.AutoHashMapUnmanaged(Ast.Node.Index, void) = .empty,
     /// These expressions will be replaced with the string value.
-    replace_nodes_with_string: std.AutoHashMapUnmanaged(Ast.Node.Index, []const u8) = .{},
+    replace_nodes_with_string: std.AutoHashMapUnmanaged(Ast.Node.Index, []const u8) = .empty,
     /// The string value will be inserted directly after the node.
-    append_string_after_node: std.AutoHashMapUnmanaged(Ast.Node.Index, []const u8) = .{},
+    append_string_after_node: std.AutoHashMapUnmanaged(Ast.Node.Index, []const u8) = .empty,
     /// These nodes will be replaced with a different node.
-    replace_nodes_with_node: std.AutoHashMapUnmanaged(Ast.Node.Index, Ast.Node.Index) = .{},
+    replace_nodes_with_node: std.AutoHashMapUnmanaged(Ast.Node.Index, Ast.Node.Index) = .empty,
     /// Change all identifier names matching the key to be value instead.
-    rename_identifiers: std.StringArrayHashMapUnmanaged([]const u8) = .{},
+    rename_identifiers: std.StringArrayHashMapUnmanaged([]const u8) = .empty,
 
     /// All `@import` builtin calls which refer to a file path will be prefixed
     /// with this path.
diff --git a/lib/std/zig/system/NativePaths.zig b/lib/std/zig/system/NativePaths.zig
index 2a50e27b0c..3c96134556 100644
--- a/lib/std/zig/system/NativePaths.zig
+++ b/lib/std/zig/system/NativePaths.zig
@@ -7,11 +7,11 @@ const mem = std.mem;
 const NativePaths = @This();
 
 arena: Allocator,
-include_dirs: std.ArrayListUnmanaged([]const u8) = .{},
-lib_dirs: std.ArrayListUnmanaged([]const u8) = .{},
-framework_dirs: std.ArrayListUnmanaged([]const u8) = .{},
-rpaths: std.ArrayListUnmanaged([]const u8) = .{},
-warnings: std.ArrayListUnmanaged([]const u8) = .{},
+include_dirs: std.ArrayListUnmanaged([]const u8) = .empty,
+lib_dirs: std.ArrayListUnmanaged([]const u8) = .empty,
+framework_dirs: std.ArrayListUnmanaged([]const u8) = .empty,
+rpaths: std.ArrayListUnmanaged([]const u8) = .empty,
+warnings: std.ArrayListUnmanaged([]const u8) = .empty,
 
 pub fn detect(arena: Allocator, native_target: std.Target) !NativePaths {
     var self: NativePaths = .{ .arena = arena };