rigortype 0.2.7 → 0.2.8

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

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

@@ -7,70 +7,56 @@ require_relative "../../source/constant_path"
 module Rigor
   module Analysis
     module CheckRules
-      # Walks a parse tree and collects every
-      # `Prism::InstanceVariableWriteNode` inside an instance
-      # method body of a `Prism::ClassNode` / `Prism::ModuleNode`,
-      # grouped by (class qualified name, ivar name).
+      # Walks a parse tree and collects every `Prism::InstanceVariableWriteNode` inside an instance method
+      # body of a `Prism::ClassNode` / `Prism::ModuleNode`, grouped by (class qualified name, ivar name).
       #
-      # The collector is the read-side companion to
-      # `Inference::ScopeIndexer#build_class_ivar_index`. The
-      # indexer unions the rvalue types into a single per-ivar
-      # carrier; this collector preserves the per-write list so
-      # the `def.ivar-write-mismatch` rule can compare each
-      # write's concrete class against the first.
+      # The collector is the read-side companion to `Inference::ScopeIndexer#build_class_ivar_index`. The
+      # indexer unions the rvalue types into a single per-ivar carrier; this collector preserves the per-write
+      # list so the `def.ivar-write-mismatch` rule can compare each write's concrete class against the first.
       #
       # Skipped on purpose:
       #
-      # - Singleton-method bodies (`def self.foo`). Their ivars
-      #   live on the class object, not on instances.
-      # - Class-body ivar writes outside any def — the
-      #   `Module#@var` surface is a separate slice the engine
+      # - Singleton-method bodies (`def self.foo`). Their ivars live on the class object, not on instances.
+      # - Class-body ivar writes outside any def — the `Module#@var` surface is a separate slice the engine
       #   doesn't yet model.
-      # - Nested classes / modules / defs inside a method body
-      #   are barriers, mirroring the indexer's
+      # - Nested classes / modules / defs inside a method body are barriers, mirroring the indexer's
       #   `IVAR_BARRIER_NODES` policy.
       class IvarWriteCollector
         BARRIER_NODES = [Prism::DefNode, Prism::ClassNode, Prism::ModuleNode].freeze
         private_constant :BARRIER_NODES
 
-        # ADR-53 Track B — the node classes the shared {RuleWalk}
-        # dispatches to this collector, and the context gate under which
-        # the walk suppresses it. The legacy walk descends only through
-        # class / module bodies and `return`s at the first `def` it meets,
-        # so it collects ivar writes only from a `def` that sits directly
-        # in a class / module body, never one nested in another `def`. On
-        # the shared full DFS that prune becomes the `:inside_def` gate;
-        # the enclosing class / module name stack the legacy walk threaded
-        # as `qualified_prefix` is now `context.qualified_prefix`.
+        # ADR-53 Track B — the node classes the shared {RuleWalk} dispatches to this collector, and the
+        # context gate under which the walk suppresses it. The legacy walk descends only through class /
+        # module bodies and `return`s at the first `def` it meets, so it collects ivar writes only from a
+        # `def` that sits directly in a class / module body, never one nested in another `def`. On the
+        # shared full DFS that prune becomes the `:inside_def` gate; the enclosing class / module name stack
+        # the legacy walk threaded as `qualified_prefix` is now `context.qualified_prefix`.
         NODE_CLASSES = [Prism::DefNode].freeze
         RULE_WALK_GATES = [:inside_def].freeze
 
-        # Returns `Hash[class_name (String) => Hash[ivar_name
-        # (Symbol) => Array<{node:, type:}>]]`. Empty when the
-        # tree has no qualifying writes.
+        # Returns `Hash[class_name (String) => Hash[ivar_name (Symbol) => Array<{node:, type:}>]]`. Empty
+        # when the tree has no qualifying writes.
         def initialize(scope_index)
           @scope_index = scope_index
           @accumulator = {}
         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, [])
           @accumulator.transform_values(&:freeze).freeze
         end
 
-        # {RuleWalk} entry point: the legacy walk's per-`def` logic,
-        # invoked at each class-/module-body `def` under the shared
-        # traversal contract. `collect_def_writes`' verbatim body reads the
-        # enclosing class prefix from `context.qualified_prefix`.
+        # {RuleWalk} entry point: the legacy walk's per-`def` logic, invoked at each class-/module-body `def`
+        # under the shared traversal contract. `collect_def_writes`' verbatim body reads the enclosing class
+        # prefix from `context.qualified_prefix`.
         def visit(def_node, context)
           collect_def_writes(def_node, context.qualified_prefix)
         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
           @accumulator.transform_values(&:freeze).freeze
         end

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

@@ -5,42 +5,35 @@ require "prism"
 module Rigor
   module Analysis
     module CheckRules
-      # ADR-53 Track B (slice B3c) — hosts the main per-node check-rule
-      # pass on the shared {RuleWalk} instead of its own
-      # `Source::NodeWalker.each` traversal.
+      # ADR-53 Track B (slice B3c) — hosts the main per-node check-rule pass on the shared {RuleWalk} instead of
+      # its own `Source::NodeWalker.each` traversal.
       #
-      # The main pass is the stateless half of the catalogue: each rule
-      # reads only `scope_index[node]` and decides, with NO loop / block
-      # suppression and NO threaded context — so the collector declares no
+      # The main pass is the stateless half of the catalogue: each rule reads only `scope_index[node]` and
+      # decides, with NO loop / block suppression and NO threaded context — so the collector declares no
       # `RULE_WALK_GATES` and ignores the walk's `context`.
       #
-      # The per-node dispatch itself stays in `CheckRules` (the verbatim
-      # `case` from `diagnose`'s former inline walk — only the traversal
-      # moved, ADR-53 WD4) and is handed in as a callable built in the
-      # `CheckRules` module context, so its calls to the private
-      # diagnostic builders remain implicit-self. The collector only owns
-      # the traversal hook and accumulation. Unlike the fact collectors
-      # its `#results` are the accumulated {Diagnostic}s, in the same
-      # emission order the inline `NodeWalker.each` produced them (the
-      # shared walk is the same visit-before-descend DFS over
-      # `compact_child_nodes`).
+      # The per-node dispatch itself stays in `CheckRules` (the verbatim `case` from `diagnose`'s former inline
+      # walk — only the traversal moved, ADR-53 WD4) and is handed in as a callable built in the `CheckRules`
+      # module context, so its calls to the private diagnostic builders remain implicit-self. The collector
+      # only owns the traversal hook and accumulation. Unlike the fact collectors its `#results` are the
+      # accumulated {Diagnostic}s, in the same emission order the inline `NodeWalker.each` produced them (the
+      # shared walk is the same visit-before-descend DFS over `compact_child_nodes`).
       class MainPassCollector
-        # The node classes the former inline pass branched on. A plain
-        # `Prism::IfNode` covers ternaries and postfix `if` too (the
-        # legacy `when Prism::IfNode, Prism::UnlessNode` arm did the same).
+        # The node classes the former inline pass branched on. A plain `Prism::IfNode` covers ternaries and
+        # postfix `if` too (the legacy `when Prism::IfNode, Prism::UnlessNode` arm did the same).
         NODE_CLASSES = [
           Prism::CallNode, Prism::DefNode, Prism::IfNode, Prism::UnlessNode
         ].freeze
 
-        # @param node_diagnostics [#call] maps a `Prism::Node` to the
-        #   array of diagnostics the main pass emits for it.
+        # @param node_diagnostics [#call] maps a `Prism::Node` to the array of diagnostics the main pass emits
+        #   for it.
         def initialize(node_diagnostics)
           @node_diagnostics = node_diagnostics
           @diagnostics = []
         end
 
-        # {RuleWalk} entry point: the per-node logic of the former inline
-        # `NodeWalker.each` `case`, invoked under the shared traversal.
+        # {RuleWalk} entry point: the per-node logic of the former inline `NodeWalker.each` `case`, invoked
+        # under the shared traversal.
         def visit(node, _context = nil)
           @diagnostics.concat(@node_diagnostics.call(node))
         end

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

@@ -7,42 +7,31 @@ require_relative "../../source/constant_path"
 module Rigor
   module Analysis
     module CheckRules
-      # ADR-53 Track B — the engine-owned AST walk that hosts CheckRules'
-      # per-node collectors, so a file is traversed once for all of them
-      # instead of once per collector (the ADR-52 WD4 model applied to
-      # the built-in rules; this walk and {Plugin::NodeRuleWalk} converge
-      # in slice B4).
+      # ADR-53 Track B — the engine-owned AST walk that hosts CheckRules' per-node collectors, so a file is
+      # traversed once for all of them instead of once per collector (the ADR-52 WD4 model applied to the
+      # built-in rules; this walk and {Plugin::NodeRuleWalk} converge in slice B4).
       #
-      # The walk is a single visit-before-descend DFS over
-      # `compact_child_nodes`. It threads the union of the context the
-      # hosted collectors need — the per-collector hand-rolled walks each
-      # tracked some subset of it — in one immutable {Context} object,
-      # recomputed once per node during the single descent:
+      # The walk is a single visit-before-descend DFS over `compact_child_nodes`. It threads the union of the
+      # context the hosted collectors need — the per-collector hand-rolled walks each tracked some subset of
+      # it — in one immutable {Context} object, recomputed once per node during the single descent:
       #
-      # - `in_loop_or_block` — whether the node is inside a loop / block
-      #   body (the two flow collectors suppress collection there because
-      #   mutation tracking through those is incomplete).
-      # - `qualified_prefix` — the enclosing class / module name stack
-      #   ({IvarWriteCollector} builds its `class_name` from it).
-      # - `inside_def` — whether the node is lexically inside a `DefNode`
-      #   ({IvarWriteCollector} collects only at a `def` that sits
-      #   directly in a class / module body, never one nested in another
-      #   `def`).
+      # - `in_loop_or_block` — whether the node is inside a loop / block body (the two flow collectors
+      #   suppress collection there because mutation tracking through those is incomplete).
+      # - `qualified_prefix` — the enclosing class / module name stack ({IvarWriteCollector} builds its
+      #   `class_name` from it).
+      # - `inside_def` — whether the node is lexically inside a `DefNode` ({IvarWriteCollector} collects only
+      #   at a `def` that sits directly in a class / module body, never one nested in another `def`).
       #
-      # A collector joins the walk by declaring `NODE_CLASSES` (the node
-      # classes it cares about — Prism node classes are leaves, so a
-      # class-equality dispatch matches the collectors' `is_a?` gates),
-      # optionally `RULE_WALK_GATES` (the {Context}-derived suppressions
-      # the walk applies before calling it), and `#visit(node, context)`
-      # with its per-node logic transplanted verbatim. Only the
-      # *traversal* merges here; each collector's gather / filter logic is
-      # unchanged from its legacy `#collect` walk (ADR-53 WD4).
+      # A collector joins the walk by declaring `NODE_CLASSES` (the node classes it cares about — Prism node
+      # classes are leaves, so a class-equality dispatch matches the collectors' `is_a?` gates), optionally
+      # `RULE_WALK_GATES` (the {Context}-derived suppressions the walk applies before calling it), and
+      # `#visit(node, context)` with its per-node logic transplanted verbatim. Only the *traversal* merges
+      # here; each collector's gather / filter logic is unchanged from its legacy `#collect` walk (ADR-53
+      # WD4).
       #
-      # Equivalence is load-bearing: every hosted collector keeps its
-      # legacy single-collector `#collect` walk as the oracle, compared
-      # against this walk by the permanent `rule_walk_equivalence_spec`
-      # and, over whole corpora, by `RIGOR_SHADOW_RULE_WALK=1`
-      # (see `CheckRules.run_node_collectors`).
+      # Equivalence is load-bearing: every hosted collector keeps its legacy single-collector `#collect` walk
+      # as the oracle, compared against this walk by the permanent `rule_walk_equivalence_spec` and, over
+      # whole corpora, by `RIGOR_SHADOW_RULE_WALK=1` (see `CheckRules.run_node_collectors`).
       module RuleWalk
         LOOP_OR_BLOCK_NODE_CLASSES = [
           Prism::WhileNode, Prism::UntilNode, Prism::ForNode, Prism::BlockNode
@@ -50,51 +39,44 @@ module Rigor
 
         CLASS_OR_MODULE_NODE_CLASSES = [Prism::ClassNode, Prism::ModuleNode].freeze
 
-        # The immutable per-node descent context. Recomputed for each
-        # child from its parent's context as the walk descends; collectors
-        # read only the fields they declared a need for.
+        # The immutable per-node descent context. Recomputed for each child from its parent's context as the
+        # walk descends; collectors read only the fields they declared a need for.
         Context = Data.define(:in_loop_or_block, :qualified_prefix, :inside_def) do
           def self.root
             new(in_loop_or_block: false, qualified_prefix: [], inside_def: false)
           end
         end
 
-        # Suppression gates a collector may declare via `RULE_WALK_GATES`.
-        # The walk skips a collector's `#visit` for a node when any of the
-        # collector's declared gates holds in that node's context — exactly
-        # reproducing the per-collector legacy walk's traversal suppression.
-        # Each gate names the {Context} predicate method that, when true,
-        # suppresses the visit:
+        # Suppression gates a collector may declare via `RULE_WALK_GATES`. The walk skips a collector's
+        # `#visit` for a node when any of the collector's declared gates holds in that node's context —
+        # exactly reproducing the per-collector legacy walk's traversal suppression. Each gate names the
+        # {Context} predicate method that, when true, suppresses the visit:
         #
-        # - `:loop_or_block` (`in_loop_or_block`) — inside a loop / block
-        #   body, the two flow collectors' envelope.
-        # - `:inside_def` (`inside_def`) — lexically inside a `DefNode`;
-        #   IvarWrite collects only at a `def` that sits directly in a
-        #   class / module body (its legacy walk `return`s at the first
-        #   `def` it meets, so a nested def is never reached).
+        # - `:loop_or_block` (`in_loop_or_block`) — inside a loop / block body, the two flow collectors'
+        #   envelope.
+        # - `:inside_def` (`inside_def`) — lexically inside a `DefNode`; IvarWrite collects only at a `def`
+        #   that sits directly in a class / module body (its legacy walk `return`s at the first `def` it
+        #   meets, so a nested def is never reached).
         GATE_CONTEXT_PREDICATES = {
           loop_or_block: :in_loop_or_block,
           inside_def: :inside_def
         }.freeze
 
-        # A per-node driver over a fixed collector set: holds the compiled
-        # `node_class => [[collector, gates], …]` hook table and applies
-        # the dispatch + context-descent that {RuleWalk.run} performs, but
-        # one node at a time. This lets a foreign traversal (the converged
-        # {Plugin::NodeRuleWalk}, ADR-53 B4) drive the built-in collectors
-        # from inside its own single walk: it calls {#visit} on each node
-        # with that node's {Context}, and derives a child's context with
-        # {#descend}. The dispatch / gate / descend logic is identical to
-        # the standalone {RuleWalk.run} walk — only the traversal driving
-        # it differs, keeping diagnostics byte-identical (ADR-53 WD4).
+        # A per-node driver over a fixed collector set: holds the compiled `node_class => [[collector,
+        # gates], …]` hook table and applies the dispatch + context-descent that {RuleWalk.run} performs,
+        # but one node at a time. This lets a foreign traversal (the converged {Plugin::NodeRuleWalk},
+        # ADR-53 B4) drive the built-in collectors from inside its own single walk: it calls {#visit} on
+        # each node with that node's {Context}, and derives a child's context with {#descend}. The dispatch
+        # / gate / descend logic is identical to the standalone {RuleWalk.run} walk — only the traversal
+        # driving it differs, keeping diagnostics byte-identical (ADR-53 WD4).
         class CollectorDriver
           def initialize(collectors)
             @hooks = RuleWalk.build_hooks(collectors)
             freeze
           end
 
-          # Dispatch `node` (under its own `context`) to every matching,
-          # un-gated collector. Mirrors {RuleWalk.dispatch}.
+          # Dispatch `node` (under its own `context`) to every matching, un-gated collector. Mirrors
+          # {RuleWalk.dispatch}.
           def visit(node, context)
             matched = @hooks[node.class]
             return if matched.nil?
@@ -106,18 +88,15 @@ module Rigor
             end
           end
 
-          # The context the children of `node` descend under. Mirrors
-          # {RuleWalk.descend}.
+          # The context the children of `node` descend under. Mirrors {RuleWalk.descend}.
           def descend(node, context)
             RuleWalk.descend(node, context)
           end
         end
 
         class << self
-          # Walks `root` once, dispatching each visited node to every
-          # collector whose `NODE_CLASSES` covers the node's class and
-          # whose declared `RULE_WALK_GATES` do not suppress it in that
-          # node's context.
+          # Walks `root` once, dispatching each visited node to every collector whose `NODE_CLASSES` covers
+          # the node's class and whose declared `RULE_WALK_GATES` do not suppress it in that node's context.
           def run(root, collectors)
             hooks = build_hooks(collectors)
             walk(root, hooks, Context.root)
@@ -135,12 +114,10 @@ module Rigor
             hooks
           end
 
-          # Computes the context the children of `node` descend under from
-          # the node's own context. `in_loop_or_block` latches on once a
-          # loop / block is entered; `qualified_prefix` extends only on a
-          # nameable class / module (an unnamed one descends with the same
-          # prefix, matching IvarWrite's fall-through); `inside_def`
-          # latches on once a `DefNode` is entered.
+          # Computes the context the children of `node` descend under from the node's own context.
+          # `in_loop_or_block` latches on once a loop / block is entered; `qualified_prefix` extends only on
+          # a nameable class / module (an unnamed one descends with the same prefix, matching IvarWrite's
+          # fall-through); `inside_def` latches on once a `DefNode` is entered.
           def descend(node, context)
             in_loop_or_block = context.in_loop_or_block ||
                                LOOP_OR_BLOCK_NODE_CLASSES.any? { |klass| node.is_a?(klass) }

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

@@ -7,24 +7,19 @@ require_relative "../../source/constant_path"
 module Rigor
   module Analysis
     module CheckRules
-      # ADR-24 slice 4 — read-side companion to `call.self-undefined-method`.
-      # Walks a file's parse tree once and collects the qualified names of
-      # declarations that are NOT confidently closed for self-call
+      # ADR-24 slice 4 — read-side companion to `call.self-undefined-method`. Walks a file's parse tree once
+      # and collects the qualified names of declarations that are NOT confidently closed for self-call
       # undefined-method analysis, so the rule can exclude them:
       #
-      # - **Modules** — a `module M` is a mixin contract; its methods may be
-      #   provided by includers (template-method pattern), so an unresolved
-      #   self-call inside it is not provably a typo.
-      # - **Classes with a dynamic `attr_*` accessor** — `attr_reader(*NAMES)`
-      #   / `attr_accessor(:a, SOME_CONST)` synthesizes readers whose names
-      #   are not statically decidable, so the class's method surface cannot
-      #   be enumerated from source.
+      # - **Modules** — a `module M` is a mixin contract; its methods may be provided by includers
+      #   (template-method pattern), so an unresolved self-call inside it is not provably a typo.
+      # - **Classes with a dynamic `attr_*` accessor** — `attr_reader(*NAMES)` / `attr_accessor(:a, SOME_CONST)`
+      #   synthesizes readers whose names are not statically decidable, so the class's method surface cannot be
+      #   enumerated from source.
       #
-      # The enclosing declaration of a self-call is always in the same file
-      # as the call (even a reopened class restates `class Foo`), so a
-      # per-file AST scan suffices — no cross-file plumbing. Names are built
-      # to match the engine's qualified `self` type (`Module.nesting`-style
-      # `A::B::C`).
+      # The enclosing declaration of a self-call is always in the same file as the call (even a reopened class
+      # restates `class Foo`), so a per-file AST scan suffices — no cross-file plumbing. Names are built to
+      # match the engine's qualified `self` type (`Module.nesting`-style `A::B::C`).
       class SelfClosednessScanner
         ATTR_MACROS = %i[attr_reader attr_accessor attr_writer].freeze
         private_constant :ATTR_MACROS
@@ -61,16 +56,14 @@ module Rigor
           end
         end
 
-        # A class whose source-declared surface cannot be fully enumerated:
-        # a dynamic `attr_*` accessor, or a non-constant (dynamically produced)
-        # superclass.
+        # A class whose source-declared surface cannot be fully enumerated: a dynamic `attr_*` accessor, or a
+        # non-constant (dynamically produced) superclass.
         def class_surface_open?(class_node)
           dynamic_attr_class?(class_node) || dynamic_superclass?(class_node)
         end
 
-        # True when the class body directly invokes an `attr_*` macro with a
-        # non-literal argument (a splat, a constant, a method call) — the
-        # synthesized accessor names are then not statically knowable.
+        # True when the class body directly invokes an `attr_*` macro with a non-literal argument (a splat, a
+        # constant, a method call) — the synthesized accessor names are then not statically knowable.
         def dynamic_attr_class?(class_node)
           body = class_node.body
           return false unless body.is_a?(Prism::StatementsNode)
@@ -90,13 +83,11 @@ module Rigor
           args.any? { |arg| !arg.is_a?(Prism::SymbolNode) && !arg.is_a?(Prism::StringNode) }
         end
 
-        # True when the class declares a superclass that is not a static
-        # constant — `class X < DelegateClass(Array)` / `< Struct.new(...)` /
-        # `< Data.define(...)`. The inherited surface is then a dynamically
-        # produced class the engine cannot enumerate from a constant name (the
-        # superclass is a method call, so `discovered_superclasses` never
-        # records it and the closed-class gate would wrongly treat the class as
-        # standalone), so a missed self-call is not provably a typo.
+        # True when the class declares a superclass that is not a static constant — `class X < DelegateClass(Array)`
+        # / `< Struct.new(...)` / `< Data.define(...)`. The inherited surface is then a dynamically produced
+        # class the engine cannot enumerate from a constant name (the superclass is a method call, so
+        # `discovered_superclasses` never records it and the closed-class gate would wrongly treat the class
+        # as standalone), so a missed self-call is not provably a typo.
         def dynamic_superclass?(class_node)
           superclass = class_node.superclass
           return false if superclass.nil?