rigortype 0.1.18 → 0.2.0

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

@@ -2,6 +2,8 @@
 
 require "prism"
 
+require_relative "../../source/constant_path"
+
 module Rigor
   module Analysis
     module CheckRules
@@ -11,54 +13,180 @@ module Rigor
       # the built-in rules; this walk and {Plugin::NodeRuleWalk} converge
       # in slice B4).
       #
-      # Slice B2 hosts the two flow collectors
-      # ({AlwaysTruthyConditionCollector} / {UnreachableClauseCollector}),
-      # whose hand-rolled walks shared this exact traversal contract:
-      # visit-before-descend DFS over `compact_child_nodes`, with
-      # collection suppressed anywhere inside a loop / block body
-      # (mutation tracking through those is incomplete — each collector's
-      # envelope documents why). A collector joins the walk by declaring
-      # `NODE_CLASSES` and exposing `#visit(node)` with its per-node logic
-      # transplanted verbatim; a collector with a different traversal
-      # contract (class-nesting prefix, def-scoped scanning) stays on its
-      # own walk until a later slice threads the context it needs.
+      # 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.flow_collector_results`).
+      # (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.
-          # Dispatch keys on the exact node class — Prism node classes
-          # are leaves, so this matches the collectors' `is_a?` gates.
+          # 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
+                (hooks[node_class] ||= []) << [collector, gates]
               end
             end
-            walk(root, hooks, in_loop_or_block: false)
-            collectors
+            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 walk(node, hooks, in_loop_or_block:)
+          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)
 
-            hooks[node.class]&.each { |collector| collector.visit(node) } unless in_loop_or_block
+            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) }
 
-            child_in_loop_or_block =
-              in_loop_or_block || LOOP_OR_BLOCK_NODE_CLASSES.any? { |klass| node.is_a?(klass) }
-            node.compact_child_nodes.each { |child| walk(child, hooks, in_loop_or_block: child_in_loop_or_block) }
+            name = Source::ConstantPath.qualified_name(node.constant_path)
+            name ? prefix + [name] : prefix
           end
         end
       end

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

@@ -2,6 +2,8 @@
 
 require "prism"
 
+require_relative "../../source/constant_path"
+
 module Rigor
   module Analysis
     module CheckRules
@@ -45,20 +47,27 @@ module Rigor
 
           case node
           when Prism::ModuleNode
-            name = constant_path_name(node.constant_path)
+            name = Source::ConstantPath.qualified_name_or_nil(node.constant_path)
             child_prefix = name ? prefix + [name] : prefix
             names << child_prefix.join("::") if name
             walk(node.body, child_prefix, names) if node.body
           when Prism::ClassNode
-            name = constant_path_name(node.constant_path)
+            name = Source::ConstantPath.qualified_name_or_nil(node.constant_path)
             child_prefix = name ? prefix + [name] : prefix
-            names << child_prefix.join("::") if name && dynamic_attr_class?(node)
+            names << child_prefix.join("::") if name && class_surface_open?(node)
             walk(node.body, child_prefix, names) if node.body
           else
             node.compact_child_nodes.each { |child| walk(child, prefix, names) }
           end
         end
 
+        # 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.
@@ -81,18 +90,18 @@ module Rigor
           args.any? { |arg| !arg.is_a?(Prism::SymbolNode) && !arg.is_a?(Prism::StringNode) }
         end
 
-        # Renders a class/module path node to its source-qualified name
-        # (`Foo`, `Foo::Bar`, leading `::` stripped); nil for a dynamic
-        # constant path the scanner cannot name statically.
-        def constant_path_name(node)
-          case node
-          when Prism::ConstantReadNode
-            node.name.to_s
-          when Prism::ConstantPathNode
-            parent = node.parent ? constant_path_name(node.parent) : nil
-            child = node.name.to_s
-            node.parent.nil? ? child : (parent && "#{parent}::#{child}")
-          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.
+        def dynamic_superclass?(class_node)
+          superclass = class_node.superclass
+          return false if superclass.nil?
+
+          !superclass.is_a?(Prism::ConstantReadNode) && !superclass.is_a?(Prism::ConstantPathNode)
         end
       end
     end

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

@@ -56,8 +56,12 @@ module Rigor
         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 (outside loop / block bodies).
+        # 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
@@ -74,8 +78,10 @@ module Rigor
         end
 
         # {RuleWalk} entry point: the per-node logic of the legacy walk,
-        # invoked under the same traversal contract.
-        def visit(node)
+        # 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