Remove static list of names and URIs from require_errdefer_deinit #48 (#117)

It now checks whether the type has a `deinit` call.

It still tries to limit noise by only looking at declarations to
`.empty`, `.init`, `initCapacity(..)` or `init(..)` without parameters
that look like arenas or fixed buffers. I'm unsure about this.

Author: KurtWagner

integration_tests/test_cases/require_errdefer_dealloc/require_errdefer_dealloc.input.zig

@@ -92,4 +92,22 @@ pub fn hasErrorButWithArena(input: u32) error{NotOk}!void {
     has_arena_d.deinit(std.heap.page_allocator);
 }
 
+pub fn cleanupInConditionBlock(allocator: std.mem.Allocator) !void {
+    const deinit_wip = true;
+    var wip = try std.ArrayList(u8).initCapacity(allocator, 10);
+    defer if (deinit_wip) wip.deinit();
+}
+
+pub fn cleanupInAssignment() !void {
+    var debug_gpa_state: std.heap.DebugAllocator(.{}) = .init;
+    defer _ = debug_gpa_state.deinit();
+}
+
+pub fn cleanupInCondition() !void {
+    var debug_gpa_state: std.heap.DebugAllocator(.{}) = .init;
+    defer {
+        if (debug_gpa_state.deinit() == .leak) {}
+    }
+}
+
 const std = @import("std");

src/lib/ast.zig

@@ -437,6 +437,27 @@ pub fn fullStatement(tree: Ast, node: Ast.Node.Index) ?Statement {
     };
 }
 
+/// Visibility of a node in the AST (e.g., a function or variable declaration).
+pub const Visibility = enum { public, private };
+
+/// Returns the visibility of a given function proto.
+pub fn fnProtoVisibility(tree: Ast, fn_decl: Ast.full.FnProto) Visibility {
+    const visibility_token = fn_decl.visib_token orelse return .private;
+    return switch (tree.tokens.items(.tag)[visibility_token]) {
+        .keyword_pub => .public,
+        else => .private,
+    };
+}
+
+/// Returns the visibility of a given variable declaration.
+pub fn varDeclVisibility(tree: Ast, var_decl: Ast.full.VarDecl) Visibility {
+    const visibility_token = var_decl.visib_token orelse return .private;
+    return switch (tree.tokens.items(.tag)[visibility_token]) {
+        .keyword_pub => .public,
+        else => .private,
+    };
+}
+
 test "isFieldVarAccess" {
     inline for (&.{
         .{

src/rules/no_inferred_error_unions.zig

@@ -62,7 +62,7 @@ fn run(
         if (tag != .fn_decl) continue :nodes;
 
         const fn_decl = tree.fullFnProto(&fn_decl_buffer, node.toNodeIndex()) orelse continue :nodes;
-        if (config.allow_private and isFnPrivate(tree, fn_decl)) continue :nodes;
+        if (config.allow_private and zlinter.ast.fnProtoVisibility(tree, fn_decl) == .private) continue :nodes;
 
         const return_type = NodeIndexShim.initOptional(fn_decl.ast.return_type) orelse continue :nodes;
 
@@ -97,14 +97,6 @@ fn run(
         null;
 }
 
-fn isFnPrivate(tree: Ast, fn_decl: Ast.full.FnProto) bool {
-    const visibility_token = fn_decl.visib_token orelse return true;
-    return switch (tree.tokens.items(.tag)[visibility_token]) {
-        .keyword_pub => false,
-        else => true,
-    };
-}
-
 test {
     std.testing.refAllDecls(@This());
 }

src/rules/no_unused.zig

@@ -64,9 +64,7 @@ fn run(
     for (tree.rootDecls()) |decl| {
         const problem: ?struct { first: Ast.TokenIndex, last: Ast.TokenIndex } = problem: {
             if (tree.fullVarDecl(decl)) |var_decl| {
-                if (var_decl.visib_token) |visib_token|
-                    if (token_tags[visib_token] == .keyword_pub)
-                        break :problem null;
+                if (zlinter.ast.varDeclVisibility(tree, var_decl) == .public) break :problem null;
 
                 if (var_decl.extern_export_token) |extern_export_token|
                     if (token_tags[extern_export_token] == .keyword_export)
@@ -81,9 +79,7 @@ fn run(
             } else {
                 var buffer: [1]Ast.Node.Index = undefined;
                 if (namedFnDeclProto(tree, &buffer, decl)) |fn_proto| {
-                    if (fn_proto.visib_token) |token|
-                        if (token_tags[token] == .keyword_pub)
-                            break :problem null;
+                    if (zlinter.ast.fnProtoVisibility(tree, fn_proto) == .public) break :problem null;
 
                     if (fn_proto.extern_export_inline_token) |token|
                         if (token_tags[token] == .keyword_export)

src/rules/require_doc_comment.zig

@@ -75,10 +75,10 @@ fn run(
 
         switch (tag) {
             .fn_decl => if (tree.fullFnProto(&fn_decl_buffer, node.toNodeIndex())) |fn_decl| {
-                const severity, const label = if (isFnPrivate(tree, fn_decl))
-                    .{ config.private_severity, "Private" }
-                else
-                    .{ config.public_severity, "Public" };
+                const severity, const label = switch (zlinter.ast.fnProtoVisibility(tree, fn_decl)) {
+                    .private => .{ config.private_severity, "Private" },
+                    .public => .{ config.public_severity, "Public" },
+                };
                 if (severity == .off) continue :nodes;
 
                 if (try hasDocComments(arena, tree, node.toNodeIndex())) continue :nodes;
@@ -92,10 +92,10 @@ fn run(
                 });
             },
             else => if (tree.fullVarDecl(node.toNodeIndex())) |var_decl| {
-                const severity, const label = if (isVarPrivate(tree, var_decl))
-                    .{ config.private_severity, "Private" }
-                else
-                    .{ config.public_severity, "Public" };
+                const severity, const label = switch (zlinter.ast.varDeclVisibility(tree, var_decl)) {
+                    .private => .{ config.private_severity, "Private" },
+                    .public => .{ config.public_severity, "Public" },
+                };
                 if (severity == .off) continue :nodes;
 
                 if (try hasDocComments(arena, tree, node.toNodeIndex())) continue :nodes;
@@ -132,22 +132,6 @@ fn hasDocComments(arena: std.mem.Allocator, tree: Ast, node: Ast.Node.Index) !bo
     return comments.len > 0;
 }
 
-fn isFnPrivate(tree: Ast, fn_decl: Ast.full.FnProto) bool {
-    const visibility_token = fn_decl.visib_token orelse return true;
-    return switch (tree.tokens.items(.tag)[visibility_token]) {
-        .keyword_pub => false,
-        else => true,
-    };
-}
-
-fn isVarPrivate(tree: Ast, var_decl: Ast.full.VarDecl) bool {
-    const visibility_token = var_decl.visib_token orelse return true;
-    return switch (tree.tokens.items(.tag)[visibility_token]) {
-        .keyword_pub => false,
-        else => true,
-    };
-}
-
 test "require_doc_comment - public" {
     const rule = buildRule(.{});
     const source: [:0]const u8 =