Remove ArrayList shim #137

This was for transitioning from managed to unmanaged between 0.14 and 0.15

Author: KurtWagner

build.zig

@@ -105,9 +105,9 @@ const LintExcludeSource = union(enum) {
 };
 
 const StepBuilder = struct {
-    rules: shims.ArrayList(BuiltRule),
-    include: shims.ArrayList(LintIncludeSource),
-    exclude: shims.ArrayList(LintExcludeSource),
+    rules: std.ArrayList(BuiltRule),
+    include: std.ArrayList(LintIncludeSource),
+    exclude: std.ArrayList(LintExcludeSource),
     options: BuildOptions,
     b: *std.Build,
 
@@ -388,13 +388,13 @@ pub fn build(b: *std.Build) void {
 
     const lint_cmd = b.step("lint", "Lint the linters own source code.");
     lint_cmd.dependOn(step: {
-        var include = shims.ArrayList(LintIncludeSource).empty;
+        var include = std.ArrayList(LintIncludeSource).empty;
         include.append(b.allocator, .compiled(b.addLibrary(.{
             .name = "zlinter",
             .root_module = zlinter_lib_module,
         }))) catch @panic("OOM");
 
-        var exclude = shims.ArrayList(LintExcludeSource).empty;
+        var exclude = std.ArrayList(LintExcludeSource).empty;
 
         // Also lint all files within project, not just those resolved to our compiled source.
         include.append(b.allocator, .{ .path = b.path("./") }) catch @panic("OOM");
@@ -735,7 +735,7 @@ fn createRulesModule(
     rules: []const BuiltRule,
     build_rules_output: std.Build.LazyPath,
 ) *std.Build.Module {
-    var rule_imports = shims.ArrayList(std.Build.Module.Import).empty;
+    var rule_imports = std.ArrayList(std.Build.Module.Import).empty;
     for (rules) |r| rule_imports.append(b.allocator, r.import) catch @panic("OOM");
     defer rule_imports.deinit(b.allocator);
 
@@ -772,7 +772,7 @@ const ZlinterRun = struct {
     step: std.Build.Step,
 
     /// CLI arguments to be passed to zlinter when executed
-    argv: shims.ArrayList(Arg),
+    argv: std.ArrayList(Arg),
 
     /// Exclude paths confiured within the build file.
     exclude: []const LintExcludeSource,
@@ -852,7 +852,7 @@ const ZlinterRun = struct {
 
         const b = step.owner;
 
-        var list: shims.ArrayList([]const u8) = try .initCapacity(
+        var list: std.ArrayList([]const u8) = try .initCapacity(
             b.allocator,
             paths.len,
         );
@@ -876,7 +876,7 @@ const ZlinterRun = struct {
         var cwd_buff: [std.fs.max_path_bytes]u8 = undefined;
         const cwd: BuildCwd = .init(&cwd_buff);
 
-        var includes: shims.ArrayList(std.Build.LazyPath) = try .initCapacity(
+        var includes: std.ArrayList(std.Build.LazyPath) = try .initCapacity(
             b.allocator,
             @max(1, run.include.len),
         );
@@ -933,7 +933,7 @@ const ZlinterRun = struct {
             includes.appendAssumeCapacity(b.path("./"));
         }
 
-        var excludes: shims.ArrayList(std.Build.LazyPath) = try .initCapacity(b.allocator, run.exclude.len);
+        var excludes: std.ArrayList(std.Build.LazyPath) = try .initCapacity(b.allocator, run.exclude.len);
         defer excludes.deinit(b.allocator);
         for (run.exclude) |exclude| {
             switch (exclude) {
@@ -948,7 +948,7 @@ const ZlinterRun = struct {
 
         var environ_map = b.graph.environ_map;
 
-        var argv_list = shims.ArrayList([]const u8).initCapacity(
+        var argv_list = std.ArrayList([]const u8).initCapacity(
             arena,
             run.argv.items.len + 1,
         ) catch @panic("OOM");

integration_tests/src/no_cats.zig

@@ -24,7 +24,7 @@ fn run(
     const config = options.getConfig(Config);
     if (config.severity == .off) return null;
 
-    var lint_problems = zlinter.shims.ArrayList(zlinter.results.LintProblem).empty;
+    var lint_problems = std.ArrayList(zlinter.results.LintProblem).empty;
     defer lint_problems.deinit(gpa);
 
     const tree = doc.handle.tree;

src/exe/run_linter.zig

@@ -370,7 +370,7 @@ fn runLinterRules(
         printer.println(.verbose, "    - {d} nodes", .{doc.handle.tree.nodes.len});
         printer.println(.verbose, "    - {d} tokens", .{doc.handle.tree.tokens.len});
 
-        var results = shims.ArrayList(zlinter.results.LintResult).empty;
+        var results = std.ArrayList(zlinter.results.LintResult).empty;
         defer results.deinit(gpa);
 
         const tree = doc.handle.tree;
@@ -472,7 +472,7 @@ fn runFormatter(
         }
     }
 
-    var flattened = try shims.ArrayList(zlinter.results.LintResult).initCapacity(
+    var flattened = try std.ArrayList(zlinter.results.LintResult).initCapacity(
         arena_allocator,
         results_count,
     );
@@ -509,7 +509,7 @@ fn runFixes(
 
     var it = file_lint_problems.iterator();
     while (it.next()) |entry| {
-        var lint_fixes = shims.ArrayList(zlinter.results.LintProblemFix).empty;
+        var lint_fixes = std.ArrayList(zlinter.results.LintProblemFix).empty;
         defer lint_fixes.deinit(gpa);
 
         const results = entry.value_ptr.*;
@@ -563,7 +563,7 @@ fn runFixes(
         };
         defer gpa.free(file_content);
 
-        var output_slices = shims.ArrayList([]const u8).empty;
+        var output_slices = std.ArrayList([]const u8).empty;
         defer output_slices.deinit(gpa);
 
         var file_fixes: usize = 0;
@@ -650,7 +650,7 @@ fn allocAstErrorMsg(
 ) ![]const u8 {
     switch (zlinter.version.zig) {
         .@"0.14" => {
-            var error_message = shims.ArrayList(u8).empty;
+            var error_message = std.ArrayList(u8).empty;
             defer error_message.deinit(allocator);
 
             try tree.renderError(err, error_message.writer(allocator));

src/lib/Args.zig

@@ -115,22 +115,22 @@ pub fn allocParse(
     var lint_args = Args{};
     errdefer lint_args.deinit(allocator);
 
-    var unknown_args = shims.ArrayList([]const u8).empty;
+    var unknown_args = std.ArrayList([]const u8).empty;
     defer unknown_args.deinit(allocator);
 
-    var include_paths = shims.ArrayList([]const u8).empty;
+    var include_paths = std.ArrayList([]const u8).empty;
     defer include_paths.deinit(allocator);
     errdefer for (include_paths.items) |p| allocator.free(p);
 
-    var exclude_paths = shims.ArrayList([]const u8).empty;
+    var exclude_paths = std.ArrayList([]const u8).empty;
     defer exclude_paths.deinit(allocator);
     errdefer for (exclude_paths.items) |p| allocator.free(p);
 
-    var filter_paths = shims.ArrayList([]const u8).empty;
+    var filter_paths = std.ArrayList([]const u8).empty;
     defer filter_paths.deinit(allocator);
     errdefer for (filter_paths.items) |p| allocator.free(p);
 
-    var rules = shims.ArrayList([]const u8).empty;
+    var rules = std.ArrayList([]const u8).empty;
     defer rules.deinit(allocator);
     errdefer for (rules.items) |r| allocator.free(r);
 

src/lib/ast.zig

@@ -36,7 +36,7 @@ pub const NodeAncestorIterator = struct {
 pub const NodeLineageIterator = struct {
     const Self = @This();
 
-    queue: shims.ArrayList(NodeIndexShim) = .empty,
+    queue: std.ArrayList(NodeIndexShim) = .empty,
     lineage: *const NodeLineage,
     gpa: std.mem.Allocator,
 
@@ -64,15 +64,15 @@ pub fn nodeChildrenAlloc(
 ) error{OutOfMemory}![]Ast.Node.Index {
     const Context = struct {
         gpa: std.mem.Allocator,
-        children: *shims.ArrayList(Ast.Node.Index),
+        children: *std.ArrayList(Ast.Node.Index),
 
         fn callback(self: @This(), _: *const Ast, child_node: Ast.Node.Index) error{OutOfMemory}!void {
             if (NodeIndexShim.init(child_node).isRoot()) return;
             try self.children.append(self.gpa, child_node);
         }
     };
 
-    var children: shims.ArrayList(Ast.Node.Index) = .empty;
+    var children: std.ArrayList(Ast.Node.Index) = .empty;
     defer children.deinit(gpa);
 
     try iterateChildren(

src/lib/comments.zig

@@ -72,10 +72,10 @@ const Tokenizer = struct {
 
 /// Returns tokens and line starts (line starts inclusive zero index)
 fn allocTokenize(source: [:0]const u8, gpa: std.mem.Allocator) error{OutOfMemory}!struct { []const Token, []const usize } {
-    var tokens = shims.ArrayList(Token).empty;
+    var tokens = std.ArrayList(Token).empty;
     defer tokens.deinit(gpa);
 
-    var line_starts = shims.ArrayList(usize).empty;
+    var line_starts = std.ArrayList(usize).empty;
     defer line_starts.deinit(gpa);
     try line_starts.append(gpa, 0); // First line starts on byte zero
 
@@ -435,7 +435,7 @@ fn testTokenize(
         defer std.testing.allocator.free(line_starts);
         defer std.testing.allocator.free(tokens);
 
-        var actual = shims.ArrayList(struct { u32, Token.Tag, []const u8 }).empty;
+        var actual = std.ArrayList(struct { u32, Token.Tag, []const u8 }).empty;
         defer actual.deinit(std.testing.allocator);
         for (tokens) |token| try actual.append(std.testing.allocator, .{
             token.line,
@@ -703,13 +703,13 @@ const Parser = struct {
 pub fn allocParse(source: [:0]const u8, gpa: std.mem.Allocator) error{OutOfMemory}!CommentsDocument {
     const tokens, const line_starts = try allocTokenize(source, gpa);
 
-    var comments = shims.ArrayList(Comment).empty;
+    var comments = std.ArrayList(Comment).empty;
     defer comments.deinit(gpa);
 
-    var enables = shims.ArrayList(struct { u32, []const u8 }).empty;
+    var enables = std.ArrayList(struct { u32, []const u8 }).empty;
     defer enables.deinit(gpa);
 
-    var disables = shims.ArrayList(struct { u32, []const u8 }).empty;
+    var disables = std.ArrayList(struct { u32, []const u8 }).empty;
     defer disables.deinit(gpa);
 
     var p = Parser{ .tokens = tokens };

src/lib/explorer.zig

@@ -129,7 +129,7 @@ fn errorsToJson(tree: Ast, arena: std.mem.Allocator) !std.json.Array {
 
         switch (version.zig) {
             .@"0.14" => {
-                var render_backing = shims.ArrayList(u8).empty;
+                var render_backing = std.ArrayList(u8).empty;
                 // zlinter-disable-next-line no_deprecated - Upgraded in 0.15
                 try tree.renderError(e, render_backing.writer(arena));
                 try json_error.put("message", .{ .string = try render_backing.toOwnedSlice(arena) });

src/lib/rendering.zig

@@ -9,7 +9,7 @@ pub const LintFileRenderer = struct {
     pub fn init(allocator: std.mem.Allocator, reader: *std.Io.Reader) !Self {
         const source = try reader.allocRemaining(allocator, .limited(max_zig_file_size_bytes));
 
-        var line_ends = try shims.ArrayList(usize).initCapacity(allocator, source.len / 40);
+        var line_ends = try std.ArrayList(usize).initCapacity(allocator, source.len / 40);
         errdefer line_ends.deinit(allocator);
 
         for (0..source.len) |i| {

src/lib/session.zig

@@ -293,7 +293,7 @@ pub const LintContext = struct {
                 node: NodeIndexShim,
             };
 
-            var queue = shims.ArrayList(QueueItem).empty;
+            var queue = std.ArrayList(QueueItem).empty;
             defer queue.deinit(gpa);
 
             try queue.append(gpa, .{ .node = NodeIndexShim.root });

src/lib/shims.zig

@@ -181,16 +181,6 @@ pub fn isContainerNamespace(tree: Ast, container_decl: Ast.full.ContainerDecl) b
     return true;
 }
 
-/// Managed versions of ArrayList are being removed from std. While it's phased
-/// out this can be used to consistently return an unmanaged version.
-pub fn ArrayList(T: type) type {
-    return comptime switch (version.zig) {
-        // zlinter-disable-next-line no_deprecated - targets 0.14 when not deprecated
-        .@"0.14" => std.ArrayListUnmanaged(T),
-        .@"0.15", .@"0.16" => std.ArrayList(T),
-    };
-}
-
 const std = @import("std");
 const version = @import("version.zig");
 const Ast = std.zig.Ast;