Refactor to pass lint document by pointer and to separate analyser (#118)

This avoids confusion around shallow copies and mutability as it was
mutating what the pointers in the shallow copies were pointing to.

This is breaking in that run accepts a pointer and context is
re-introduced.

Before:

```zig
fn (
    self: LintRule,
    doc: session.LintDocument,
    gpa: std.mem.Allocator,
    options: RunOptions,
) error{OutOfMemory}!?results.LintResult
```

After:

```zig
fn (
    self: LintRule,
    context: *session.LintContext,
    doc: *const session.LintDocument,
    gpa: std.mem.Allocator,
    options: RunOptions,
 ) error{OutOfMemory}!?results.LintResult
```

Author: KurtWagner

integration_tests/src/no_cats.zig

@@ -16,7 +16,8 @@ pub fn buildRule(options: zlinter.rules.RuleOptions) zlinter.rules.LintRule {
 
 fn run(
     rule: zlinter.rules.LintRule,
-    doc: zlinter.session.LintDocument,
+    _: *zlinter.session.LintContext,
+    doc: *const zlinter.session.LintDocument,
     allocator: std.mem.Allocator,
     options: zlinter.rules.RunOptions,
 ) error{OutOfMemory}!?zlinter.results.LintResult {

src/exe/run_linter.zig

@@ -221,6 +221,9 @@ fn runLinterRules(
         slowest_files.unloadAndPrint("Files", printer);
     };
 
+    var arena = std.heap.ArenaAllocator.init(gpa);
+    defer arena.deinit();
+
     var maybe_rule_elapsed_times: ?[rules.len]usize = if (args.verbose)
         @splat(0)
     else
@@ -238,13 +241,13 @@ fn runLinterRules(
         item_timers.unloadAndPrint("Rules", printer);
     };
 
-    var ctx: zlinter.session.LintContext = undefined;
-    try ctx.init(.{
+    var context: zlinter.session.LintContext = undefined;
+    try context.init(.{
         .zig_exe_path = args.zig_exe,
         .zig_lib_path = args.zig_lib_directory,
         .global_cache_path = args.global_cache_root,
-    }, gpa);
-    defer ctx.deinit();
+    }, gpa, arena.allocator());
+    defer context.deinit();
 
     var enabled_rules = enabledRules(args.rules);
 
@@ -260,9 +263,9 @@ fn runLinterRules(
                     if (rule_config_overrides.get(rules[rule_index].rule_id)) |zon_path| {
                         inline for (0..rules_configs_types.len) |i| {
                             if (i == rule_index) {
-                                const arena = config_overrides_arena.allocator();
-                                const config = try arena.create(rules_configs_types[i]);
-                                errdefer arena.destroy(config);
+                                const config_arena = config_overrides_arena.allocator();
+                                const config = try config_arena.create(rules_configs_types[i]);
+                                errdefer config_arena.destroy(config);
 
                                 var diagnostics: zlinter.zon.Diagnostics = .{};
 
@@ -271,7 +274,7 @@ fn runLinterRules(
                                     std.fs.cwd(),
                                     zon_path,
                                     &diagnostics,
-                                    arena,
+                                    config_arena,
                                 ) catch |e| {
                                     switch (e) {
                                         error.ParseZon => {
@@ -315,15 +318,16 @@ fn runLinterRules(
             }
         }
 
-        var arena = std.heap.ArenaAllocator.init(gpa);
-        defer arena.deinit();
-        const arena_allocator = arena.allocator();
-
-        var doc = try ctx.loadDocument(lint_file.pathname, ctx.gpa, arena_allocator) orelse {
-            printer.println(.err, "Unable to open file: {s}", .{lint_file.pathname});
+        var doc: zlinter.session.LintDocument = undefined;
+        context.initDocument(
+            lint_file.pathname,
+            context.gpa,
+            &doc,
+        ) catch |e| {
+            printer.println(.err, "Unable to open file: {s} ({s})", .{ lint_file.pathname, @errorName(e) });
             continue :files;
         };
-        defer doc.deinit(ctx.gpa);
+        defer doc.deinit(context.gpa);
 
         if (timer.lapMilliseconds()) |ms|
             printer.println(.verbose, "  - Load document: {d}ms", .{ms})
@@ -370,7 +374,8 @@ fn runLinterRules(
             const rule = rules[rule_index];
             if (try rule.run(
                 rule,
-                doc,
+                &context,
+                &doc,
                 gpa,
                 .{ .config = rule_configs[rule_index] },
             )) |result| {

src/lib/ast.zig

@@ -16,7 +16,7 @@ pub const NodeAncestorIterator = struct {
     const Self = @This();
 
     current: NodeIndexShim,
-    lineage: *NodeLineage,
+    lineage: *const NodeLineage,
     done: bool = false,
 
     pub fn next(self: *Self) ?Ast.Node.Index {
@@ -37,7 +37,7 @@ pub const NodeLineageIterator = struct {
     const Self = @This();
 
     queue: shims.ArrayList(NodeIndexShim) = .empty,
-    lineage: *NodeLineage,
+    lineage: *const NodeLineage,
     gpa: std.mem.Allocator,
 
     pub fn deinit(self: *NodeLineageIterator) void {
@@ -121,7 +121,7 @@ pub const DeferBlock = struct {
     }
 };
 
-pub fn deferBlock(doc: session.LintDocument, node: Ast.Node.Index, allocator: std.mem.Allocator) !?DeferBlock {
+pub fn deferBlock(doc: *const session.LintDocument, node: Ast.Node.Index, allocator: std.mem.Allocator) !?DeferBlock {
     const tree = doc.handle.tree;
 
     const data = shims.nodeData(tree, node);
@@ -212,21 +212,20 @@ test "deferBlock - has expected children" {
 
         defer _ = arena.reset(.retain_capacity);
 
-        var ctx: session.LintContext = undefined;
-        try ctx.init(.{}, arena.allocator());
-        defer ctx.deinit();
+        var context: session.LintContext = undefined;
+        try context.init(.{}, std.testing.allocator, arena.allocator());
+        defer context.deinit();
 
         var tmp = std.testing.tmpDir(.{});
         defer tmp.cleanup();
 
-        var doc = try testing.loadFakeDocument(
-            &ctx,
+        const doc = try testing.loadFakeDocument(
+            &context,
             tmp.dir,
             "test.zig",
             "fn main() void {\n" ++ source ++ "\n}",
             arena.allocator(),
         );
-        defer doc.deinit(arena.allocator());
 
         const decl_ref = try deferBlock(
             doc,
@@ -608,7 +607,7 @@ test "isEnumLiteral" {
 /// Checks whether the current node is a function call or contains one in its
 /// children.
 pub fn findFnCall(
-    doc: session.LintDocument,
+    doc: *const session.LintDocument,
     node: Ast.Node.Index,
     call_buffer: *[1]Ast.Node.Index,
     comptime names: []const []const u8,
@@ -670,7 +669,7 @@ pub const FnCall = struct {
 ///
 /// If names is empty, then it'll match all function names.
 pub fn fnCall(
-    doc: session.LintDocument,
+    doc: *const session.LintDocument,
     node: Ast.Node.Index,
     buffer: *[1]Ast.Node.Index,
     comptime names: []const []const u8,

src/lib/rules.zig

@@ -3,8 +3,9 @@ pub const LintRule = struct {
     rule_id: []const u8,
     run: *const fn (
         self: LintRule,
-        doc: session.LintDocument,
-        allocator: std.mem.Allocator,
+        context: *session.LintContext,
+        doc: *const session.LintDocument,
+        gpa: std.mem.Allocator,
         options: RunOptions,
     ) error{OutOfMemory}!?results.LintResult,
 };