rigortype 0.4.6 → 0.4.8

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

@@ -0,0 +1,147 @@
+# frozen_string_literal: true
+
+require "prism"
+
+require_relative "../../reflection"
+require_relative "../../source/node_children"
+require_relative "../../type"
+
+module Rigor
+  module Analysis
+    module CheckRules
+      # Issue #3036 — answers, for a call node `flow.always-raises` proved raises, whether an enclosing
+      # `begin` (or `def … rescue … end`, which Prism wraps in the same `BeginNode`) catches the raise
+      # before it escapes. When a rescue clause may catch the raised class the exception flows to the
+      # handler, so the rule stays silent.
+      #
+      # The check is deliberately conservative in BOTH directions:
+      #
+      # - it suppresses only when a clause NAMES a class the raised class orders at-or-below
+      #   (`rescue ZeroDivisionError`, `rescue StandardError`, `rescue Exception`, or a bare `rescue`,
+      #   which is `StandardError`), resolved through the typer so lexical constant lookup applies. An
+      #   exception reference that is not a constant (`rescue *ERRORS`, `rescue klass`) contributes no
+      #   coverage, and an unresolvable / `:unknown` ordering keeps the diagnostic — a wrong silence is
+      #   worse than a kept finding.
+      # - it never crosses a body boundary ({BODY_BOUNDARIES}): a `def`, `->`, or block body runs when
+      #   called, not while the `begin` body evaluates, and `BEGIN` / `END` blocks run on their own
+      #   schedule, so an outer rescue cannot be proven to see their raise. Class / module bodies are
+      #   NOT boundaries — they evaluate inline, so their raises DO reach the enclosing rescue.
+      #
+      # Prism nodes carry no parent pointers, so ancestry is answered from a `node => parent` table
+      # built lazily on the first query: a file with no zero-division candidate never pays for it.
+      class AlwaysRaisesShield
+        # The exception class the rule proves today — Integer `/# % div modulo divmod` by a literal
+        # zero divisor. A rescue catches it when the clause names the class itself or an ancestor.
+        RAISED_CLASS = "ZeroDivisionError"
+
+        # The implicit class of a bare `rescue` / `rescue => e`.
+        BARE_RESCUE_CLASS = "StandardError"
+
+        # Node classes whose bodies do not execute inside the enclosing `begin` — see the class
+        # comment. Mirrors the deferred-body set `Inference::ScopeIndexer` already tracks.
+        BODY_BOUNDARIES = [
+          Prism::DefNode, Prism::LambdaNode, Prism::BlockNode,
+          Prism::PreExecutionNode, Prism::PostExecutionNode
+        ].freeze
+
+        def initialize(root)
+          @root = root
+          @parent_map = nil
+        end
+
+        # True when `node` sits in the protected body of a `begin` whose rescue chain may catch
+        # {RAISED_CLASS}. `scope` is the scope recorded for `node`; it resolves the clause's exception
+        # constants lexically. A nil scope or a node outside `root`'s subtree answers false.
+        def rescued?(node, scope)
+          return false if scope.nil?
+
+          parents = parent_map
+          child = node
+          current = parents[node]
+          while current
+            return true if protected_body?(current, child, scope)
+            return false if BODY_BOUNDARIES.any? { |klass| current.is_a?(klass) }
+
+            child = current
+            current = parents[current]
+          end
+          false
+        end
+
+        private
+
+        # True when `node` is a `begin` whose protected body (`statements`) contains `child` — the
+        # ascent arrived through the body rather than through a rescue / else / ensure clause, whose
+        # raises this `begin` does not catch — and whose rescue chain may catch {RAISED_CLASS}. When
+        # the chain does NOT catch, the ascent continues: an outer `begin` may still.
+        def protected_body?(node, child, scope)
+          return false unless node.is_a?(Prism::BeginNode)
+          return false unless child.equal?(node.statements)
+          return false if node.rescue_clause.nil?
+
+          rescue_chain_catches?(node.rescue_clause, scope)
+        end
+
+        # Any clause of the `rescue … rescue …` chain may catch — clauses are tried in order and the
+        # first match wins, so one catching clause is enough.
+        def rescue_chain_catches?(clause, scope)
+          while clause
+            return true if rescue_clause_catches?(clause, scope)
+
+            clause = clause.subsequent
+          end
+          false
+        end
+
+        # One `rescue` clause catches {RAISED_CLASS} when any class it names orders at-or-above the
+        # raised class. A bare `rescue` names {BARE_RESCUE_CLASS}.
+        def rescue_clause_catches?(clause, scope)
+          exceptions = clause.exceptions
+          return class_catches?(BARE_RESCUE_CLASS, scope) if exceptions.empty?
+
+          exceptions.any? do |exception|
+            class_name = exception_class_name(exception, scope)
+            class_name && class_catches?(class_name, scope)
+          end
+        end
+
+        # The class a rescue exception reference names, or nil when it is not a constant path (a splat,
+        # a dynamic expression) or does not resolve to a class object. Only `Type::Singleton` counts:
+        # the rescue operand is the class itself, and an instance-typed constant cannot be proven to
+        # match.
+        def exception_class_name(node, scope)
+          return nil unless node.is_a?(Prism::ConstantReadNode) || node.is_a?(Prism::ConstantPathNode)
+
+          type = scope.type_of(node)
+          type.class_name if type.is_a?(Type::Singleton)
+        end
+
+        # `class_ordering(raised, rescued)`: `:equal` / `:subclass` mean the rescued class IS the raised
+        # class or an ancestor of it — the clause catches. `:superclass`, `:disjoint`, and `:unknown`
+        # all keep the diagnostic.
+        def class_catches?(rescued_class, scope)
+          %i[equal subclass].include?(
+            Rigor::Reflection.class_ordering(RAISED_CLASS, rescued_class, scope: scope)
+          )
+        end
+
+        # `node => parent` for every descendant of `root`, built on first use. Iterative so a deeply
+        # nested file cannot overflow the stack the way a recursive walk could.
+        def parent_map
+          @parent_map ||= begin
+            parents = {}
+            stack = [@root]
+            until stack.empty?
+              node = stack.pop
+              node.rigor_each_child do |child|
+                parents[child] = node
+                stack << child
+              end
+            end
+            parents
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -23,10 +23,11 @@ module Rigor
       #   `BlockNode` ancestors. Mutation tracking through loop bodies is incomplete (`shift = 0; loop {
       #   shift += 7 }` keeps `shift` at `Constant<7>` per the analyzer), so a `Constant<bool>` predicate
       #   inside the loop body is suspect.
-      # - **Defensive predicate calls**: `.nil?` / `.empty?` / `.zero?` / `.any?` / `.none?` / `.all?`. These
-      #   read like the user explicitly checking for a runtime condition that the type system already proves
-      #   can't happen — Rigor's strict-on-returns RBS often disagrees with the user's defensive check (e.g.
-      #   `Module#name` returns `String` per RBS but anonymous classes really do return `nil`). Skipping
+      # - **Defensive predicate calls**: `.nil?` / `.empty?` / `.zero?` / `.any?` / `.none?` / `.all?` /
+      #   `.respond_to?`. These read like the user explicitly checking for a runtime condition that the type
+      #   system already proves can't happen — Rigor's strict-on-returns RBS often disagrees with the user's
+      #   defensive check (e.g. `Module#name` returns `String` per RBS but anonymous classes really do return
+      #   `nil`). Skipping
       #   these forms keeps the rule useful for genuine logic errors without faulting defensive code.
       #
       # Also skipped (so the literal-only `unreachable-branch` rule doesn't double-fire alongside this one):
@@ -53,8 +54,6 @@ module Rigor
         NODE_CLASSES = [Prism::IfNode, Prism::UnlessNode].freeze
         RULE_WALK_GATES = [:loop_or_block].freeze
 
-        # @return one entry per qualifying predicate. Empty when the tree carries no firing
-        #   predicates.
         def initialize(scope_index)
           @scope_index = scope_index
           @results = []

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

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+module Rigor
+  module Analysis
+    module CheckRules
+      # Issue #2786 — what the per-call-node rules ({CheckRules.call_node_diagnostics}) each derived on their own:
+      # the call node's index scope, the type of its receiver under that scope, and the RBS signature the call
+      # resolves to on that receiver. One object per call node is built before the rules run and handed to every
+      # rule that reads them.
+      #
+      # The receiver type is computed lazily, on the first rule that asks, from the same `(scope, node)` pair each
+      # rule typed before: `scope_index[call_node]` and `call_node.receiver`. Every later rule reads that value
+      # instead of re-typing the receiver chain. This is not a memo over `type_of`: nothing is served across call
+      # nodes or across scopes, and no fact is computed anywhere but at the first point a rule computed it before.
+      # It rests on the `Scope#type_of` contract that one `(scope, node)` pair types structurally equal within a run
+      # *under the same ambient inputs* (`docs/internal-spec/inference-engine.md`), which holds here because of
+      # an invariant of the rule list: between the first rule that types the receiver and the last that reads it, no
+      # frame is installed and nothing types a node inside the receiver's subtree under another state or adds an
+      # `optimistic_origins` mark there. The other typings in that window are the call's arguments (outside the
+      # subtree), `receiver.receiver` under the same scope (which rewrites what the receiver's typing already
+      # wrote), and the key-presence re-walk, which runs on `with_isolated_side_tables`. A rule inserted between
+      # two readers that breaks this must type the receiver itself.
+      #
+      # Of the typing, only the receiver is shared. A rule that types a sub-expression (`receiver.receiver`), an
+      # argument, or any node under a scope other than the call's keeps its own `type_of` call: arguments are typed
+      # from their own index entry by `call.argument-type-mismatch` and from the call's by `flow.always-raises`, and
+      # the two meet only on a divisor.
+      class CallFacts
+        attr_reader :call_node, :scope_index, :scope
+
+        def initialize(call_node, scope_index)
+          @call_node = call_node
+          @scope_index = scope_index
+          @scope = scope_index[call_node]
+          @receiver_type = nil
+          @receiver_signature = nil
+          @receiver_signature_resolved = false
+        end
+
+        # `scope.type_of(call_node.receiver)`, computed once. Callers check that the call has a receiver and that
+        # {#scope} is not nil first, as they did before sharing it.
+        def receiver_type
+          @receiver_type ||= @scope.type_of(@call_node.receiver)
+        end
+
+        # The signature `CheckRules.receiver_signature` resolves, its block run on the first ask only. A nil answer
+        # is remembered too. A block that raises leaves it unresolved, so the next ask raises as it did before.
+        def receiver_signature
+          return @receiver_signature if @receiver_signature_resolved
+
+          signature = yield
+          @receiver_signature_resolved = true
+          @receiver_signature = signature
+        end
+      end
+    end
+  end
+end

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

@@ -35,8 +35,8 @@ module Rigor
         # 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.
+        # One entry per dead-assignment write, as `{def_node:, write_node:}`. Empty when the tree has no
+        # qualifying writes.
         def initialize(scope_index)
           @scope_index = scope_index
           @results = []

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

@@ -24,10 +24,10 @@ module Rigor
       # currently declaration-sourced ivar*, so a second hop (`c = @count; d = c`) and an `||=` rewrite land on
       # the plain `with_local` path and carry no mark.
       #
-      # A branch join is NOT one of those cases, contrary to what this comment claimed when it landed: both
-      # arms of `if c then r = @count else r = @count end` stamp `(:local, :r)`, and `join_declaration_sourced`
-      # INTERSECTS, so the mark survives. Only an *asymmetric* join drops it, and by that intersection rather
-      # than by reaching `with_local`. The normative statement — establishment, drop, join and the full list of
+      # A branch join keeps the mark when both arms stamp it: `if c then r = @count else r = @count end` stamps
+      # `(:local, :r)` on each arm, and `join_declaration_sourced` INTERSECTS, so the mark survives. Only an
+      # *asymmetric* join drops it, by that intersection rather than by reaching `with_local`. The normative
+      # statement — establishment, drop, join and the full list of
       # unmarked shapes, each verified against the implementation — is
       # `docs/internal-spec/inference-engine.md` § "Declaration-sourced provenance mark (ADR-58)"; keep this
       # comment subordinate to it.
@@ -59,6 +59,14 @@ module Rigor
           end
         end
 
+        # Issue #2656 — true when `node` reads a local a class guard narrowed from a `Dynamic` value
+        # ({Scope#with_gradual_narrowing_mark}). `call.argument-type-mismatch` judges such an argument by its class
+        # rather than against the parameter's literals (`CheckRules#gradual_narrowing_accepted?`); the other rules
+        # read the narrowed `Nominal` as before.
+        def gradual_narrowed?(node, scope)
+          node.is_a?(Prism::LocalVariableReadNode) && scope.gradual_narrowing?(node.name)
+        end
+
         # The globals whose declared seeds `node` still reads, empty for none: a read of a marked global, or of a
         # local copied from one or more (`sep = $/`, `Scope#declaration_sourced_global_copies`), bare or in
         # parentheses (`($stdout)`).

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

@@ -36,8 +36,8 @@ module Rigor
         # a Hash literal, loops and blocks included.
         NODE_CLASSES = [Prism::HashNode, Prism::KeywordHashNode].freeze
 
-        # Returns `Array<{hash_node:, key_node:, first_key_node:, key_label:}>` — one entry per LATER
-        # occurrence of a repeated literal key (`key_node` is the repeat the diagnostic points at;
+        # One entry per LATER occurrence of a repeated literal key, carrying `hash_node`, `key_node`,
+        # `first_key_node` and `key_label` (`key_node` is the repeat the diagnostic points at;
         # `first_key_node` is the earliest occurrence its message references). Empty when the tree has no
         # qualifying duplicates.
         def initialize(scope_index)

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

@@ -29,6 +29,13 @@ module Rigor
       #   under the ivar's `@`-prefixed name, which no local can spell — because the write and the read are
       #   separate statements. The mark is method-local: the class-ivar census that seeds a sibling method's
       #   ivars types the write's RHS without the inference seed, so a cross-method read is not a lower bound.
+      # - `Array(param)` (issue #2280): the conversion passes the parameter's elements through, so
+      #   `Array(param).first.upcase` reads the lower bound back.
+      # - an `if` / `unless` / ternary whose value is the parameter (issue #2280): `(c ? param : param).upcase`.
+      #   Unlike `&&` / `||`, a branch that does not hold the parameter keeps its diagnostic: the form is rooted
+      #   when every branch that can run is. A predicate the engine folds to one arm (the same certainty
+      #   `StatementEvaluator#eval_if` elides the dead arm on) leaves only that arm to decide, so
+      #   `(c ? param : 1).upcase` declines when `c` folds truthy and reports `Integer` when it folds falsey.
       #
       # Every value derived from an inferred parameter by dispatch is itself a lower bound, so firing against it
       # is an FP by the same construction. No-op on a normal `check` run — `Scope#inferred_param?` is false
@@ -40,40 +47,105 @@ module Rigor
         # length, which is tiny in practice).
         MAX_DEPTH = 64
 
-        def rooted?(node, scope, depth = 0)
+        # `fold` is whether `scope` is still the scope the walked node is evaluated in. The callers pass the scope
+        # at the start of the expression; once the walk passes something evaluated earlier inside it (a leading
+        # statement, the left operand of `&&`, an earlier literal element, a conditional's predicate), that
+        # earlier code may have rebound what a nested predicate reads (`(c = false; c ? param : 1)`), so a
+        # conditional below no longer folds its predicate in `scope`.
+        def rooted?(node, scope, depth = 0, fold: true)
           return false if node.nil? || depth > MAX_DEPTH
 
           case node
           when Prism::LocalVariableReadNode, Prism::InstanceVariableReadNode then scope.inferred_param?(node.name)
-          when Prism::CallNode then rooted?(node.receiver, scope, depth + 1)
+          when Prism::CallNode then call_rooted?(node, scope, depth + 1, fold)
           when Prism::ArrayNode, Prism::HashNode, Prism::KeywordHashNode, Prism::AssocNode
-            literal_rooted?(node, scope, depth + 1)
-          else combining_rooted?(node, scope, depth + 1)
+            literal_rooted?(node, scope, depth + 1, fold)
+          else combining_rooted?(node, scope, depth + 1, fold)
+          end
+        end
+
+        def call_rooted?(node, scope, depth, fold)
+          return rooted?(node.receiver, scope, depth, fold: fold) unless array_conversion?(node, scope)
+
+          rooted?(node.arguments.arguments.first, scope, depth, fold: fold)
+        end
+
+        # A receiverless `Array(x)` reaching Kernel#Array: exactly one plain argument, no block, and no project
+        # `Array` on `self`'s class or its project ancestors to bind ahead of Kernel's.
+        def array_conversion?(node, scope)
+          node.receiver.nil? && node.name == :Array && node.block.nil? &&
+            node.arguments&.arguments&.size == 1 && !project_array_method?(scope)
+        end
+
+        def project_array_method?(scope)
+          self_type = scope.self_type
+          case self_type
+          when Type::Nominal then scope.discovered_method_through_ancestors?(self_type.class_name, :Array, :instance)
+          when Type::Singleton
+            scope.discovered_method_through_ancestors?(self_type.class_name, :Array, :singleton)
+          else false
           end
         end
 
         # An array or hash literal is rooted when any element is: the engine reads the element back precisely.
-        def literal_rooted?(node, scope, depth)
+        def literal_rooted?(node, scope, depth, fold)
           parts = node.is_a?(Prism::AssocNode) ? [node.key, node.value] : node.elements
-          parts.any? { |part| rooted?(part, scope, depth) }
+          parts.each_with_index.any? { |part, index| rooted?(part, scope, depth, fold: fold && index.zero?) }
         end
 
         # Value-combining forms: the produced value is a union of the operands, so it is a lower bound when ANY
         # operand is inferred-parameter-rooted (`cps[i] - x rescue -1`, `a && param.foo`, `param || b`). Declining
         # on the whole expression is FP-safe by the same lower-bound argument.
-        def combining_rooted?(node, scope, depth)
+        def combining_rooted?(node, scope, depth, fold)
           case node
           when Prism::RescueModifierNode
-            rooted?(node.expression, scope, depth) || rooted?(node.rescue_expression, scope, depth)
-          when Prism::AndNode, Prism::OrNode then rooted?(node.left, scope, depth) || rooted?(node.right, scope, depth)
-          when Prism::ParenthesesNode then rooted?(last_statement(node.body), scope, depth)
-          when Prism::StatementsNode then rooted?(node.body.last, scope, depth)
+            rooted?(node.expression, scope, depth, fold: fold) ||
+              rooted?(node.rescue_expression, scope, depth, fold: false)
+          when Prism::AndNode, Prism::OrNode
+            rooted?(node.left, scope, depth, fold: fold) || rooted?(node.right, scope, depth, fold: false)
+          when Prism::ParenthesesNode then body_rooted?(node.body, scope, depth, fold)
+          when Prism::StatementsNode then body_rooted?(node, scope, depth, fold)
+          when Prism::IfNode, Prism::UnlessNode then conditional_rooted?(node, scope, depth, fold)
+          when Prism::ElseNode then rooted?(node.statements, scope, depth, fold: fold)
+          else false
+          end
+        end
+
+        # A body's value is its last statement; any statement before it runs first.
+        def body_rooted?(body, scope, depth, fold)
+          return rooted?(body, scope, depth, fold: fold) unless body.is_a?(Prism::StatementsNode)
+
+          rooted?(body.body.last, scope, depth, fold: fold && body.body.size == 1)
+        end
+
+        # Every branch that can run must be rooted; an absent branch is `nil`, never rooted. The predicate is
+        # typed only when the branches disagree, so a conditional that never mentions a parameter costs nothing.
+        # An arm runs after the predicate, so a conditional nested in one never folds.
+        def conditional_rooted?(node, scope, depth, fold)
+          truthy_rooted, falsey_rooted = arms(node).map { |arm| rooted?(arm, scope, depth, fold: false) }
+          return truthy_rooted if truthy_rooted == falsey_rooted
+          return false unless fold
+
+          case predicate_certainty(node.predicate, scope)
+          when :truthy then truthy_rooted
+          when :falsey then falsey_rooted
           else false
           end
         end
 
-        def last_statement(body)
-          body.is_a?(Prism::StatementsNode) ? body.body.last : body
+        # `[runs when the predicate is truthy, runs when it is falsey]`.
+        def arms(node)
+          node.is_a?(Prism::IfNode) ? [node.statements, node.subsequent] : [node.else_clause, node.statements]
+        end
+
+        # The arm certainty `StatementEvaluator#branch_certainty` elides on: a decidable version guard, else the
+        # predicate's folded truthiness unless an optimistic carrier props it up.
+        def predicate_certainty(predicate, scope)
+          guard = Inference::VersionGuard.verdict(predicate)
+          return guard if guard
+          return nil unless Inference::OptimisticOrigin.resolve(predicate, scope).nil?
+
+          Inference::Narrowing.predicate_certainty(scope.type_of(predicate))
         end
       end
     end

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

@@ -6,6 +6,7 @@ require_relative "rule_walk"
 require_relative "../../scope/resolution_chain"
 require_relative "../../source/constant_path"
 require_relative "../../source/node_children"
+require_relative "../../inference/census_foreign_block"
 
 module Rigor
   module Analysis
@@ -28,6 +29,9 @@ module Rigor
       #   doesn't yet model.
       # - Nested classes / modules / defs inside a method body are barriers, mirroring the indexer's
       #   `IVAR_BARRIER_NODES` policy.
+      # - Issue #2943: a write directly in a block or `class << obj` body whose `self` is provably not an instance
+      #   of the class (`Other.new.instance_eval { @r = 1 }`), by the class-ivar census's rule
+      #   ({Inference::CensusForeignBlock}).
       class IvarWriteCollector
         BARRIER_NODES = [Prism::DefNode, Prism::ClassNode, Prism::ModuleNode].freeze
         private_constant :BARRIER_NODES
@@ -44,8 +48,9 @@ module Rigor
         NODE_CLASSES = [Prism::DefNode, Prism::CallNode].freeze
         RULE_WALK_GATES = %i[inside_def detached_ivar_facet].freeze
 
-        # Returns `Hash[class_name (String) => Hash[ivar_name (Symbol) => Array<{node:, type:, declared:,
-        # method_name:, visibility:, per_invocation:, action:}>]]`. Empty when the tree has no qualifying writes.
+        # Groups the writes by class qualified name, then by ivar name. Each write carries `node`, `type`,
+        # `declared`, `method_name`, `visibility`, `per_invocation` and `action`. Empty when the tree has no
+        # qualifying writes.
         # `declared` is the translated type of the class's RBS declaration of the ivar — an `@x: T` member or
         # the slot an `attr_*` member implies, own or inherited — and nil when the RBS declares none.
         #
@@ -155,7 +160,8 @@ module Rigor
 
         def collect_def_writes(def_node, qualified_prefix)
           return if def_node.body.nil? || qualified_prefix.empty?
-          return if def_node.receiver.is_a?(Prism::SelfNode)
+          # A def with a receiver writes the ivars of another object than an instance (#3155).
+          return if def_node.receiver
 
           class_name = qualified_prefix.join("::")
           gather_writes(def_node.body, class_name, def_node.name)
@@ -167,7 +173,13 @@ module Rigor
           record_write(node, class_name, method_name) if node.is_a?(Prism::InstanceVariableWriteNode)
           return if BARRIER_NODES.any? { |klass| node.is_a?(klass) }
 
-          node.rigor_each_child { |child| gather_writes(child, class_name, method_name) }
+          # #2943 — a block or `class <<` body whose `self` is provably another object writes that object's ivars, as
+          # the class-ivar census reads it ({Inference::CensusForeignBlock}); a `define_method` block nested in it that
+          # runs on an instance again still counts. A `def` it reenters stays a barrier here.
+          children = Inference::CensusForeignBlock.census_children(node, class_name)
+          return node.rigor_each_child { |child| gather_writes(child, class_name, method_name) } unless children
+
+          children.each { |child| gather_writes(child, class_name, method_name) }
         end
 
         def record_write(node, class_name, method_name)

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

@@ -5,6 +5,7 @@ require "prism"
 require_relative "../../inference/scope_indexer"
 require_relative "../../source/node_children"
 require_relative "rebinding_block_callees"
+require_relative "replaced_singleton_defs"
 
 module Rigor
   module Analysis
@@ -42,6 +43,11 @@ module Rigor
 
         def refinements = (@refinements ||= Inference::InEffectRefinements.new(@root))
 
+        # Issue #3155 — the file's singleton defs a later certain def replaces, for `def.return-type-mismatch`.
+        def replaced_singleton_defs(scope_index)
+          @replaced_singleton_defs ||= ReplacedSingletonDefs.new(@root, scope_index)
+        end
+
         # Issue #1817 — the file's block-passing calls, for `call.unresolved-toplevel`'s rebinding-callee decline.
         def block_calls = (@block_calls ||= RebindingBlockCallees::Sites.new(@root))
 
@@ -152,7 +158,6 @@ module Rigor
           end
         end
 
-        # `o.singleton_class`.
         def singleton_class_of_local?(node)
           node.is_a?(Prism::CallNode) && node.name == :singleton_class && node.arguments.nil? &&
             node.receiver.is_a?(Prism::LocalVariableReadNode)

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

@@ -12,16 +12,13 @@ module Rigor
       # 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 stays in `CheckRules` (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; `#results` are the accumulated {Diagnostic}s in
+      # the walk's emission order.
       class MainPassCollector
         # The node classes the main pass branches on. A plain `Prism::IfNode` covers ternaries and postfix `if`
-        # too (the legacy `when Prism::IfNode, Prism::UnlessNode` arm did the same). The three global-write
-        # classes carry issue #1367's `global.*` rules.
+        # too. The global-write classes and `MultiWriteNode` carry issue #1367's `global.*` rules.
         NODE_CLASSES = [
           Prism::CallNode, Prism::DefNode, Prism::IfNode, Prism::UnlessNode,
           Prism::GlobalVariableWriteNode, Prism::GlobalVariableOperatorWriteNode, Prism::MultiWriteNode