rigortype 0.1.17 → 0.1.19

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

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+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.
+      #
+      # 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`).
+      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).
+        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.
+        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.
+        def visit(node, _context = nil)
+          @diagnostics.concat(@node_diagnostics.call(node))
+        end
+
+        def results
+          @diagnostics
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,213 @@
+# frozen_string_literal: true
+
+require "prism"
+
+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).
+      #
+      # 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`).
+      #
+      # 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`).
+      module RuleWalk
+        LOOP_OR_BLOCK_NODE_CLASSES = [
+          Prism::WhileNode, Prism::UntilNode, Prism::ForNode, Prism::BlockNode
+        ].freeze
+
+        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.
+        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:
+        #
+        # - `: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).
+        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}.
+          def visit(node, context)
+            matched = @hooks[node.class]
+            return if matched.nil?
+
+            matched.each do |collector, gates|
+              next if gates.any? { |predicate| context.public_send(predicate) }
+
+              collector.visit(node, context)
+            end
+          end
+
+          # 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.
+          def run(root, collectors)
+            hooks = build_hooks(collectors)
+            walk(root, hooks, Context.root)
+            collectors
+          end
+
+          def build_hooks(collectors)
+            hooks = {}
+            collectors.each do |collector|
+              gates = collector_gates(collector)
+              collector.class::NODE_CLASSES.each do |node_class|
+                (hooks[node_class] ||= []) << [collector, gates]
+              end
+            end
+            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.
+          def descend(node, context)
+            in_loop_or_block = context.in_loop_or_block ||
+                               LOOP_OR_BLOCK_NODE_CLASSES.any? { |klass| node.is_a?(klass) }
+            inside_def = context.inside_def || node.is_a?(Prism::DefNode)
+            qualified_prefix = extend_prefix(node, context.qualified_prefix)
+
+            Context.new(
+              in_loop_or_block: in_loop_or_block,
+              qualified_prefix: qualified_prefix,
+              inside_def: inside_def
+            )
+          end
+
+          private
+
+          def collector_gates(collector)
+            klass = collector.class
+            return [] unless klass.const_defined?(:RULE_WALK_GATES)
+
+            klass::RULE_WALK_GATES.map { |gate| GATE_CONTEXT_PREDICATES.fetch(gate) }
+          end
+
+          def walk(node, hooks, context)
+            return unless node.is_a?(Prism::Node)
+
+            dispatch(node, hooks, context)
+            child_context = descend(node, context)
+            node.compact_child_nodes.each { |child| walk(child, hooks, child_context) }
+          end
+
+          def dispatch(node, hooks, context)
+            matched = hooks[node.class]
+            return if matched.nil?
+
+            matched.each do |collector, gates|
+              next if gates.any? { |predicate| context.public_send(predicate) }
+
+              collector.visit(node, context)
+            end
+          end
+
+          def extend_prefix(node, prefix)
+            return prefix unless CLASS_OR_MODULE_NODE_CLASSES.any? { |klass| node.is_a?(klass) }
+
+            name = qualified_name_for(node.constant_path)
+            name ? prefix + [name] : prefix
+          end
+
+          # Same shape resolution as `IvarWriteCollector#qualified_name_for`
+          # and `ScopeIndexer.qualified_name_for` (single-segment
+          # ConstantReadNode and dotted ConstantPathNode).
+          def qualified_name_for(constant_path_node)
+            case constant_path_node
+            when Prism::ConstantReadNode then constant_path_node.name.to_s
+            when Prism::ConstantPathNode then render_constant_path(constant_path_node)
+            end
+          end
+
+          def render_constant_path(node)
+            prefix =
+              case node.parent
+              when Prism::ConstantReadNode then "#{node.parent.name}::"
+              when Prism::ConstantPathNode then "#{render_constant_path(node.parent)}::"
+              else ""
+              end
+            "#{prefix}#{node.name}"
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -55,23 +55,46 @@ 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`.
+        NODE_CLASSES = [Prism::CaseNode, Prism::CaseMatchNode].freeze
+        RULE_WALK_GATES = [:loop_or_block].freeze
+
         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.
         # @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.
+        def visit(node, _context = nil)
+          collect_case(node)
+        end
+
+        def results
+          @results.freeze
+        end
+
         private
 
         def walk(node, in_loop_or_block:)
           return unless node.is_a?(Prism::Node)
 
-          collect_case(node) if case_like?(node) && !in_loop_or_block
+          visit(node) if case_like?(node) && !in_loop_or_block
 
           child_in_loop_or_block = in_loop_or_block || enters_loop_or_block?(node)
           node.compact_child_nodes.each { |child| walk(child, in_loop_or_block: child_in_loop_or_block) }