Eliminate NOLINTNEXTLINE suppressions + iterative AST walkers

Remove ~480 dead per-line NOLINTNEXTLINE comments. Update .clang-tidy with
documented upstream bug references for disabled checks.

Convert key AST walkers to iterative with explicit stacks: walk_defs (with
context-aware stack frames for class nesting), walk_throws, walk_readwrites,
walk_calls, walk_usages, walk_env_accesses, extract_elixir_call, glob_match,
cbm_yaml_free, rmdir_recursive, resolve_func_name, walk_variables_iter,
count_branching. Reversed child push for left-to-right traversal.

Disable readability-implicit-bool-conversion globally — designed for C++,
flags all idiomatic C patterns (bool = x && y) with no config to allow them.

Fix clang-format, implicit-bool edge cases, add test_helpers.h.

Author: DeusData

.clang-tidy

@@ -2,6 +2,32 @@
 #
 # ALL checks enabled. WarningsAsErrors: '*'.
 # Check thresholds configured for idiomatic C11 (not C++).
+#
+# Globally disabled checks must have an upstream bug reference or
+# architectural justification. Re-evaluate on LLVM upgrades.
+#
+# Documented LLVM false positives:
+#   bugprone-multi-level-implicit-pointer-conversion  — LLVM #93959, relaxed in LLVM 19
+#   clang-analyzer-security.insecureAPI.DeprecatedOrUnsafeBufferHandling — LLVM #64027
+#   clang-analyzer-optin.portability.UnixAPI — malloc(0) behavior, guarded in code
+#
+# Architectural:
+#   bugprone-command-processor — popen required for git, inputs validated
+#   cert-env33-c — popen/system needed for git commands, inputs validated
+#
+# Pending fix (phases 4-6):
+#   bugprone-easily-swappable-parameters — Phase 5: struct params
+#   concurrency-mt-unsafe — Phase 4: thread-safe wrappers
+#   cert-err33-c — Phase 4: check fwrite/fseek return values
+#   performance-no-int-to-ptr — Phase 4: union type-punning
+#   bugprone-branch-clone — Phase 6
+#   readability-avoid-nested-conditional-operator — Phase 6
+#   readability-redundant-casting — Phase 6
+#   bugprone-implicit-widening-of-multiplication-result — Phase 6
+#   bugprone-unchecked-string-to-number-conversion — Phase 6
+#   clang-analyzer-core.CallAndMessage — Phase 6
+#   clang-analyzer-core.NullPointerArithm — Phase 6
+#   clang-analyzer-security.insecureAPI.strcpy — Phase 6
 
 Checks: >
   -*,
@@ -16,41 +42,39 @@ Checks: >
   readability-*,
   clang-analyzer-*,
   -misc-no-recursion,
+  -readability-implicit-bool-conversion,
   -bugprone-multi-level-implicit-pointer-conversion,
-  -bugprone-branch-clone,
+  -clang-analyzer-security.insecureAPI.DeprecatedOrUnsafeBufferHandling,
+  -clang-analyzer-optin.portability.UnixAPI,
+  -clang-analyzer-security.ArrayBound,
+  -clang-analyzer-unix.Malloc,
+  -misc-include-cleaner,
   -bugprone-command-processor,
+  -cert-env33-c,
+  -bugprone-easily-swappable-parameters,
+  -concurrency-mt-unsafe,
+  -cert-err33-c,
+  -performance-no-int-to-ptr,
+  -bugprone-branch-clone,
   -readability-avoid-nested-conditional-operator,
   -readability-redundant-casting,
   -bugprone-implicit-widening-of-multiplication-result,
   -bugprone-unchecked-string-to-number-conversion,
-  -bugprone-easily-swappable-parameters,
   -clang-analyzer-core.CallAndMessage,
-  -clang-analyzer-security.ArrayBound,
-  -clang-analyzer-unix.Malloc,
-  -clang-analyzer-optin.portability.UnixAPI,
   -clang-analyzer-core.NullPointerArithm,
-  -performance-no-int-to-ptr,
-  -concurrency-mt-unsafe,
-  -cert-err33-c,
-  -clang-analyzer-security.insecureAPI.DeprecatedOrUnsafeBufferHandling,
   -clang-analyzer-security.insecureAPI.strcpy,
-  -misc-include-cleaner,
 
 WarningsAsErrors: '*'
 
 CheckOptions:
   bugprone-implicit-widening-of-multiplication-result.UseCXXStaticCastsInCppSources: false
-  # C idiom: i, j, k, n, p, s are standard variable names
   readability-identifier-length.MinimumVariableNameLength: 1
   readability-identifier-length.MinimumParameterNameLength: 1
   readability-identifier-length.MinimumLoopCounterNameLength: 1
-  # C idiom: if (!ptr), if (count) are standard
   readability-implicit-bool-conversion.AllowIntegerConditions: true
   readability-implicit-bool-conversion.AllowPointerConditions: true
-  # Systems C uses bit shifts, buffer sizes, hash constants, protocol sizes
   readability-magic-numbers.IgnoredIntegerValues: "1;2;3;4;5;6;7;8;9;10;11;12;14;15;16;20;24;32;48;64;100;128;200;256;493;512;755;1000;1024;1040;2048;4096;8192;16384;32768;65536;500000;1000000;1000000000"
   readability-magic-numbers.IgnoredFloatingPointValues: "0.0;0.25;0.5;0.7;0.75;0.8;0.85;0.9;0.95;1.0;2.0;100.0;1e308"
-  # Cypher parser + tree-sitter resolver have deeply nested execution logic
   readability-function-cognitive-complexity.Threshold: 250
   readability-function-size.StatementThreshold: 400
   readability-function-size.LineThreshold: 800

internal/cbm/ac.c

@@ -45,12 +45,10 @@ typedef struct {
 
 static void queue_init(Queue *q, int cap) {
     q->data = (int *)malloc(cap * sizeof(int));
-    // NOLINTNEXTLINE(clang-analyzer-security.ArrayBound)
     q->head = q->tail = 0;
     q->cap = cap;
 }
 static void queue_push(Queue *q, int v) {
-    // NOLINTNEXTLINE(clang-analyzer-security.ArrayBound)
     q->data[q->tail++] = v;
 }
 static int queue_pop(Queue *q) {
@@ -128,7 +126,6 @@ CBMAutomaton *cbm_ac_build(const char **patterns, const int *lengths, int count,
         }
         // Mark this state as accepting pattern p.
         if (p < CBM_AC_MAX_BITMASK) {
-            // NOLINTNEXTLINE(clang-analyzer-security.ArrayBound)
             ac->output[state] |= (1ULL << p);
         }
         // Append to output list.
@@ -147,15 +144,12 @@ CBMAutomaton *cbm_ac_build(const char **patterns, const int *lengths, int count,
     int *fail = (int *)calloc(num_states, sizeof(int));
 
     Queue q;
-    // NOLINTNEXTLINE(clang-analyzer-security.ArrayBound)
     queue_init(&q, num_states);
 
     // Depth-1 states: failure → root.
     for (int c = 0; c < alpha_size; c++) {
-        // NOLINTNEXTLINE(clang-analyzer-security.ArrayBound)
         int s = ac->go_table[c]; // root's goto for c
         if (s != 0) {
-            // NOLINTNEXTLINE(clang-analyzer-security.ArrayBound)
             fail[s] = 0;
             queue_push(&q, s);
         }
@@ -166,11 +160,9 @@ CBMAutomaton *cbm_ac_build(const char **patterns, const int *lengths, int count,
         int r = queue_pop(&q);
         for (int c = 0; c < alpha_size; c++) {
             int idx = (r * alpha_size) + c;
-            // NOLINTNEXTLINE(clang-analyzer-security.ArrayBound)
             int s = ac->go_table[idx];
             if (s != -1) {
                 // s exists in trie
-                // NOLINTNEXTLINE(clang-analyzer-security.ArrayBound)
                 fail[s] = ac->go_table[(fail[r] * alpha_size) + c];
                 // Merge output: dictionary suffix links.
                 ac->output[s] |= ac->output[fail[s]];
@@ -250,7 +242,6 @@ uint64_t cbm_ac_scan_bitmask(const CBMAutomaton *ac, const char *text, int text_
 
 // Thread-local reusable decompression buffer to avoid repeated malloc/free.
 // Each goroutine gets its own OS thread (via CGo), so CBM_TLS is safe.
-// NOLINTNEXTLINE(clang-analyzer-optin.portability.UnixAPI)
 static CBM_TLS char *tls_decomp_buf = NULL;
 static CBM_TLS int tls_decomp_cap = 0;
 
@@ -259,7 +250,6 @@ static char *get_decomp_buf(int needed) {
         free(tls_decomp_buf);
         // Round up to 64KB chunks for reuse.
         int cap = (needed + DECOMP_BUF_ALIGN_MASK) & ~DECOMP_BUF_ALIGN_MASK;
-        // NOLINTNEXTLINE(clang-analyzer-optin.portability.UnixAPI)
         tls_decomp_buf = (char *)malloc((size_t)cap);
         tls_decomp_cap = cap;
     }
@@ -364,7 +354,6 @@ int cbm_ac_scan_lz4_batch(const CBMAutomaton *ac, const CBMLz4Entry *entries, in
 //   num_names    — number of names
 //   out_matches  — output buffer for (name_index, pattern_id) pairs
 //   max_matches  — capacity of out_matches
-// NOLINTNEXTLINE(bugprone-easily-swappable-parameters)
 int cbm_ac_scan_batch(const CBMAutomaton *ac, const char *names_buf, const int *name_offsets,
                       const int *name_lengths, int num_names, CBMMatchResult *out_matches,
                       int max_matches) {

internal/cbm/cbm.c

@@ -27,13 +27,11 @@ static _Atomic uint64_t total_files = 0;
 
 static uint64_t now_ns(void) {
     struct timespec ts;
-    // NOLINTNEXTLINE(misc-include-cleaner) — clock_gettime provided by standard header
     cbm_clock_gettime(CLOCK_MONOTONIC, &ts);
     return ((uint64_t)ts.tv_sec * NSEC_PER_SEC) + (uint64_t)ts.tv_nsec;
 }
 
 // cbm_get_profile returns accumulated parse/extract times and file count.
-// NOLINTNEXTLINE(bugprone-easily-swappable-parameters)
 void cbm_get_profile(uint64_t *parse_ns, uint64_t *extract_ns, uint64_t *files) {
     *parse_ns = atomic_load(&total_parse_ns);
     *extract_ns = atomic_load(&total_extract_ns);

internal/cbm/extract_calls.c

@@ -42,7 +42,7 @@ static const char *strip_quotes(CBMArena *a, const char *text) {
 }
 
 // Forward declarations
-static void walk_calls(CBMExtractCtx *ctx, TSNode node, const CBMLangSpec *spec);
+static void walk_calls(CBMExtractCtx *ctx, TSNode root, const CBMLangSpec *spec);
 static char *extract_callee_name(CBMArena *a, TSNode node, const char *source, CBMLanguage lang);
 static void extract_jsx_refs(CBMExtractCtx *ctx, TSNode node);
 
@@ -276,77 +276,75 @@ static char *extract_callee_name(CBMArena *a, TSNode node, const char *source, C
     return NULL;
 }
 
-// Walk AST for call nodes
-// NOLINTNEXTLINE(misc-no-recursion) — intentional AST tree walk
-static void walk_calls(CBMExtractCtx *ctx, TSNode node, const CBMLangSpec *spec) {
-    const char *kind = ts_node_type(node);
-
-    if (cbm_kind_in_set(node, spec->call_node_types)) {
-        char *callee = extract_callee_name(ctx->arena, node, ctx->source, ctx->language);
-        if (callee && callee[0]) {
-            // Skip keywords
-            if (!cbm_is_keyword(callee, ctx->language)) {
-                CBMCall call = {0};
-                call.callee_name = callee;
-                call.enclosing_func_qn = cbm_enclosing_func_qn_cached(ctx, node);
-                call.first_string_arg = NULL;
-
-                /* Extract first string literal argument (URL, topic, key) */
-                TSNode args = ts_node_child_by_field_name(node, "arguments", 9);
-                if (!ts_node_is_null(args)) {
-                    uint32_t nc = ts_node_named_child_count(args);
-                    for (uint32_t ai = 0; ai < nc && ai < 3; ai++) {
-                        TSNode arg = ts_node_named_child(args, ai);
-                        const char *ak = ts_node_type(arg);
-                        if (strcmp(ak, "string") == 0 || strcmp(ak, "string_literal") == 0 ||
-                            strcmp(ak, "interpreted_string_literal") == 0 ||
-                            strcmp(ak, "raw_string_literal") == 0 ||
-                            strcmp(ak, "string_content") == 0) {
-                            char *text = cbm_node_text(ctx->arena, arg, ctx->source);
-                            if (text && text[0]) {
-                                /* Strip quotes */
-                                int len = (int)strlen(text);
-                                if (len >= 2 && (text[0] == '"' || text[0] == '\'')) {
-                                    text =
-                                        cbm_arena_strndup(ctx->arena, text + 1, (size_t)(len - 2));
-                                    len -= 2;
-                                }
-                                /* Validate: must be printable ASCII, no control chars */
-                                // NOLINTNEXTLINE(readability-implicit-bool-conversion)
-                                bool valid = (text != NULL && len > 0 && len < 512);
-                                for (int vi = 0; vi < len && valid; vi++) {
-                                    unsigned char ch = (unsigned char)text[vi];
-                                    if (ch < 0x20 && ch != '\t') {
-                                        valid = false;
+// Walk AST for call nodes (iterative)
+#define CALLS_STACK_CAP 512
+static void walk_calls(CBMExtractCtx *ctx, TSNode root, const CBMLangSpec *spec) {
+    TSNode stack[CALLS_STACK_CAP];
+    int top = 0;
+    stack[top++] = root;
+
+    while (top > 0) {
+        TSNode node = stack[--top];
+        const char *kind = ts_node_type(node);
+
+        if (cbm_kind_in_set(node, spec->call_node_types)) {
+            char *callee = extract_callee_name(ctx->arena, node, ctx->source, ctx->language);
+            if (callee && callee[0]) {
+                if (!cbm_is_keyword(callee, ctx->language)) {
+                    CBMCall call = {0};
+                    call.callee_name = callee;
+                    call.enclosing_func_qn = cbm_enclosing_func_qn_cached(ctx, node);
+                    call.first_string_arg = NULL;
+
+                    TSNode args = ts_node_child_by_field_name(node, "arguments", 9);
+                    if (!ts_node_is_null(args)) {
+                        uint32_t nc = ts_node_named_child_count(args);
+                        for (uint32_t ai = 0; ai < nc && ai < 3; ai++) {
+                            TSNode arg = ts_node_named_child(args, ai);
+                            const char *ak = ts_node_type(arg);
+                            if (strcmp(ak, "string") == 0 || strcmp(ak, "string_literal") == 0 ||
+                                strcmp(ak, "interpreted_string_literal") == 0 ||
+                                strcmp(ak, "raw_string_literal") == 0 ||
+                                strcmp(ak, "string_content") == 0) {
+                                char *text = cbm_node_text(ctx->arena, arg, ctx->source);
+                                if (text && text[0]) {
+                                    int len = (int)strlen(text);
+                                    if (len >= 2 && (text[0] == '"' || text[0] == '\'')) {
+                                        text = cbm_arena_strndup(ctx->arena, text + 1,
+                                                                 (size_t)(len - 2));
+                                        len -= 2;
+                                    }
+                                    bool valid = (text != NULL && len > 0 && len < 512);
+                                    for (int vi = 0; vi < len && valid; vi++) {
+                                        unsigned char ch = (unsigned char)text[vi];
+                                        if (ch < 0x20 && ch != '\t') {
+                                            valid = false;
+                                        }
+                                    }
+                                    if (valid) {
+                                        call.first_string_arg = text;
                                     }
                                 }
-                                if (valid) {
-                                    call.first_string_arg = text;
-                                }
+                                break;
                             }
-                            break;
                         }
                     }
+                    cbm_calls_push(&ctx->result->calls, ctx->arena, call);
                 }
-
-                cbm_calls_push(&ctx->result->calls, ctx->arena, call);
             }
         }
-        // Don't recurse into call arguments for nested calls — the walk handles that
-    }
 
-    // JSX component refs (TSX/JSX)
-    if (ctx->language == CBM_LANG_TSX || ctx->language == CBM_LANG_JAVASCRIPT) {
-        if (strcmp(kind, "jsx_self_closing_element") == 0 ||
-            strcmp(kind, "jsx_opening_element") == 0) {
-            extract_jsx_refs(ctx, node);
+        if (ctx->language == CBM_LANG_TSX || ctx->language == CBM_LANG_JAVASCRIPT) {
+            if (strcmp(kind, "jsx_self_closing_element") == 0 ||
+                strcmp(kind, "jsx_opening_element") == 0) {
+                extract_jsx_refs(ctx, node);
+            }
         }
-    }
 
-    // Recurse
-    uint32_t count = ts_node_child_count(node);
-    for (uint32_t i = 0; i < count; i++) {
-        walk_calls(ctx, ts_node_child(node, i), spec);
+        uint32_t count = ts_node_child_count(node);
+        for (int i = (int)count - 1; i >= 0 && top < CALLS_STACK_CAP; i--) {
+            stack[top++] = ts_node_child(node, (uint32_t)i);
+        }
     }
 }
 
@@ -542,7 +540,6 @@ void handle_calls(CBMExtractCtx *ctx, TSNode node, const CBMLangSpec *spec, Walk
                                     len -= 2;
                                 }
                                 /* Validate printable */
-                                // NOLINTNEXTLINE(readability-implicit-bool-conversion)
                                 bool valid = (text != NULL && len > 0 && len < 512);
                                 for (int vi = 0; vi < len && valid; vi++) {
                                     if ((unsigned char)text[vi] < 0x20 && text[vi] != '\t') {