rigortype 0.2.7 → 0.2.9

data/lib/rigor/analysis/baseline.rb

@@ -6,9 +6,8 @@ module Rigor
   module Analysis
     # ADR-22 Slice 1 — PHPStan-shaped per-project baseline.
     #
-    # Loads `.rigor-baseline.yml`, filters a current run's
-    # diagnostic stream against the recorded buckets, and emits
-    # an `(surfaced, silenced_count)` pair for the CLI to render.
+    # Loads `.rigor-baseline.yml`, filters a current run's diagnostic stream against the recorded buckets, and
+    # emits an `(surfaced, silenced_count)` pair for the CLI to render.
     #
     # Two row shapes are accepted (WD1):
     #
@@ -27,17 +26,13 @@ module Rigor
     # ## Semantics per (file, rule [, message]) bucket (WD4)
     #
     #   actual <= count    → ALL diagnostics in the bucket are silenced.
-    #   actual >  count    → ALL diagnostics in the bucket surface
-    #                        (not just the excess delta — the bucket
-    #                        has crossed its threshold; the team's
-    #                        review focus shifts from "which N is new"
-    #                        to "what's going on with this rule in
-    #                        this file as a whole").
+    #   actual >  count    → ALL diagnostics in the bucket surface (not just the excess delta — the bucket has
+    #                        crossed its threshold; the team's review focus shifts from "which N is new" to
+    #                        "what's going on with this rule in this file as a whole").
     #
     # ## Filter pipeline position (WD6)
     #
-    # The baseline filter runs LAST among the diagnostic-suppression
-    # layers:
+    # The baseline filter runs LAST among the diagnostic-suppression layers:
     #
     #   emit →  `# rigor:disable` (per-line)
     #        →  `# rigor:disable-file`
@@ -47,41 +42,32 @@ module Rigor
     #
     # ## Loading (WD2 (b))
     #
-    # `Baseline.load` is called by the CLI when it has resolved
-    # an explicit baseline path (from `--baseline=PATH` on the
-    # CLI or `baseline: <path>` in `.rigor.yml`). The presence
-    # of `.rigor-baseline.yml` on disk alone never triggers a
-    # load — that's the CLI / Configuration's job to enforce.
+    # `Baseline.load` is called by the CLI when it has resolved an explicit baseline path (from `--baseline=PATH`
+    # on the CLI or `baseline: <path>` in `.rigor.yml`). The presence of `.rigor-baseline.yml` on disk alone
+    # never triggers a load — that's the CLI / Configuration's job to enforce.
     #
     # ## Path handling
     #
-    # Baselines store file paths **relative to the project root**
-    # (the working directory when `rigor` is run). This makes the
-    # generated `.rigor-baseline.yml` portable across machines and
-    # checkout locations. When filtering a live diagnostic stream,
-    # the instance normalises each diagnostic's absolute path to a
-    # relative one before the bucket lookup.
+    # Baselines store file paths **relative to the project root** (the working directory when `rigor` is run).
+    # This makes the generated `.rigor-baseline.yml` portable across machines and checkout locations. When
+    # filtering a live diagnostic stream, the instance normalises each diagnostic's absolute path to a relative
+    # one before the bucket lookup.
     class Baseline
-      # The bucket key is intentionally tuple-shaped so rule-ID
-      # rows and message-pattern rows can coexist in a single
-      # multimap. `message` is `nil` for rule-ID rows; a Regexp
-      # for message-pattern rows.
-      # `count` shadows Struct#count; intentional — `count` is the
-      # PHPStan-compatible field name and we don't use the
-      # Enumerable-style `Struct#count` on Bucket instances.
+      # The bucket key is intentionally tuple-shaped so rule-ID rows and message-pattern rows can coexist in a
+      # single multimap. `message` is `nil` for rule-ID rows; a Regexp for message-pattern rows.
+      # `count` shadows Struct#count; intentional — `count` is the PHPStan-compatible field name and we don't
+      # use the Enumerable-style `Struct#count` on Bucket instances.
       Bucket = Struct.new(:file, :rule, :message_regex, :count, keyword_init: true) # rubocop:disable Lint/StructNewOverride
 
       CURRENT_VERSION = 1
 
       class << self
-        # Load a baseline file from disk. Returns `nil` when the
-        # path is nil (the caller's "no baseline configured"
-        # state). Raises {LoadError} on malformed content;
-        # callers translate to a user-facing diagnostic.
+        # Load a baseline file from disk. Returns `nil` when the path is nil (the caller's "no baseline
+        # configured" state). Raises {LoadError} on malformed content; callers translate to a user-facing
+        # diagnostic.
         #
-        # `project_root:` is the working directory against which
-        # stored relative paths are resolved during filtering.
-        # Defaults to `Dir.pwd`.
+        # `project_root:` is the working directory against which stored relative paths are resolved during
+        # filtering. Defaults to `Dir.pwd`.
         def load(path, project_root: Dir.pwd)
           return nil if path.nil?
           return new([], project_root: project_root) unless File.exist?(path)
@@ -90,15 +76,12 @@ module Rigor
           parse_loaded(raw, path: path, project_root: project_root)
         end
 
-        # Build a baseline from a current run's diagnostic stream.
-        # `match_mode:` is `:rule` (default) or `:message`. The
-        # message-mode generator passes literal messages through
-        # `Regexp.escape` so generated rows never accidentally
-        # over-match on punctuation.
+        # Build a baseline from a current run's diagnostic stream. `match_mode:` is `:rule` (default) or
+        # `:message`. The message-mode generator passes literal messages through `Regexp.escape` so generated
+        # rows never accidentally over-match on punctuation.
         #
-        # `project_root:` is used to convert absolute diagnostic
-        # paths to relative paths in the generated YAML. Defaults
-        # to `Dir.pwd`.
+        # `project_root:` is used to convert absolute diagnostic paths to relative paths in the generated YAML.
+        # Defaults to `Dir.pwd`.
         def from_diagnostics(diagnostics, match_mode: :rule, project_root: Dir.pwd)
           raise ArgumentError, "match_mode must be :rule or :message" unless %i[rule message].include?(match_mode)
 
@@ -177,11 +160,9 @@ module Rigor
           end
         end
 
-        # Generates a Regexp source string for the baseline row.
-        # The string is `Regexp.escape`d so the YAML round-trip
-        # produces a regex that matches the literal message.
-        # Users hand-editing the row can replace the escaped
-        # form with a pattern.
+        # Generates a Regexp source string for the baseline row. The string is `Regexp.escape`d so the YAML
+        # round-trip produces a regex that matches the literal message. Users hand-editing the row can replace
+        # the escaped form with a pattern.
         def message_pattern_for(message)
           Regexp.new(Regexp.escape(message.to_s))
         end
@@ -203,10 +184,8 @@ module Rigor
         # For each (file, qualified_rule) pair, two arrays:
         # - rule-ID rows (message_regex == nil)
         # - message-pattern rows (message_regex != nil)
-        # The matcher walks message-pattern rows first (tighter
-        # match takes precedence); diagnostics that don't match
-        # any message row fall through to the rule-ID row if
-        # one exists.
+        # The matcher walks message-pattern rows first (tighter match takes precedence); diagnostics that
+        # don't match any message row fall through to the rule-ID row if one exists.
         @by_pair = buckets.group_by { |b| [b.file, b.rule] }.freeze
         freeze
       end
@@ -214,10 +193,8 @@ module Rigor
       # Apply the baseline filter to a diagnostic stream.
       #
       # Returns a 2-tuple:
-      # - `surfaced` — the diagnostics that survived the filter
-      #   (new findings + entire over-threshold buckets).
-      # - `silenced_count` — how many diagnostics the baseline
-      #   suppressed (for the WD7 stderr summary line).
+      # - `surfaced` — the diagnostics that survived the filter (new findings + entire over-threshold buckets).
+      # - `silenced_count` — how many diagnostics the baseline suppressed (for the WD7 stderr summary line).
       def filter(diagnostics)
         return [diagnostics, 0] if buckets.empty?
 
@@ -228,10 +205,8 @@ module Rigor
         grouped.each_value do |entries|
           bucket = entries[:bucket]
           diags = entries[:diagnostics]
-          # No matching bucket → all surface as new findings.
-          # `actual <= count` → all silenced (within threshold,
-          # WD4). `actual >  count` → all surface (over
-          # threshold, WD4).
+          # No matching bucket → all surface as new findings. `actual <= count` → all silenced (within
+          # threshold, WD4). `actual >  count` → all surface (over threshold, WD4).
           if bucket && diags.size <= bucket.count
             silenced_count += diags.size
           else
@@ -239,39 +214,31 @@ module Rigor
           end
         end
 
-        # Diagnostics that lacked a rule or a path bypass the
-        # baseline entirely (the baseline can't address them).
+        # Diagnostics that lacked a rule or a path bypass the baseline entirely (the baseline can't address
+        # them).
         unkeyable = diagnostics.reject { |d| d.qualified_rule && d.path }
         [surfaced + unkeyable, silenced_count]
       end
 
-      # A single bucket's drift state for slice 2 inspection.
-      # `status` is one of:
+      # A single bucket's drift state for slice 2 inspection. `status` is one of:
       #
       # - `:within`    — `actual <= count` (silenced by the filter).
-      # - `:over`      — `actual > count` (over threshold; surfaced
-      #                  in the regular `rigor check` output).
+      # - `:over`      — `actual > count` (over threshold; surfaced in the regular `rigor check` output).
       # - `:cleared`   — `actual == 0` (the bucket can be pruned).
-      # - `:reducible` — `0 < actual < count` (the bucket's count
-      #                  can be tightened; future `regenerate`
-      #                  slice 5 handles this).
+      # - `:reducible` — `0 < actual < count` (the bucket's count can be tightened; future `regenerate` slice 5
+      #                  handles this).
       DriftRow = Struct.new(:bucket, :actual_count, :status, keyword_init: true) do
         def delta
           actual_count - bucket.count
         end
       end
 
-      # Walk the current diagnostic stream and report
-      # bucket-level drift. Each baseline bucket becomes one
-      # DriftRow regardless of whether the current run still
-      # matches it.
+      # Walk the current diagnostic stream and report bucket-level drift. Each baseline bucket becomes one
+      # DriftRow regardless of whether the current run still matches it.
       #
-      # @param diagnostics [Array<Diagnostic>] current run's
-      #   diagnostic stream (PRE-filter — pass the raw
-      #   `result.diagnostics` from `Runner#run`, not the
-      #   post-baseline surface).
-      # @return [Array<DriftRow>] one entry per baseline bucket,
-      #   in baseline-file order.
+      # @param diagnostics [Array<Diagnostic>] current run's diagnostic stream (PRE-filter — pass the raw
+      #   `result.diagnostics` from `Runner#run`, not the post-baseline surface).
+      # @return [Array<DriftRow>] one entry per baseline bucket, in baseline-file order.
       def audit(diagnostics)
         counts = Hash.new(0)
         diagnostics.each do |diag|
@@ -287,18 +254,15 @@ module Rigor
         end
       end
 
-      # Returns a new Baseline with the given buckets dropped.
-      # Used by `rigor baseline prune` (slice 2) to remove
-      # cleared buckets (`actual == 0`) from the on-disk file.
+      # Returns a new Baseline with the given buckets dropped. Used by `rigor baseline prune` (slice 2) to
+      # remove cleared buckets (`actual == 0`) from the on-disk file.
       def without(buckets_to_drop)
         dropset = buckets_to_drop.to_set
         self.class.new(buckets.reject { |b| dropset.include?(b) }, project_root: @project_root)
       end
 
-      # Serialise to a YAML string. The generator path writes
-      # this through `File.write`; the dump format is stable
-      # across versions of this class as long as the bucket
-      # shape is unchanged.
+      # Serialise to a YAML string. The generator path writes this through `File.write`; the dump format is
+      # stable across versions of this class as long as the bucket shape is unchanged.
       def to_yaml
         rows = buckets.map do |bucket|
           row = { "file" => bucket.file, "rule" => bucket.rule }
@@ -311,8 +275,7 @@ module Rigor
         YAML.dump(document)
       end
 
-      # The number of buckets recorded. Useful for the CLI
-      # summary on `generate`.
+      # The number of buckets recorded. Useful for the CLI summary on `generate`.
       def size
         buckets.size
       end
@@ -344,11 +307,9 @@ module Rigor
       end
 
       def group_diagnostics_for_filtering(diagnostics)
-        # First pass: bin each diagnostic into the bucket that
-        # claims it. Message-pattern rows take precedence over
-        # rule-ID rows because they're more specific. A
-        # diagnostic that matches no row goes into a synthetic
-        # "no-bucket" bin keyed by (file, rule).
+        # First pass: bin each diagnostic into the bucket that claims it. Message-pattern rows take precedence
+        # over rule-ID rows because they're more specific. A diagnostic that matches no row goes into a
+        # synthetic "no-bucket" bin keyed by (file, rule).
         bins = {}
         diagnostics.each do |diag|
           next if diag.qualified_rule.nil? || diag.path.nil?
@@ -370,8 +331,7 @@ module Rigor
         candidates = @by_pair[[normalize_path(diagnostic.path), diagnostic.qualified_rule]]
         return nil if candidates.nil? || candidates.empty?
 
-        # Tighter (message-pattern) buckets first, then the
-        # rule-ID bucket as fallback.
+        # Tighter (message-pattern) buckets first, then the rule-ID bucket as fallback.
         message_buckets, rule_buckets = candidates.partition(&:message_regex)
         message_buckets.each do |b|
           return b if b.message_regex.match?(diagnostic.message.to_s)

data/lib/rigor/analysis/buffer_binding.rb

@@ -2,32 +2,25 @@
 
 module Rigor
   module Analysis
-    # Binds one logical project path (the path the user is editing,
-    # e.g. `lib/foo.rb`) to a physical file containing the in-flight
-    # buffer bytes (e.g. `/tmp/9539itfeh2.rb`). When the runner /
-    # workers / pre-passes need to read source for the logical path,
-    # they read from the physical path instead; when they emit a
-    # `Diagnostic`, the path is the logical one so editors highlight
-    # the buffer the user is actually looking at.
+    # Binds one logical project path (the path the user is editing, e.g. `lib/foo.rb`) to a physical file
+    # containing the in-flight buffer bytes (e.g. `/tmp/9539itfeh2.rb`). When the runner / workers / pre-passes
+    # need to read source for the logical path, they read from the physical path instead; when they emit a
+    # `Diagnostic`, the path is the logical one so editors highlight the buffer the user is actually looking at.
     #
-    # See `docs/design/20260516-editor-mode.md` for the design.
-    # The CLI surfaces this through paired `--tmp-file` /
-    # `--instead-of` flags on `rigor check` and `rigor type-of`;
-    # programmatic callers pass a `BufferBinding` to `Runner.new`.
+    # See `docs/design/20260516-editor-mode.md` for the design. The CLI surfaces this through paired
+    # `--tmp-file` / `--instead-of` flags on `rigor check` and `rigor type-of`; programmatic callers pass a
+    # `BufferBinding` to `Runner.new`.
     BufferBinding = Data.define(:logical_path, :physical_path) do
-      # Returns the physical path to read bytes from when the caller
-      # is about to parse `path`. For non-logical paths returns the
-      # input unchanged. Cheap to call on every path; the binding is
-      # singular today (one buffer per run).
+      # Returns the physical path to read bytes from when the caller is about to parse `path`. For non-logical
+      # paths returns the input unchanged. Cheap to call on every path; the binding is singular today (one
+      # buffer per run).
       def resolve(path)
         path == logical_path ? physical_path : path
       end
 
-      # Returns the path the caller should report in user-facing
-      # output (diagnostics, run stats) when it currently holds the
-      # physical path. The inverse of `#resolve`. Non-physical paths
-      # pass through unchanged, so it is safe to stamp every
-      # outgoing path through this helper.
+      # Returns the path the caller should report in user-facing output (diagnostics, run stats) when it
+      # currently holds the physical path. The inverse of `#resolve`. Non-physical paths pass through
+      # unchanged, so it is safe to stamp every outgoing path through this helper.
       def display_path(path)
         path == physical_path ? logical_path : path
       end

data/lib/rigor/analysis/check_rules/always_truthy_condition_collector.rb

@@ -5,44 +5,29 @@ require "prism"
 module Rigor
   module Analysis
     module CheckRules
-      # Walks a parse tree and collects every `IfNode` / `UnlessNode`
-      # whose predicate folds to a `Type::Constant` AND is NOT
-      # disqualified by the rule's conservative envelope.
+      # Walks a parse tree and collects every `IfNode` / `UnlessNode` whose predicate folds to a
+      # `Type::Constant` AND is NOT disqualified by the rule's conservative envelope.
       #
-      # The companion rule (`flow.always-truthy-condition`) is
-      # the inferred-constant counterpart to
-      # `flow.unreachable-branch` (which only fires on syntactic
-      # literals). The literal-only rule was the v0.1.2 first-cut
-      # because Rigor's incomplete loop / mutation / RBS-strictness
-      # modelling produces inferred constants that look real but
-      # are pragmatically false-positives. This collector adds two
-      # surgical skips to bring the inferred-constant case in
-      # without resurfacing those false positives:
+      # The companion rule (`flow.always-truthy-condition`) is the inferred-constant counterpart to
+      # `flow.unreachable-branch` (which only fires on syntactic literals). The literal-only rule was the
+      # v0.1.2 first-cut because Rigor's incomplete loop / mutation / RBS-strictness modelling produces
+      # inferred constants that look real but are pragmatically false-positives. This collector adds two
+      # surgical skips to bring the inferred-constant case in without resurfacing those false positives:
       #
-      # - **Inside a loop / block**: predicates nested inside
-      #   `WhileNode` / `UntilNode` / `ForNode` / `BlockNode`
-      #   ancestors. Mutation tracking through loop bodies is
-      #   incomplete (`shift = 0; loop { shift += 7 }` keeps
-      #   `shift` at `Constant<7>` per the analyzer), so a
-      #   `Constant<bool>` predicate inside the loop body is
-      #   suspect.
-      # - **Defensive predicate calls**: `.nil?` / `.empty?` /
-      #   `.zero?` / `.any?` / `.none?` / `.all?`. These read
-      #   like the user explicitly checking for a runtime
-      #   condition that the type system already proves can't
-      #   happen — Rigor's strict-on-returns RBS often disagrees
-      #   with the user's defensive check (e.g. `Module#name`
-      #   returns `String` per RBS but anonymous classes really
-      #   do return `nil`). Skipping these forms keeps the rule
-      #   useful for genuine logic errors without faulting
-      #   defensive code.
+      # - **Inside a loop / block**: predicates nested inside `WhileNode` / `UntilNode` / `ForNode` /
+      #   `BlockNode` ancestors. Mutation tracking through loop bodies is incomplete (`shift = 0; loop {
+      #   shift += 7 }` keeps `shift` at `Constant<7>` per the analyzer), so a `Constant<bool>` predicate
+      #   inside the loop body is suspect.
+      # - **Defensive predicate calls**: `.nil?` / `.empty?` / `.zero?` / `.any?` / `.none?` / `.all?`. These
+      #   read like the user explicitly checking for a runtime condition that the type system already proves
+      #   can't happen — Rigor's strict-on-returns RBS often disagrees with the user's defensive check (e.g.
+      #   `Module#name` returns `String` per RBS but anonymous classes really do return `nil`). Skipping
+      #   these forms keeps the rule useful for genuine logic errors without faulting defensive code.
       #
-      # Also skipped (so the literal-only `unreachable-branch`
-      # rule doesn't double-fire alongside this one):
+      # Also skipped (so the literal-only `unreachable-branch` rule doesn't double-fire alongside this one):
       #
-      # - Predicates whose direct AST shape is a literal
-      #   (`TrueNode` / `FalseNode` / `NilNode` / numeric / string
-      #   / symbol / regexp).
+      # - Predicates whose direct AST shape is a literal (`TrueNode` / `FalseNode` / `NilNode` / numeric /
+      #   string / symbol / regexp).
       class AlwaysTruthyConditionCollector
         DEFENSIVE_PREDICATES = %i[nil? empty? zero? any? none? all? respond_to?].freeze
         LOOP_OR_BLOCK_NODE_CLASSES = [
@@ -56,34 +41,30 @@ module Rigor
 
         Result = Data.define(:node, :polarity)
 
-        # ADR-53 Track B — the node classes the shared {RuleWalk}
-        # dispatches to this collector, and the context gate under which
-        # the walk suppresses it (loop / block bodies — see the envelope
-        # above). The legacy walk's `!in_loop_or_block` guard is now the
-        # walk's `:loop_or_block` gate, applied before `#visit`.
+        # ADR-53 Track B — the node classes the shared {RuleWalk} dispatches to this collector, and the
+        # context gate under which the walk suppresses it (loop / block bodies — see the envelope above). The
+        # legacy walk's `!in_loop_or_block` guard is now the walk's `:loop_or_block` gate, applied before
+        # `#visit`.
         NODE_CLASSES = [Prism::IfNode, Prism::UnlessNode].freeze
         RULE_WALK_GATES = [:loop_or_block].freeze
 
-        # @return [Array<Result>] one entry per qualifying
-        #   predicate. Empty when the tree carries no firing
+        # @return [Array<Result>] one entry per qualifying predicate. Empty when the tree carries no firing
         #   predicates.
         def initialize(scope_index)
           @scope_index = scope_index
           @results = []
         end
 
-        # Legacy single-collector walk — kept as the oracle the
-        # ADR-53 Track B equivalence harness compares {RuleWalk}
-        # against; deleted when Track B completes.
+        # Legacy single-collector walk — kept as the oracle the ADR-53 Track B equivalence harness compares
+        # {RuleWalk} against; deleted when Track B completes.
         def collect(root)
           walk(root, in_loop_or_block: false)
           @results.freeze
         end
 
-        # {RuleWalk} entry point: the per-node logic of the legacy walk,
-        # invoked under the same traversal contract. The `context` is
-        # unused — the loop / block suppression this collector relied on
-        # is the walk's `:loop_or_block` gate now.
+        # {RuleWalk} entry point: the per-node logic of the legacy walk, invoked under the same traversal
+        # contract. The `context` is unused — the loop / block suppression this collector relied on is the
+        # walk's `:loop_or_block` gate now.
         def visit(node, _context = nil)
           collect_predicate(node)
         end

data/lib/rigor/analysis/check_rules/dead_assignment_collector.rb

@@ -5,71 +5,56 @@ require "prism"
 module Rigor
   module Analysis
     module CheckRules
-      # Walks a parse tree and collects every `LocalVariableWriteNode`
-      # inside a `DefNode` body whose target name is **never read**
-      # within the same body.
+      # Walks a parse tree and collects every `LocalVariableWriteNode` inside a `DefNode` body whose target
+      # name is **never read** within the same body.
       #
-      # The collector is the read-side companion to the
-      # `def.dead-assignment` rule. v0.1.2 ships the narrowest
-      # envelope that catches the most common typo / refactoring-
-      # leftover shape ("wrote and never used") without surfacing
-      # false positives:
+      # The collector is the read-side companion to the `def.dead-assignment` rule. v0.1.2 ships the
+      # narrowest envelope that catches the most common typo / refactoring-leftover shape ("wrote and never
+      # used") without surfacing false positives:
       #
-      # - Only `Prism::DefNode` bodies are scanned. Top-level
-      #   scripts and class-body assignments are skipped — their
-      #   variable surface bleeds across requires / introspection
-      #   in ways the rule cannot reason about.
-      # - Only plain `LocalVariableWriteNode` writes are
-      #   considered. Operator-writes (`x += 1`), and-/or-writes
-      #   (`x ||= 1`), and `MultiWriteNode` destructures (`a, b =
-      #   foo`) are skipped because their write semantics are
-      #   intertwined with reads or with a wider tuple binding.
-      # - The "is this name ever read" question is answered by
-      #   any `LocalVariableReadNode` anywhere in the def
-      #   subtree — so a closure capture, a `return x`, a
-      #   block-call argument, an interpolated string all count
-      #   as a read.
-      # - A write whose name starts with `_` is skipped per the
-      #   Ruby convention that `_` / `_foo` declares
+      # - Only `Prism::DefNode` bodies are scanned. Top-level scripts and class-body assignments are
+      #   skipped — their variable surface bleeds across requires / introspection in ways the rule cannot
+      #   reason about.
+      # - Only plain `LocalVariableWriteNode` writes are considered. Operator-writes (`x += 1`), and-/or-writes
+      #   (`x ||= 1`), and `MultiWriteNode` destructures (`a, b = foo`) are skipped because their write
+      #   semantics are intertwined with reads or with a wider tuple binding.
+      # - The "is this name ever read" question is answered by any `LocalVariableReadNode` anywhere in the
+      #   def subtree — so a closure capture, a `return x`, a block-call argument, an interpolated string all
+      #   count as a read.
+      # - A write whose name starts with `_` is skipped per the Ruby convention that `_` / `_foo` declares
       #   "intentionally unused".
-      # - The last statement of a def body is skipped — Ruby's
-      #   implicit return treats `def foo; x = 1; end` as
-      #   returning `1`, so the trailing write is intentional.
+      # - The last statement of a def body is skipped — Ruby's implicit return treats `def foo; x = 1; end`
+      #   as returning `1`, so the trailing write is intentional.
       class DeadAssignmentCollector
-        # ADR-53 Track B — the node classes the shared {RuleWalk}
-        # dispatches to this collector. The legacy walk visits EVERY
-        # `DefNode` (it descends into all of them, nested defs included,
-        # processing each separately — `gather_*` barrier at nested defs
-        # so an outer def never sees an inner def's locals), so the
-        # collector needs no context gate: it fires at every `def` the
-        # shared full DFS reaches, exactly like the legacy walk.
+        # ADR-53 Track B — the node classes the shared {RuleWalk} dispatches to this collector. The legacy
+        # walk visits EVERY `DefNode` (it descends into all of them, nested defs included, processing each
+        # separately — `gather_*` barrier at nested defs so an outer def never sees an inner def's locals),
+        # so the collector needs no context gate: it fires at every `def` the shared full DFS reaches,
+        # exactly like the legacy walk.
         NODE_CLASSES = [Prism::DefNode].freeze
 
-        # Returns `Array<{def_class:, def_name:, write_node:}>`
-        # — one entry per dead-assignment write. Empty when
-        # the tree has no qualifying writes.
+        # Returns `Array<{def_class:, def_name:, write_node:}>` — one entry per dead-assignment write. Empty
+        # when the tree has no qualifying writes.
         def initialize(scope_index)
           @scope_index = scope_index
           @results = []
         end
 
-        # Legacy single-collector walk — kept as the oracle the ADR-53
-        # Track B equivalence harness compares {RuleWalk} against; deleted
-        # when Track B completes.
+        # Legacy single-collector walk — kept as the oracle the ADR-53 Track B equivalence harness compares
+        # {RuleWalk} against; deleted when Track B completes.
         def collect(root)
           walk_for_def_nodes(root)
           @results.freeze
         end
 
-        # {RuleWalk} entry point: the legacy walk's per-`def` logic,
-        # invoked at every `def` under the shared traversal contract. The
-        # `context` is unused — this collector processes all defs.
+        # {RuleWalk} entry point: the legacy walk's per-`def` logic, invoked at every `def` under the shared
+        # traversal contract. The `context` is unused — this collector processes all defs.
         def visit(def_node, _context = nil)
           collect_def_assignments(def_node)
         end
 
-        # The accumulated result, frozen the same way `#collect` returns
-        # it — used by {RuleWalk}-driven callers after the walk completes.
+        # The accumulated result, frozen the same way `#collect` returns it — used by {RuleWalk}-driven
+        # callers after the walk completes.
         def results
           @results.freeze
         end
@@ -103,9 +88,8 @@ module Rigor
           return accumulator unless node.is_a?(Prism::Node)
 
           accumulator << node.name if node.is_a?(Prism::LocalVariableReadNode)
-          # Operator/and/or-writes implicitly read the prior
-          # binding — count them too so `x = 1; x ||= 2; x` /
-          # similar shapes don't trip the rule.
+          # Operator/and/or-writes implicitly read the prior binding — count them too so `x = 1; x ||= 2; x`
+          # / similar shapes don't trip the rule.
           accumulator << node.name if reading_assignment?(node)
 
           node.compact_child_nodes.each { |child| gather_read_names(child, accumulator) }
@@ -122,8 +106,7 @@ module Rigor
           return accumulator unless node.is_a?(Prism::Node)
 
           accumulator << node if node.is_a?(Prism::LocalVariableWriteNode)
-          # Don't recurse into nested DefNodes — their bodies
-          # carry their own dead-assignment scope and the
+          # Don't recurse into nested DefNodes — their bodies carry their own dead-assignment scope and the
           # outer walker visits them separately.
           return accumulator if node.is_a?(Prism::DefNode) && !accumulator.last.equal?(node)
 
@@ -131,10 +114,8 @@ module Rigor
           accumulator
         end
 
-        # Returns the final statement of a body node, descending
-        # into wrappers Ruby preserves verbatim (`begin ... end`
-        # blocks). Used to skip the implicit-return write at the
-        # tail of a method body.
+        # Returns the final statement of a body node, descending into wrappers Ruby preserves verbatim
+        # (`begin ... end` blocks). Used to skip the implicit-return write at the tail of a method body.
         def trailing_statement(body)
           case body
           when Prism::StatementsNode then body.body.last