rigortype 0.2.7 → 0.2.9

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?

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

@@ -5,46 +5,37 @@ require "prism"
 module Rigor
   module Analysis
     module CheckRules
-      # ADR-47 — collects `case`/`when` clauses proven unreachable. The flow
-      # engine already narrows the case subject across `when` branches
-      # (`Narrowing.case_when_scopes`), and the per-clause `body_scope` it
-      # produces is recorded in `scope_index` keyed on the `WhenNode` (the
-      # evaluator enters the clause under that scope). So a clause whose
-      # narrowed subject local is `Type::Bot` is one the engine's own
-      # narrowing proves no reaching value can match — a stale `when`,
-      # mis-ordered clauses, or a type that moved out from under a branch.
+      # ADR-47 — collects `case`/`when` clauses proven unreachable. The flow engine already narrows the case
+      # subject across `when` branches (`Narrowing.case_when_scopes`), and the per-clause `body_scope` it
+      # produces is recorded in `scope_index` keyed on the `WhenNode` (the evaluator enters the clause under
+      # that scope). So a clause whose narrowed subject local is `Type::Bot` is one the engine's own
+      # narrowing proves no reaching value can match — a stale `when`, mis-ordered clauses, or a type that
+      # moved out from under a branch.
       #
-      # WD1 (per-clause disjointness) — the narrow, high-value core. Fires
-      # ONLY on the safe shape:
+      # WD1 (per-clause disjointness) — the narrow, high-value core. Fires ONLY on the safe shape:
       #
-      # - the subject is a `case <local>` (a `LocalVariableReadNode`, the
-      #   only shape `case_when_scopes` narrows — no narrowing ⇒ no firing),
-      # - every `when` condition is a class/module constant (`when String` /
-      #   `when MyClass`), the shape the narrowing recognises — `when nil` /
-      #   ranges / regexps / arbitrary expressions are out of scope here,
-      # - the subject's type at case entry is a concrete carrier, never
-      #   `Type::Dynamic` (disjointness is never provable under gradual
-      #   `Dynamic`, preserving the gradual guarantee) and never already
+      # - the subject is a `case <local>` (a `LocalVariableReadNode`, the only shape `case_when_scopes`
+      #   narrows — no narrowing ⇒ no firing),
+      # - every `when` condition is a class/module constant (`when String` / `when MyClass`), the shape the
+      #   narrowing recognises — `when nil` / ranges / regexps / arbitrary expressions are out of scope here,
+      # - the subject's type at case entry is a concrete carrier, never `Type::Dynamic` (disjointness is
+      #   never provable under gradual `Dynamic`, preserving the gradual guarantee) and never already
       #   `Type::Bot` (dead code, not a clause error),
       # - and the clause's narrowed `body_scope` subject is `Type::Bot`.
       #
-      # The false-positive envelope mirrors `flow.always-truthy-condition`:
-      # clauses inside loops / blocks are skipped (mutation tracking through
-      # those is incomplete), and the rule reads the engine's own narrowing
-      # rather than recomputing it, so the diagnostic and the body typing
-      # can never diverge.
+      # The false-positive envelope mirrors `flow.always-truthy-condition`: clauses inside loops / blocks are
+      # skipped (mutation tracking through those is incomplete), and the rule reads the engine's own
+      # narrowing rather than recomputing it, so the diagnostic and the body typing can never diverge.
       class UnreachableClauseCollector
         LOOP_OR_BLOCK_NODE_CLASSES = [
           Prism::WhileNode, Prism::UntilNode, Prism::ForNode, Prism::BlockNode
         ].freeze
 
-        # A trailing `else` whose body only re-raises / aborts is a
-        # deliberate defensive guard ("this should be unreachable — shout
-        # if it ever isn't"), NOT dead code the author wants removed.
-        # Flagging it would push the author to delete a safety net, which
-        # the false-positive discipline forbids. WD1's `when` shapes don't
-        # carry this idiom (a stale `when` is a real redundancy), so the
-        # skip is `else`-only.
+        # A trailing `else` whose body only re-raises / aborts is a deliberate defensive guard ("this should
+        # be unreachable — shout if it ever isn't"), NOT dead code the author wants removed. Flagging it
+        # would push the author to delete a safety net, which the false-positive discipline forbids. WD1's
+        # `when` shapes don't carry this idiom (a stale `when` is a real redundancy), so the skip is
+        # `else`-only.
         DEFENSIVE_EXIT_CALLS = %i[raise fail throw abort exit].freeze
 
         # @!attribute kind
@@ -55,11 +46,10 @@ module Rigor
         #     `else` never runs).
         Result = Data.define(:clause, :body, :subject_name, :condition_source, :kind, :keyword)
 
-        # 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::CaseNode, Prism::CaseMatchNode].freeze
         RULE_WALK_GATES = [:loop_or_block].freeze
 
@@ -68,19 +58,17 @@ module Rigor
           @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.
         # @return [Array<Result>] one entry per provably-dead `when` clause.
         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_case(node)
         end
@@ -100,9 +88,8 @@ module Rigor
           node.compact_child_nodes.each { |child| walk(child, in_loop_or_block: child_in_loop_or_block) }
         end
 
-        # `case/when` is a `CaseNode`; `case/in` is a `CaseMatchNode`. Both
-        # carry `predicate` + `conditions` + `else_clause` and the engine
-        # narrows both through `eval_case_when_branches`.
+        # `case/when` is a `CaseNode`; `case/in` is a `CaseMatchNode`. Both carry `predicate` + `conditions`
+        # + `else_clause` and the engine narrows both through `eval_case_when_branches`.
         def case_like?(node)
           node.is_a?(Prism::CaseNode) || node.is_a?(Prism::CaseMatchNode)
         end
@@ -116,9 +103,8 @@ module Rigor
           return unless subject.is_a?(Prism::LocalVariableReadNode)
 
           entry_type = entry_subject_type(node, subject.name)
-          # Only meaningful for a concrete subject type: a `Dynamic` subject
-          # can never be proven disjoint (the gradual guarantee), and an
-          # already-`Bot` subject is dead code, not a clause-ordering error.
+          # Only meaningful for a concrete subject type: a `Dynamic` subject can never be proven disjoint
+          # (the gradual guarantee), and an already-`Bot` subject is dead code, not a clause-ordering error.
           return if entry_type.nil? || entry_type.is_a?(Type::Bot) || entry_type.is_a?(Type::Dynamic)
 
           keyword = node.is_a?(Prism::CaseMatchNode) ? "in" : "when"
@@ -151,12 +137,10 @@ module Rigor
           )
         end
 
-        # A dead `when` is `:prior_exhaustion` when the subject was
-        # already narrowed to `bot` BEFORE this clause (an earlier clause
-        # covered it) — read from the entry scope the engine recorded on
-        # the clause's first condition node (ADR-47 WD2). Otherwise the
-        # subject was still concrete entering the clause and THIS clause's
-        # type is disjoint from it.
+        # A dead `when` is `:prior_exhaustion` when the subject was already narrowed to `bot` BEFORE this
+        # clause (an earlier clause covered it) — read from the entry scope the engine recorded on the
+        # clause's first condition node (ADR-47 WD2). Otherwise the subject was still concrete entering the
+        # clause and THIS clause's type is disjoint from it.
         def when_clause_kind(clause, subject_name)
           entry = @scope_index[clause.conditions.first]
           return :prior_exhaustion if entry && entry.local(subject_name).is_a?(Type::Bot)
@@ -164,14 +148,12 @@ module Rigor
           :disjoint
         end
 
-        # ADR-47 WD3a — a dead `case/in` clause. The body scope reaches
-        # `bot` either because a bare class pattern (`in C` / `in C => x`)
-        # is disjoint from the still-possible subject (the engine narrows
-        # those soundly, like `when C`), or because an earlier clause
-        # already exhausted the subject (prior-exhaustion — true for ANY
-        # pattern downstream of a covering set). Non-bare patterns are not
-        # narrowed, so their body is `bot` ONLY under prior-exhaustion;
-        # they never produce a spurious `:disjoint`.
+        # ADR-47 WD3a — a dead `case/in` clause. The body scope reaches `bot` either because a bare class
+        # pattern (`in C` / `in C => x`) is disjoint from the still-possible subject (the engine narrows
+        # those soundly, like `when C`), or because an earlier clause already exhausted the subject
+        # (prior-exhaustion — true for ANY pattern downstream of a covering set). Non-bare patterns are not
+        # narrowed, so their body is `bot` ONLY under prior-exhaustion; they never produce a spurious
+        # `:disjoint`.
         def collect_in(clause, subject_name)
           return if clause.statements.nil?
 
@@ -193,11 +175,10 @@ module Rigor
           :disjoint
         end
 
-        # The trailing `else` is dead when every subject value is covered
-        # by the `when` clauses — the final falsey scope (recorded on the
-        # `else` node) narrows the subject to `bot`. Defensive `else`
-        # bodies (a bare `raise` / `fail` / `throw`) are deliberate
-        # guards, not removable dead code, so they are skipped.
+        # The trailing `else` is dead when every subject value is covered by the `when` clauses — the final
+        # falsey scope (recorded on the `else` node) narrows the subject to `bot`. Defensive `else` bodies (a
+        # bare `raise` / `fail` / `throw`) are deliberate guards, not removable dead code, so they are
+        # skipped.
         def collect_else(else_clause, subject_name, keyword)
           return if else_clause.nil? || else_clause.statements.nil?
           return if defensive_else?(else_clause)