Function _scan_body_lines

scripts/code_verify_rules.py:670–716

Run a list of `(regex, kind, message)` triples over each line of a function body. First-match wins per line so a single problematic expression doesn't fire every pattern. Lines skipped (all driven by AST walks for multi-line statements): - `constexpr` / `static const` declarations

(body, src: bytes, fname: str, fenced, patterns)

def _scan_body_lines(body, src: bytes, fname: str, fenced, patterns) -> list:
    """Run a list of `(regex, kind, message)` triples over each line of a
    function body. First-match wins per line so a single problematic
    expression doesn't fire every pattern.

    Lines skipped (all driven by AST walks for multi-line statements):
      - `constexpr` / `static const` declarations -- init code, not per-call
      - `[[unlikely]]`-attributed substatement bodies -- cold path
      - `catch_clause` bodies -- error / exception path, not steady-state

    Lines skipped per-pattern: reciprocal-cache declarations
    (`const T inv = 1.0 / x;`) bypass the divide rule -- they ARE the
    recommended fix for runtime-divisor cost."""
    if body is None:
        return []
    findings: list = []
    body_text = _node_text(body, src)
    body_start = body.start_point[0] + 1
    exempt_lines = _init_only_decl_line_span(body, src) | _cold_branch_line_span(
        body, src
    )
    constexpr_names = _compile_time_constants_in_scope(body, src)
    for j, line in enumerate(body_text.split("\n")):
        abs_line = body_start + j
        if fenced(abs_line) or abs_line in exempt_lines:
            continue
        scrubbed = _strip_strings_and_line_comments(line)
        is_recip_cache = _is_reciprocal_cache_line(scrubbed)
        # If every divisor / modulo on this line resolves to a constexpr
        # name we know is in scope, the compiler folds them. Skip the
        # divide/modulo runtime rules for this line.
        divisors = _DIV_OR_MOD_DIVISOR_RE.findall(scrubbed)
        all_compile_time = bool(divisors) and all(
            d in constexpr_names for d in divisors
        )
        for pat, kind, msg in patterns:
            if is_recip_cache and kind == "perf-divide-runtime-divisor":
                continue
            if all_compile_time and kind in (
                "perf-divide-runtime-divisor",
                "perf-modulo-runtime-divisor",
            ):
                continue
            if pat.search(scrubbed):
                findings.append(Finding(abs_line, kind, msg))
                break
    return findings


def _recursion_findings(func_node, fname: str, body, src: bytes, fenced) -> list: