std.ArrayList: make unmanaged the default

8 files changed, 69 insertions, 68 deletions

diff --git a/lib/std/Build/Module.zig b/lib/std/Build/Module.zig
index 0fa8a9a623..2719aea1c6 100644
--- a/lib/std/Build/Module.zig
+++ b/lib/std/Build/Module.zig
@@ -10,12 +10,12 @@ resolved_target: ?std.Build.ResolvedTarget = null,
 optimize: ?std.builtin.OptimizeMode = null,
 dwarf_format: ?std.dwarf.Format,
 
-c_macros: std.ArrayListUnmanaged([]const u8),
-include_dirs: std.ArrayListUnmanaged(IncludeDir),
-lib_paths: std.ArrayListUnmanaged(LazyPath),
-rpaths: std.ArrayListUnmanaged(RPath),
+c_macros: ArrayList([]const u8),
+include_dirs: ArrayList(IncludeDir),
+lib_paths: ArrayList(LazyPath),
+rpaths: ArrayList(RPath),
 frameworks: std.StringArrayHashMapUnmanaged(LinkFrameworkOptions),
-link_objects: std.ArrayListUnmanaged(LinkObject),
+link_objects: ArrayList(LinkObject),
 
 strip: ?bool,
 unwind_tables: ?std.builtin.UnwindTables,
@@ -170,7 +170,7 @@ pub const IncludeDir = union(enum) {
     pub fn appendZigProcessFlags(
         include_dir: IncludeDir,
         b: *std.Build,
-        zig_args: *std.ArrayList([]const u8),
+        zig_args: *std.array_list.Managed([]const u8),
         asking_step: ?*Step,
     ) !void {
         const flag: []const u8, const lazy_path: LazyPath = switch (include_dir) {
@@ -537,7 +537,7 @@ pub fn addCMacro(m: *Module, name: []const u8, value: []const u8) void {
 
 pub fn appendZigProcessFlags(
     m: *Module,
-    zig_args: *std.ArrayList([]const u8),
+    zig_args: *std.array_list.Managed([]const u8),
     asking_step: ?*Step,
 ) !void {
     const b = m.owner;
@@ -634,7 +634,7 @@ pub fn appendZigProcessFlags(
 }
 
 fn addFlag(
-    args: *std.ArrayList([]const u8),
+    args: *std.array_list.Managed([]const u8),
     opt: ?bool,
     then_name: []const u8,
     else_name: []const u8,
@@ -706,3 +706,4 @@ const std = @import("std");
 const assert = std.debug.assert;
 const LazyPath = std.Build.LazyPath;
 const Step = std.Build.Step;
+const ArrayList = std.ArrayList;
diff --git a/lib/std/Build/Step.zig b/lib/std/Build/Step.zig
index ee883ee152..c3392c4301 100644
--- a/lib/std/Build/Step.zig
+++ b/lib/std/Build/Step.zig
@@ -1,12 +1,22 @@
+const Step = @This();
+const std = @import("../std.zig");
+const Build = std.Build;
+const Allocator = std.mem.Allocator;
+const assert = std.debug.assert;
+const builtin = @import("builtin");
+const Cache = Build.Cache;
+const Path = Cache.Path;
+const ArrayList = std.ArrayList;
+
 id: Id,
 name: []const u8,
 owner: *Build,
 makeFn: MakeFn,
 
-dependencies: std.ArrayList(*Step),
+dependencies: std.array_list.Managed(*Step),
 /// This field is empty during execution of the user's build script, and
 /// then populated during dependency loop checking in the build runner.
-dependants: std.ArrayListUnmanaged(*Step),
+dependants: ArrayList(*Step),
 /// Collects the set of files that retrigger this step to run.
 ///
 /// This is used by the build system's implementation of `--watch` but it can
@@ -39,7 +49,7 @@ state: State,
 /// total system memory available.
 max_rss: usize,
 
-result_error_msgs: std.ArrayListUnmanaged([]const u8),
+result_error_msgs: ArrayList([]const u8),
 result_error_bundle: std.zig.ErrorBundle,
 result_stderr: []const u8,
 result_cached: bool,
@@ -175,7 +185,7 @@ pub const Inputs = struct {
 
     pub const Table = std.ArrayHashMapUnmanaged(Build.Cache.Path, Files, Build.Cache.Path.TableAdapter, false);
     /// The special file name "." means any changes inside the directory.
-    pub const Files = std.ArrayListUnmanaged([]const u8);
+    pub const Files = ArrayList([]const u8);
 
     pub fn populated(inputs: *Inputs) bool {
         return inputs.table.count() != 0;
@@ -204,8 +214,8 @@ pub fn init(options: StepOptions) Step {
         .name = arena.dupe(u8, options.name) catch @panic("OOM"),
         .owner = options.owner,
         .makeFn = options.makeFn,
-        .dependencies = std.ArrayList(*Step).init(arena),
-        .dependants = .{},
+        .dependencies = std.array_list.Managed(*Step).init(arena),
+        .dependants = .empty,
         .inputs = Inputs.init,
         .state = .precheck_unstarted,
         .max_rss = options.max_rss,
@@ -326,15 +336,6 @@ pub fn dump(step: *Step, w: *std.Io.Writer, tty_config: std.Io.tty.Config) void
     }
 }
 
-const Step = @This();
-const std = @import("../std.zig");
-const Build = std.Build;
-const Allocator = std.mem.Allocator;
-const assert = std.debug.assert;
-const builtin = @import("builtin");
-const Cache = Build.Cache;
-const Path = Cache.Path;
-
 pub fn evalChildProcess(s: *Step, argv: []const []const u8) ![]u8 {
     const run_result = try captureChildProcess(s, std.Progress.Node.none, argv);
     try handleChildProcessTerm(s, run_result.term, null, argv);
@@ -980,7 +981,7 @@ fn addDirectoryWatchInputFromBuilder(step: *Step, builder: *Build, sub_path: []c
 fn addWatchInputFromPath(step: *Step, path: Build.Cache.Path, basename: []const u8) !void {
     const gpa = step.owner.allocator;
     const gop = try step.inputs.table.getOrPut(gpa, path);
-    if (!gop.found_existing) gop.value_ptr.* = .{};
+    if (!gop.found_existing) gop.value_ptr.* = .empty;
     try gop.value_ptr.append(gpa, basename);
 }
 
diff --git a/lib/std/Build/Step/CheckObject.zig b/lib/std/Build/Step/CheckObject.zig
index 06ad26ccc8..6bbe3307a0 100644
--- a/lib/std/Build/Step/CheckObject.zig
+++ b/lib/std/Build/Step/CheckObject.zig
@@ -18,7 +18,7 @@ pub const base_id: Step.Id = .check_object;
 step: Step,
 source: std.Build.LazyPath,
 max_bytes: usize = 20 * 1024 * 1024,
-checks: std.ArrayList(Check),
+checks: std.array_list.Managed(Check),
 obj_format: std.Target.ObjectFormat,
 
 pub fn create(
@@ -36,7 +36,7 @@ pub fn create(
             .makeFn = make,
         }),
         .source = source.dupe(owner),
-        .checks = std.ArrayList(Check).init(gpa),
+        .checks = std.array_list.Managed(Check).init(gpa),
         .obj_format = obj_format,
     };
     check_object.source.addStepDependencies(&check_object.step);
@@ -81,7 +81,7 @@ const Action = struct {
         const hay = mem.trim(u8, haystack, " ");
         const phrase = mem.trim(u8, act.phrase.resolve(b, step), " ");
 
-        var candidate_vars: std.ArrayList(struct { name: []const u8, value: u64 }) = .init(b.allocator);
+        var candidate_vars: std.array_list.Managed(struct { name: []const u8, value: u64 }) = .init(b.allocator);
         var hay_it = mem.tokenizeScalar(u8, hay, ' ');
         var needle_it = mem.tokenizeScalar(u8, phrase, ' ');
 
@@ -157,8 +157,8 @@ const Action = struct {
     fn computeCmp(act: Action, b: *std.Build, step: *Step, global_vars: anytype) !bool {
         const gpa = step.owner.allocator;
         const phrase = act.phrase.resolve(b, step);
-        var op_stack = std.ArrayList(enum { add, sub, mod, mul }).init(gpa);
-        var values = std.ArrayList(u64).init(gpa);
+        var op_stack = std.array_list.Managed(enum { add, sub, mod, mul }).init(gpa);
+        var values = std.array_list.Managed(u64).init(gpa);
 
         var it = mem.tokenizeScalar(u8, phrase, ' ');
         while (it.next()) |next| {
@@ -242,15 +242,15 @@ const ComputeCompareExpected = struct {
 const Check = struct {
     kind: Kind,
     payload: Payload,
-    data: std.ArrayList(u8),
-    actions: std.ArrayList(Action),
+    data: std.array_list.Managed(u8),
+    actions: std.array_list.Managed(Action),
 
     fn create(allocator: Allocator, kind: Kind) Check {
         return .{
             .kind = kind,
             .payload = .{ .none = {} },
-            .data = std.ArrayList(u8).init(allocator),
-            .actions = std.ArrayList(Action).init(allocator),
+            .data = std.array_list.Managed(u8).init(allocator),
+            .actions = std.array_list.Managed(Action).init(allocator),
         };
     }
 
@@ -1214,7 +1214,7 @@ const MachODumper = struct {
         }
 
         fn dumpRebaseInfo(ctx: ObjectContext, data: []const u8, writer: anytype) !void {
-            var rebases = std.ArrayList(u64).init(ctx.gpa);
+            var rebases = std.array_list.Managed(u64).init(ctx.gpa);
             defer rebases.deinit();
             try ctx.parseRebaseInfo(data, &rebases);
             mem.sort(u64, rebases.items, {}, std.sort.asc(u64));
@@ -1223,7 +1223,7 @@ const MachODumper = struct {
             }
         }
 
-        fn parseRebaseInfo(ctx: ObjectContext, data: []const u8, rebases: *std.ArrayList(u64)) !void {
+        fn parseRebaseInfo(ctx: ObjectContext, data: []const u8, rebases: *std.array_list.Managed(u64)) !void {
             var stream = std.io.fixedBufferStream(data);
             var creader = std.io.countingReader(stream.reader());
             const reader = creader.reader();
@@ -1313,7 +1313,7 @@ const MachODumper = struct {
         };
 
         fn dumpBindInfo(ctx: ObjectContext, data: []const u8, writer: anytype) !void {
-            var bindings = std.ArrayList(Binding).init(ctx.gpa);
+            var bindings = std.array_list.Managed(Binding).init(ctx.gpa);
             defer {
                 for (bindings.items) |*b| {
                     b.deinit(ctx.gpa);
@@ -1335,7 +1335,7 @@ const MachODumper = struct {
             }
         }
 
-        fn parseBindInfo(ctx: ObjectContext, data: []const u8, bindings: *std.ArrayList(Binding)) !void {
+        fn parseBindInfo(ctx: ObjectContext, data: []const u8, bindings: *std.array_list.Managed(Binding)) !void {
             var stream = std.io.fixedBufferStream(data);
             var creader = std.io.countingReader(stream.reader());
             const reader = creader.reader();
@@ -1346,7 +1346,7 @@ const MachODumper = struct {
             var offset: u64 = 0;
             var addend: i64 = 0;
 
-            var name_buf = std.ArrayList(u8).init(ctx.gpa);
+            var name_buf = std.array_list.Managed(u8).init(ctx.gpa);
             defer name_buf.deinit();
 
             while (true) {
@@ -1434,7 +1434,7 @@ const MachODumper = struct {
             var arena = std.heap.ArenaAllocator.init(ctx.gpa);
             defer arena.deinit();
 
-            var exports = std.ArrayList(Export).init(arena.allocator());
+            var exports = std.array_list.Managed(Export).init(arena.allocator());
             var it = TrieIterator{ .data = data };
             try parseTrieNode(arena.allocator(), &it, "", &exports);
 
@@ -1546,7 +1546,7 @@ const MachODumper = struct {
             arena: Allocator,
             it: *TrieIterator,
             prefix: []const u8,
-            exports: *std.ArrayList(Export),
+            exports: *std.array_list.Managed(Export),
         ) !void {
             const size = try it.readUleb128();
             if (size > 0) {
@@ -1621,7 +1621,7 @@ const MachODumper = struct {
         var ctx = ObjectContext{ .gpa = gpa, .data = bytes, .header = hdr };
         try ctx.parse();
 
-        var output = std.ArrayList(u8).init(gpa);
+        var output = std.array_list.Managed(u8).init(gpa);
         const writer = output.writer();
 
         switch (check.kind) {
@@ -1787,7 +1787,7 @@ const ElfDumper = struct {
             try ctx.objects.append(gpa, .{ .name = name, .off = stream.pos, .len = size });
         }
 
-        var output = std.ArrayList(u8).init(gpa);
+        var output = std.array_list.Managed(u8).init(gpa);
         const writer = output.writer();
 
         switch (check.kind) {
@@ -1848,7 +1848,7 @@ const ElfDumper = struct {
                 files.putAssumeCapacityNoClobber(object.off - @sizeOf(elf.ar_hdr), object.name);
             }
 
-            var symbols = std.AutoArrayHashMap(usize, std.ArrayList([]const u8)).init(ctx.gpa);
+            var symbols = std.AutoArrayHashMap(usize, std.array_list.Managed([]const u8)).init(ctx.gpa);
             defer {
                 for (symbols.values()) |*value| {
                     value.deinit();
@@ -1859,7 +1859,7 @@ const ElfDumper = struct {
             for (ctx.symtab.items) |entry| {
                 const gop = try symbols.getOrPut(@intCast(entry.off));
                 if (!gop.found_existing) {
-                    gop.value_ptr.* = std.ArrayList([]const u8).init(ctx.gpa);
+                    gop.value_ptr.* = std.array_list.Managed([]const u8).init(ctx.gpa);
                 }
                 try gop.value_ptr.append(entry.name);
             }
@@ -1944,7 +1944,7 @@ const ElfDumper = struct {
             else => {},
         };
 
-        var output = std.ArrayList(u8).init(gpa);
+        var output = std.array_list.Managed(u8).init(gpa);
         const writer = output.writer();
 
         switch (check.kind) {
@@ -2398,7 +2398,7 @@ const WasmDumper = struct {
             return error.UnsupportedWasmVersion;
         }
 
-        var output = std.ArrayList(u8).init(gpa);
+        var output = std.array_list.Managed(u8).init(gpa);
         defer output.deinit();
         parseAndDumpInner(step, check, bytes, &fbs, &output) catch |err| switch (err) {
             error.EndOfStream => try output.appendSlice("\n<UnexpectedEndOfStream>"),
@@ -2412,7 +2412,7 @@ const WasmDumper = struct {
         check: Check,
         bytes: []const u8,
         fbs: *std.io.FixedBufferStream([]const u8),
-        output: *std.ArrayList(u8),
+        output: *std.array_list.Managed(u8),
     ) !void {
         const reader = fbs.reader();
         const writer = output.writer();
diff --git a/lib/std/Build/Step/Compile.zig b/lib/std/Build/Step/Compile.zig
index 59ccb87dad..79d3694c02 100644
--- a/lib/std/Build/Step/Compile.zig
+++ b/lib/std/Build/Step/Compile.zig
@@ -4,7 +4,6 @@ const mem = std.mem;
 const fs = std.fs;
 const assert = std.debug.assert;
 const panic = std.debug.panic;
-const ArrayList = std.ArrayList;
 const StringHashMap = std.StringHashMap;
 const Sha256 = std.crypto.hash.sha2.Sha256;
 const Allocator = mem.Allocator;
@@ -60,7 +59,7 @@ filters: []const []const u8,
 test_runner: ?TestRunner,
 wasi_exec_model: ?std.builtin.WasiExecModel = null,
 
-installed_headers: ArrayList(HeaderInstallation),
+installed_headers: std.array_list.Managed(HeaderInstallation),
 
 /// This step is used to create an include tree that dependent modules can add to their include
 /// search paths. Installed headers are copied to this step.
@@ -421,7 +420,7 @@ pub fn create(owner: *std.Build, options: Options) *Compile {
         .out_lib_filename = undefined,
         .major_only_filename = null,
         .name_only_filename = null,
-        .installed_headers = ArrayList(HeaderInstallation).init(owner.allocator),
+        .installed_headers = std.array_list.Managed(HeaderInstallation).init(owner.allocator),
         .zig_lib_dir = null,
         .exec_cmd_args = null,
         .filters = options.filters,
@@ -766,9 +765,9 @@ fn runPkgConfig(compile: *Compile, lib_name: []const u8) !PkgConfigResult {
         else => return err,
     };
 
-    var zig_cflags = ArrayList([]const u8).init(b.allocator);
+    var zig_cflags = std.array_list.Managed([]const u8).init(b.allocator);
     defer zig_cflags.deinit();
-    var zig_libs = ArrayList([]const u8).init(b.allocator);
+    var zig_libs = std.array_list.Managed([]const u8).init(b.allocator);
     defer zig_libs.deinit();
 
     var arg_it = mem.tokenizeAny(u8, stdout, " \r\n\t");
@@ -1076,7 +1075,7 @@ fn getZigArgs(compile: *Compile, fuzz: bool) ![][]const u8 {
     const b = step.owner;
     const arena = b.allocator;
 
-    var zig_args = ArrayList([]const u8).init(arena);
+    var zig_args = std.array_list.Managed([]const u8).init(arena);
     defer zig_args.deinit();
 
     try zig_args.append(b.graph.zig_exe);
@@ -1798,7 +1797,7 @@ fn getZigArgs(compile: *Compile, fuzz: bool) ![][]const u8 {
         try b.cache_root.handle.makePath("args");
 
         const args_to_escape = zig_args.items[2..];
-        var escaped_args = try ArrayList([]const u8).initCapacity(arena, args_to_escape.len);
+        var escaped_args = try std.array_list.Managed([]const u8).initCapacity(arena, args_to_escape.len);
         arg_blk: for (args_to_escape) |arg| {
             for (arg, 0..) |c, arg_idx| {
                 if (c == '\\' or c == '"') {
@@ -1948,7 +1947,7 @@ pub fn doAtomicSymLinks(
 fn execPkgConfigList(b: *std.Build, out_code: *u8) (PkgConfigError || RunError)![]const PkgConfigPkg {
     const pkg_config_exe = b.graph.env_map.get("PKG_CONFIG") orelse "pkg-config";
     const stdout = try b.runAllowFail(&[_][]const u8{ pkg_config_exe, "--list-all" }, out_code, .Ignore);
-    var list = ArrayList(PkgConfigPkg).init(b.allocator);
+    var list = std.array_list.Managed(PkgConfigPkg).init(b.allocator);
     errdefer list.deinit();
     var line_it = mem.tokenizeAny(u8, stdout, "\r\n");
     while (line_it.next()) |line| {
@@ -1985,7 +1984,7 @@ fn getPkgConfigList(b: *std.Build) ![]const PkgConfigPkg {
     }
 }
 
-fn addFlag(args: *ArrayList([]const u8), comptime name: []const u8, opt: ?bool) !void {
+fn addFlag(args: *std.array_list.Managed([]const u8), comptime name: []const u8, opt: ?bool) !void {
     const cond = opt orelse return;
     try args.ensureUnusedCapacity(1);
     if (cond) {
diff --git a/lib/std/Build/Step/ConfigHeader.zig b/lib/std/Build/Step/ConfigHeader.zig
index e27887693d..40144985cb 100644
--- a/lib/std/Build/Step/ConfigHeader.zig
+++ b/lib/std/Build/Step/ConfigHeader.zig
@@ -621,7 +621,7 @@ fn expand_variables_cmake(
     contents: []const u8,
     values: std.StringArrayHashMap(Value),
 ) ![]const u8 {
-    var result: std.ArrayList(u8) = .init(allocator);
+    var result: std.array_list.Managed(u8) = .init(allocator);
     errdefer result.deinit();
 
     const valid_varname_chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789/_.+-";
@@ -633,7 +633,7 @@ fn expand_variables_cmake(
         source: usize,
         target: usize,
     };
-    var var_stack: std.ArrayList(Position) = .init(allocator);
+    var var_stack: std.array_list.Managed(Position) = .init(allocator);
     defer var_stack.deinit();
     loop: while (curr < contents.len) : (curr += 1) {
         switch (contents[curr]) {
diff --git a/lib/std/Build/Step/ObjCopy.zig b/lib/std/Build/Step/ObjCopy.zig
index 3c9eb2eaa7..e6ee8fc6e8 100644
--- a/lib/std/Build/Step/ObjCopy.zig
+++ b/lib/std/Build/Step/ObjCopy.zig
@@ -182,7 +182,7 @@ fn make(step: *Step, options: Step.MakeOptions) !void {
         return step.fail("unable to make path {s}: {s}", .{ cache_path, @errorName(err) });
     };
 
-    var argv = std.ArrayList([]const u8).init(b.allocator);
+    var argv = std.array_list.Managed([]const u8).init(b.allocator);
     try argv.appendSlice(&.{ b.graph.zig_exe, "objcopy" });
 
     if (objcopy.only_section) |only_section| {
diff --git a/lib/std/Build/Step/Run.zig b/lib/std/Build/Step/Run.zig
index d317422bd9..cd9fdc27d8 100644
--- a/lib/std/Build/Step/Run.zig
+++ b/lib/std/Build/Step/Run.zig
@@ -679,15 +679,15 @@ fn make(step: *Step, options: Step.MakeOptions) !void {
     const run: *Run = @fieldParentPtr("step", step);
     const has_side_effects = run.hasSideEffects();
 
-    var argv_list = std.ArrayList([]const u8).init(arena);
-    var output_placeholders = std.ArrayList(IndexedOutput).init(arena);
+    var argv_list = std.array_list.Managed([]const u8).init(arena);
+    var output_placeholders = std.array_list.Managed(IndexedOutput).init(arena);
 
     var man = b.graph.cache.obtain();
     defer man.deinit();
 
     if (run.env_map) |env_map| {
         const KV = struct { []const u8, []const u8 };
-        var kv_pairs = try std.ArrayList(KV).initCapacity(arena, env_map.count());
+        var kv_pairs = try std.array_list.Managed(KV).initCapacity(arena, env_map.count());
         var iter = env_map.iterator();
         while (iter.next()) |entry| {
             kv_pairs.appendAssumeCapacity(.{ entry.key_ptr.*, entry.value_ptr.* });
@@ -1080,7 +1080,7 @@ fn runCommand(
         else => false,
     };
 
-    var interp_argv = std.ArrayList([]const u8).init(b.allocator);
+    var interp_argv = std.array_list.Managed([]const u8).init(b.allocator);
     defer interp_argv.deinit();
 
     var env_map = run.env_map orelse &b.graph.env_map;
diff --git a/lib/std/Build/Step/TranslateC.zig b/lib/std/Build/Step/TranslateC.zig
index 53c4007e26..dabf2200df 100644
--- a/lib/std/Build/Step/TranslateC.zig
+++ b/lib/std/Build/Step/TranslateC.zig
@@ -10,8 +10,8 @@ pub const base_id: Step.Id = .translate_c;
 
 step: Step,
 source: std.Build.LazyPath,
-include_dirs: std.ArrayList(std.Build.Module.IncludeDir),
-c_macros: std.ArrayList([]const u8),
+include_dirs: std.array_list.Managed(std.Build.Module.IncludeDir),
+c_macros: std.array_list.Managed([]const u8),
 out_basename: []const u8,
 target: std.Build.ResolvedTarget,
 optimize: std.builtin.OptimizeMode,
@@ -38,8 +38,8 @@ pub fn create(owner: *std.Build, options: Options) *TranslateC {
             .makeFn = make,
         }),
         .source = source,
-        .include_dirs = std.ArrayList(std.Build.Module.IncludeDir).init(owner.allocator),
-        .c_macros = std.ArrayList([]const u8).init(owner.allocator),
+        .include_dirs = std.array_list.Managed(std.Build.Module.IncludeDir).init(owner.allocator),
+        .c_macros = std.array_list.Managed([]const u8).init(owner.allocator),
         .out_basename = undefined,
         .target = options.target,
         .optimize = options.optimize,
@@ -153,7 +153,7 @@ fn make(step: *Step, options: Step.MakeOptions) !void {
     const b = step.owner;
     const translate_c: *TranslateC = @fieldParentPtr("step", step);
 
-    var argv_list = std.ArrayList([]const u8).init(b.allocator);
+    var argv_list = std.array_list.Managed([]const u8).init(b.allocator);
     try argv_list.append(b.graph.zig_exe);
     try argv_list.append("translate-c");
     if (translate_c.link_libc) {