rigortype 0.4.7 → 0.4.8

data/lib/rigor/inference/last_line/self_evidence.rb

@@ -4,6 +4,7 @@ require "prism"
 
 require_relative "../../source/constant_path"
 require_relative "../../source/node_children"
+require_relative "../../typing_state"
 
 module Rigor
   module Inference
@@ -50,6 +51,9 @@ module Rigor
       #   `undef_method :gets`), other than `&:gets` and the first argument of a call that only names a method
       #   (`respond_to?(:gets)`, `send(:gets)`).
       class SelfEvidence
+        TypingState.memo_field(self, :@scan, reason: "one walk of the file's root node, built on first ask")
+        TypingState.memo_field(self, :@const_set_spellings, reason: "one walk of the file's root, built on first ask")
+
         # The context of a reader whose `self` is `main`.
         MAIN = :main
         UNKNOWN = :unknown
@@ -83,8 +87,14 @@ module Rigor
         def initialize(root)
           @root = root
           @scan = nil
+          @const_set_spellings = nil
         end
 
+        # Issue #3156 — the constants this file binds by a `const_set` with a literal name on the body's own module
+        # (implicit `self` or `self.const_set`) inside a `class` / `module` body, qualified by that body's nesting
+        # (`module NS; const_set(:AMid, Other)` binds `"NS::AMid"`). The census files no such write.
+        def const_set_spellings = (@const_set_spellings ||= collect_const_sets(@root, nil, Set.new).freeze)
+
         # {MAIN}, the `Prism::ClassNode` or `Prism::ModuleNode` whose body the implicit-self reader `call_node` runs
         # in, or nil: the file may give it another `self`, or it is not one of this file's readers.
         def context(call_node) = scan.context(call_node)
@@ -96,6 +106,26 @@ module Rigor
 
         def scan = (@scan ||= Scan.new(@root))
 
+        def collect_const_sets(node, namespace, found)
+          case node
+          when Prism::ClassNode, Prism::ModuleNode
+            inner = Source::ConstantPath.pushed_nesting(namespace ? [namespace] : [], node.constant_path)&.first
+            collect_const_sets(node.body, inner, found) if inner
+            return found
+          when Prism::CallNode
+            found << "#{namespace}::#{literal_const_set_name(node)}" if namespace && literal_const_set_name(node)
+          end
+          node&.compact_child_nodes&.each { |child| collect_const_sets(child, namespace, found) }
+          found
+        end
+
+        def literal_const_set_name(node)
+          return nil unless node.name == :const_set && (node.receiver.nil? || node.receiver.is_a?(Prism::SelfNode))
+
+          name = node.arguments&.arguments&.first
+          name.unescaped if name.is_a?(Prism::SymbolNode) || name.is_a?(Prism::StringNode)
+        end
+
         # One walk of the file, whose answers {SelfEvidence} keeps once the walk is complete.
         class Scan
           def initialize(root)

data/lib/rigor/inference/last_line.rb

@@ -261,10 +261,13 @@ module Rigor
       # The scope a block or lambda body enters with, as {MatchRebinding.block_entry} gives the match globals': `$_`
       # forgotten when the body may set it, which a later iteration then reads, when the frame makes a closure that
       # may, or when the owning call may: its receiver chain and arguments run before the method yields, and
-      # `IO.foreach` sets `$_` to each line it yields.
+      # `IO.foreach` sets `$_` to each line it yields. Issue #3195 — and whatever the body does when it runs later
+      # than where it is written ({FreshFrameBlocks.deferred_body?}): a proc's body, an enumerator's or a hash's
+      # default proc reads the `$_` the slot holds when it runs.
       def block_entry(scope, block_node, call_node = nil)
         return scope unless scope.last_line_bound?
-        return scope unless scope.last_line_closure? || may_set?(block_node.body, scope) || call_sets?(call_node, scope)
+        return scope unless FreshFrameBlocks.deferred_body?(block_node, call_node, scope) ||
+                            scope.last_line_closure? || may_set?(block_node.body, scope) || call_sets?(call_node, scope)
 
         scope.forget_last_line
       end

data/lib/rigor/inference/loop_value_record.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require_relative "../run_scoped_slots"
+require_relative "../typing_state"
 
 module Rigor
   module Inference
@@ -17,40 +17,88 @@ module Rigor
     # `discovery`): across the cost spec's 10933 reads every match was an identity match, and `lib/` read no record at
     # all (issue #2262). It lives in a per-thread map keyed by the loop node. The map's keys are weak but its values
     # are strong, and a recorded scope reaches its discovery, its environment and the parse tree that holds the key,
-    # so a record never goes on its own (issue #2412): the map is a run-scoped slot ({RunScopedSlots}), emptied when
-    # the run that filled it ends.
+    # so a record never goes on its own (issue #2412): the map is a run-scoped slot ({TypingState.release_run_scoped}),
+    # emptied when the run that filled it ends.
     module LoopValueRecord
-      KEY = RunScopedSlots.register(:rigor_loop_value_record)
-      private_constant :KEY
+      # ADR-129 WD1 — a Table, and a read-through cache of the computation's own value: a record read back answers
+      # what evaluating the loop again from the same scope would.
+      RECORD = TypingState.table(
+        :loop_value_record,
+        run_scoped: true, read_through: true, entries: TypingState::WeakKeyMapEntries,
+        reason: "keyed by loop node; a read-through cache of the loop's own evaluation"
+      )
+      private_constant :RECORD
 
-      module_function
+      # ADR-129 WD3 — a Resource read only as a delta: {#loops_evaluated} feeds a before/after comparison taken within
+      # one conditional's evaluation, so with no loop evaluated in between the delta is zero.
+      LOOPS_EVALUATED = TypingState.resource(
+        :loops_evaluated,
+        read_exemption: :delta_internal, run_scoped: true,
+        reason: "a count of the loops this thread evaluated, incremented in place and read as a delta"
+      )
+      private_constant :LOOPS_EVALUATED
+
+      # Issue #2767 — the ADR-55 fixpoint summaries are an ambient input of a loop's value: an ADR-55 fixpoint
+      # evaluates a recursive method's body several times from the same body scope object, each time under a wider
+      # assumption, so a value recorded in one iteration would answer an identity-matching read in the next one with
+      # the narrower iterate, and the fixpoint would converge on it (`[(while …; break(n.zero? ? 1 : q(n - 1)); end)]`
+      # typed `[bot]`). The generation moves whenever a summary's assumption is seeded or changed
+      # ({advance_generation}), and a record answers only a read in the generation it was written in. The advance in
+      # `fixpoint_step` is the one a witness needs (the spec above); the advances at the seed, the entangled degrade
+      # and the cap collapse are precautions, since each leaves no in-flight evaluation of that body scope behind.
+      #
+      # ADR-129 WD3 — a Resource whose value is fixed while the state id is: every advance is a {TypingState::State#rewrite}.
+      GENERATION = TypingState.resource(
+        :summary_generation,
+        read_exemption: :id_determined, run_scoped: true,
+        reason: "a count of the ADR-55 summary assumption changes on this thread; a record keys on it"
+      )
+      private_constant :GENERATION
 
-      COUNT_KEY = RunScopedSlots.register(:rigor_loop_value_count)
-      private_constant :COUNT_KEY
+      module_function
 
       def record(node, scope, type)
-        Thread.current[COUNT_KEY] = loops_evaluated + 1
+        TypingState.current.write(LOOPS_EVALUATED, loops_evaluated + 1)
         conditional(node, scope, type)
       end
 
+      # The current ADR-55 summary generation (#2767), which a record made now carries and a read must match.
+      def generation = TypingState.current[GENERATION] || 0
+
+      # A summary assumption was seeded or changed: no record written before answers a read from now on (#2767).
+      def advance_generation
+        state = TypingState.current
+        state.write(GENERATION, (state[GENERATION] || 0) + 1)
+        state.rewrite(GENERATION)
+      end
+
       # How many loops this thread has evaluated, so a conditional can tell whether its evaluation held one.
-      def loops_evaluated = Thread.current[COUNT_KEY] || 0
+      def loops_evaluated = TypingState.current[LOOPS_EVALUATED] || 0
 
       # The same record for a conditional that evaluated a loop in a branch: `id(c ? (while …) : 0)` types the
       # conditional again from the scope it was evaluated from, and each typing evaluated the loop again from a
       # branch scope of its own, which multiplied the passes of every loop nested in it (issue #2262).
       def conditional(node, scope, type)
-        (Thread.current[KEY] ||= ObjectSpace::WeakKeyMap.new)[node] = [scope, type]
+        record = [scope, type, generation]
+        state = TypingState.current
+        state.log_write(RECORD, node, record)
+        state.weak_key_map(RECORD)[node] = record
         type
       end
 
-      # The recorded value of `node` evaluated from `scope` itself, or nil.
+      # Runs the evaluation a {fetch} that answered nil falls back to: the read-through Table's miss (ADR-129 WD1),
+      # which touches when it writes another Table while a capture is open.
+      def miss(&) = TypingState.current.memo_miss(RECORD, &)
+
+      # The recorded value of `node` evaluated from `scope` itself in the current summary generation, or nil.
       def fetch(node, scope)
-        slot = Thread.current[KEY]&.[](node)
+        state = TypingState.current
+        slot = state[RECORD]&.[](node)
+        state.log_read(RECORD, node, slot || TypingState::ABSENT)
         return nil if slot.nil?
 
-        recorded, type = slot
-        recorded.equal?(scope) ? type : nil
+        recorded, type, recorded_generation = slot
+        recorded.equal?(scope) && recorded_generation == generation ? type : nil
       end
     end
   end

data/lib/rigor/inference/match_rebinding/frame.rb

@@ -3,6 +3,7 @@
 require "prism"
 
 require_relative "../../source/node_children"
+require_relative "../../typing_state"
 
 module Rigor
   module Inference
@@ -15,6 +16,16 @@ module Rigor
       # `$_` (issue #1359), whose frame-wide answers ({#last_line_closure?}, {#last_line_fallback?}) are kept here
       # too, asked only while `$_` is narrowed.
       class Frame
+        # ADR-129 G4 — the frame's extensional caches. A scan is keyed on its node (and reading kind) and on the scope's
+        # local and instance-variable tables by identity, the inputs a lookup argument's answer reads; the rest of what
+        # it reads through the scope (constant resolution over the lexical nesting, discovery and environment) is fixed
+        # for the body the frame runs. The other three read the body and the parameters alone.
+        TypingState.memo_field(self, :@scans, :@kind_scans, :@self_call_fallback,
+                               reason: "keyed on the node and the scope's locals and ivars tables by identity; the " \
+                                       "other scope inputs a scan reads are fixed for the frame's body")
+        TypingState.memo_field(self, :@forwarded_block, :@body_locals, :@parameter_names,
+                               reason: "functions of the frame's body and parameters alone")
+
         # The body the frame runs, which issue #2555's escape scan reads ({ConstructionEscape.escaped?}).
         attr_reader :body
         # The method's parameters (nil for a class, module or file body), which issue #2608's holder scan reads for a

data/lib/rigor/inference/match_rebinding/yielding_match.rb

@@ -5,40 +5,96 @@ require "prism"
 module Rigor
   module Inference
     module MatchRebinding
-      # Issue #2443 — the match globals a block enters with when the call that owns it matches before every yield.
-      # `String#scan`, `#gsub`, `#gsub!`, `#sub` and `#sub!` set the caller's `$~` to the current match before each
-      # run of their block, with a Regexp pattern or a String one, so the block reads that match on every run
+      # Issue #2443, #1371 — the match globals a block enters with when the call that owns it matches before every
+      # yield. `String#scan`, `#gsub`, `#gsub!`, `#sub` and `#sub!` set the caller's `$~` to the current match before
+      # each run of their block, with a Regexp pattern or a String one, so the block reads that match on every run
       # whatever the enclosing frame held; the frame-wide entry ({MatchRebinding.block_entry}) would otherwise leave
-      # it the narrowing at the call site (issue #1371) or nothing at all, and `Regexp.last_match.begin(0)` in the
-      # block read `MatchData?`.
+      # it the narrowing at the call site or nothing at all.
       #
       # A receiver that is a String, or a `Dynamic` the analyzer cannot type ({Narrowing.string_match_receiver?}),
-      # enters with the call's own match edge ({Narrowing.yielded_match_scope}). A `Dynamic` receiver may be another
-      # object whose block-taking `scan` runs no match, and then the block reads the caller's `$~`; narrowing it
-      # anyway can only drop a diagnostic, never add one (ADR-5). A receiver known to be anything else — a project
-      # class, `Pathname`, a union with either — keeps the frame-wide entry: a method defined in Ruby runs its
-      # matches in a frame of its own, so its block reads the caller's `$~` as the frame rules leave it. So does an
-      # implicit-self call.
+      # enters with the call's own match edge ({Narrowing.yielded_match_scope}), which forgets what the frame held.
+      # A `Dynamic` receiver may be another object whose block-taking `scan` runs no match, and then the block reads
+      # the caller's `$~`; the name is taken as String's there, the overwhelmingly common case. A receiver known to
+      # be anything else — a project class, `Pathname`, a union with either — keeps the frame-wide entry: a method
+      # defined in Ruby runs its matches in a frame of its own, so its block reads the caller's `$~` as the frame
+      # rules leave it. So does an implicit-self call.
+      #
+      # The block form of `grep` and `grep_v` runs `pattern === element` in the caller's frame before each yield,
+      # which a Regexp pattern answers by setting `$~`: `grep` yields after a match, `grep_v` after a failed one. With
+      # a regex literal for the pattern, a `grep` block enters with that match edge and a `grep_v` block with the
+      # globals unbound. `Enumerable` is mixed into classes of every kind, so any explicit receiver counts but one
+      # whose `grep` the project defines ({ProjectMethodOwnership}): that method matches, if at all, in a frame of
+      # its own, and its block keeps the frame-wide entry as a project `scan`'s does. Where a refinement that defines
+      # the name is in effect at the call (issue #3198), the method that runs is the refinement's or `Enumerable`'s,
+      # and this does not tell which, so the block enters with what `Enumerable`'s would bind read untyped. Any other
+      # pattern (`grep(Integer)`) keeps the frame-wide entry too, since its `===` may leave `$~` alone.
       module YieldingMatch
         NAMES = Set[:scan, :gsub, :gsub!, :sub, :sub!].freeze
-        private_constant :NAMES
+        GREP_NAMES = Set[:grep, :grep_v].freeze
+        private_constant :NAMES, :GREP_NAMES
 
         module_function
 
         # `scope` with the match globals `call_node`'s block enters with; `scope` itself for any other block.
         # `operand_scope` types the receiver.
         def entry(scope, block_node, call_node, operand_scope)
-          return scope unless yielding_call?(block_node, call_node) &&
-                              Narrowing.string_match_receiver?(operand_scope.type_of(call_node.receiver), operand_scope)
+          return scope unless own_block_call?(block_node, call_node)
+
+          name = call_node.name
+          if NAMES.include?(name)
+            string_entry(scope, call_node, operand_scope)
+          elsif GREP_NAMES.include?(name)
+            grep_entry(scope, call_node, operand_scope)
+          else
+            scope
+          end
+        end
+
+        def string_entry(scope, call_node, operand_scope)
+          return scope unless Narrowing.string_match_receiver?(operand_scope.type_of(call_node.receiver), operand_scope)
+
+          Narrowing.yielded_match_scope(scope, pattern_argument(call_node))
+        end
+
+        def grep_entry(scope, call_node, operand_scope)
+          pattern = pattern_argument(call_node)
+          return scope unless pattern.is_a?(Prism::RegularExpressionNode) ||
+                              pattern.is_a?(Prism::InterpolatedRegularExpressionNode)
+          return scope if project_method?(call_node, operand_scope)
+
+          entry = call_node.name == :grep_v ? scope.forget_match_globals : Narrowing.yielded_match_scope(scope, pattern)
+          refined?(call_node, operand_scope) ? entry.untyped_match_globals : entry
+        end
+
+        # True when the receiver answers the call with a method the project defines, or is a carrier whose class
+        # cannot be resolved; an untyped receiver is not one.
+        def project_method?(call_node, operand_scope)
+          targets = ProjectMethodOwnership.targets(operand_scope.type_of(call_node.receiver))
+          return true if targets.nil?
+
+          targets.any? do |class_name, kind|
+            ProjectMethodOwnership.defines?(class_name, call_node.name, kind, operand_scope)
+          end
+        end
+
+        # Issue #3198 — true when a refinement in effect at the call defines its name on any class: a refined method
+        # is Ruby's, and matches, if at all, in a frame of its own. The refined class is not compared with the
+        # receiver, so the call may still be `Enumerable`'s.
+        def refined?(call_node, operand_scope)
+          SelfPreservingBlock.refined_in_effect?(call_node, call_node.name, operand_scope)
+        end
 
-          Narrowing.yielded_match_scope(scope)
+        # The call's first argument, which each of these methods takes as its pattern; nil without one.
+        def pattern_argument(call_node)
+          call_node.arguments&.arguments&.first
         end
 
-        def yielding_call?(block_node, call_node)
-          call_node.is_a?(Prism::CallNode) && NAMES.include?(call_node.name) && !call_node.receiver.nil? &&
+        def own_block_call?(block_node, call_node)
+          call_node.is_a?(Prism::CallNode) && !call_node.receiver.nil? &&
             block_node.is_a?(Prism::BlockNode) && call_node.block.equal?(block_node)
         end
-        private_class_method :yielding_call?
+        private_class_method :string_entry, :grep_entry, :project_method?, :refined?, :pattern_argument,
+                             :own_block_call?
       end
     end
   end

data/lib/rigor/inference/match_rebinding.rb

@@ -7,6 +7,8 @@ require_relative "../type"
 require_relative "block_call_timing"
 require_relative "fresh_frame_blocks"
 require_relative "guard_rebinding"
+require_relative "project_method_ownership"
+require_relative "self_preserving_block"
 require_relative "stored_block_call"
 require_relative "match_rebinding/frame"
 require_relative "match_rebinding/operands"
@@ -364,14 +366,20 @@ module Rigor
       # ractor's root block with the globals unbound, since it reads a slot of its own, and a `define_method` body
       # with a narrowed global untyped, since it reads the definer's slot whenever the method is called. `$_`, which
       # shares the slot, enters on the same terms ({LastLine.block_entry}, issue #1359). A closure's body, which runs
-      # whenever it is called, enters with `$!`, `$@` and `$?` unbound ({FreshFrameBlocks.closure_entry}, issue #1360).
+      # whenever it is called, enters with `$!`, `$@` and `$?` unbound ({FreshFrameBlocks.closure_entry}, issue #1360),
+      # and with the match globals unbound whatever its body does ({FreshFrameBlocks.proc_body?}, issue #1371): the
+      # narrowing where a lambda or proc is written proves nothing about the `$~` it reads when it is called. The
+      # block of `Enumerator.new` or `Hash.new` on the core class runs later too, but often in the statement that
+      # makes it, so where none of the rules above forgets them it enters with a narrowed global untyped
+      # ({FreshFrameBlocks.deferred_constructor?}, issue #3195).
       #
       # Issue #1429 — the entry also restores a guard's narrowing of a global or constant where the body may run after
       # code that rebinds it ({GuardRebinding.block_entry}).
       #
-      # Issue #2443 — the block of a call that matches before every yield (`scan`, `gsub`, `sub`, …) on a String or
-      # untyped receiver enters with that call's own match edge, laid over the entry above ({YieldingMatch}); a match
-      # its body runs still rebinds them through the statement-level rules.
+      # Issue #2443, #1371 — the block of a call that matches before every yield (`scan`, `gsub`, `sub`, … on a String
+      # or untyped receiver, `grep` and `grep_v` with a regex literal) enters with that call's own match edge in place
+      # of the entry above ({YieldingMatch}); a match its body runs still rebinds them through the statement-level
+      # rules.
       def block_entry(scope, block_node, call_node = nil)
         operand_scope = scope
         scope = GuardRebinding.block_entry(scope, block_node, call_node)
@@ -384,10 +392,15 @@ module Rigor
 
       def frame_entry(scope, block_node, call_node)
         return scope unless scope.match_globals_bound?
-        return scope unless scope.match_rebinding_closure? || entry_may_match?(block_node.body, scope, call_node) ||
-                            (call_node.is_a?(Prism::CallNode) && operands_may_rebind?(call_node, scope))
+        return scope.forget_match_globals if entry_forgets?(scope, block_node, call_node)
 
-        scope.forget_match_globals
+        FreshFrameBlocks.deferred_constructor?(block_node, call_node, scope) ? scope.untyped_match_globals : scope
+      end
+
+      def entry_forgets?(scope, block_node, call_node)
+        FreshFrameBlocks.proc_body?(block_node, call_node, scope) ||
+          scope.match_rebinding_closure? || entry_may_match?(block_node.body, scope, call_node) ||
+          (call_node.is_a?(Prism::CallNode) && operands_may_rebind?(call_node, scope))
       end
 
       def entry_may_match?(body, scope, call_node)
@@ -396,7 +409,7 @@ module Rigor
 
         body.is_a?(Prism::Node) && scan(body, scope, base: true)
       end
-      private_class_method :frame_entry, :entry_may_match?
+      private_class_method :frame_entry, :entry_forgets?, :entry_may_match?
     end
   end
 end

data/lib/rigor/inference/method_dispatcher/block_folding.rb

@@ -2,6 +2,7 @@
 
 require_relative "../../type"
 require_relative "iterator_dispatch"
+require_relative "core_enumerable_receiver"
 
 module Rigor
   module Inference
@@ -37,12 +38,12 @@ module Rigor
       module BlockFolding
         module_function
 
-        FILTER_KEEP_ON_TRUTHY = Set[:select, :filter, :take_while].freeze
+        FILTER_KEEP_ON_TRUTHY = Set[:select, :filter, :find_all, :take_while].freeze
         FILTER_KEEP_ON_FALSEY = Set[:reject, :drop_while].freeze
 
-        # The filter methods `Hash` defines itself, returning a Hash. `take_while` / `drop_while` on a Hash
-        # are Enumerable's and return an Array of `[key, value]` pairs; `Set` and `Range` define none of the
-        # five, so all of theirs return an Array too.
+        # The filter methods `Hash` defines itself, returning a Hash. `find_all` / `take_while` /
+        # `drop_while` on a Hash are Enumerable's and return an Array of `[key, value]` pairs; `Set` and
+        # `Range` define none of the six, so all of theirs return an Array too.
         HASH_RETURNING_FILTERS = Set[:select, :filter, :reject].freeze
 
         # `filter_receiver_kind`'s answer for a nominal receiver; an unlisted class declines.
@@ -52,21 +53,22 @@ module Rigor
 
         PREDICATE_METHODS = Set[:all?, :any?, :none?].freeze
 
-        # Methods whose answer is `nil` when the block always returns Ruby-falsey — `find` / `detect`
-        # short-circuit to nil when nothing matches, `find_index` / `index` likewise. These methods only fold
-        # on the falsey side for now; the truthy-block side requires per-position analysis (the index of the
-        # first kept element, or the element itself, depend on the receiver's shape and on which positions
-        # actually evaluate to truthy).
-        FALSEY_BLOCK_NIL_METHODS = Set[:find, :detect, :find_index, :index].freeze
+        # Methods whose answer is `nil` when the block always returns Ruby-falsey — `find` / `detect` /
+        # `rfind` short-circuit to nil when nothing matches, `find_index` / `index` / `rindex` likewise.
+        # These methods only fold on the falsey side here; the truthy-block side requires per-position
+        # analysis.
+        FALSEY_BLOCK_NIL_METHODS = Set[:find, :detect, :rfind, :find_index, :index, :rindex].freeze
+        ARRAY_ONLY_FALSEY_NIL_METHODS = Set[:rfind, :index, :rindex].freeze
 
         # Block-taking `count` returns the number of elements for which the block is truthy. With a
         # Constant-falsey block the answer is unconditionally `Constant[0]`; with a Constant-truthy block on
         # a finitely-sized receiver it is `Constant[size]`.
         COUNT_METHOD = :count
 
-        # `min_by` / `max_by` pick one element by the block's key, so the block's value decides WHICH element
-        # but never WHETHER one is returned: only an empty receiver answers `nil`.
-        EDGE_BY_METHODS = Set[:min_by, :max_by].freeze
+        # `min_by` / `max_by` / `minmax_by` pick edge elements by the block's key, so the block's value
+        # decides WHICH element(s) but never WHETHER one is returned: only an empty receiver answers `nil`
+        # (or `[nil, nil]` for `minmax_by`).
+        EDGE_BY_METHODS = Set[:min_by, :max_by, :minmax_by].freeze
 
         # `context.block_type` is the inferred return type of the call's block; `nil` means "no block at the
         # call site" and disqualifies every rule here.
@@ -76,32 +78,44 @@ module Rigor
           args = context.args
           block_type = context.block_type
           return nil if receiver.nil? || block_type.nil?
-          return fold_edge_by(receiver, args) if EDGE_BY_METHODS.include?(method_name)
+          return fold_edge_by(receiver, method_name, args) if EDGE_BY_METHODS.include?(method_name)
 
+          # Issue #3242 — the predicate, `find`-family and `count` folds read no receiver shape, so a class that
+          # may define the method itself declines (the filter folds already do, through `filter_receiver_kind`).
           truthiness = constant_truthiness(block_type)
-          return nil if truthiness.nil?
+          return nil if truthiness.nil? || CoreEnumerableReceiver.project_receiver?(receiver)
 
           if PREDICATE_METHODS.include?(method_name)
             fold_predicate(receiver, method_name, truthiness, args)
           elsif filter_method?(method_name)
             fold_filter(receiver, method_name, truthiness)
           elsif FALSEY_BLOCK_NIL_METHODS.include?(method_name)
-            fold_falsey_nil_short_circuit(method_name, truthiness, args)
+            fold_falsey_nil_short_circuit(receiver, method_name, truthiness, args)
           elsif method_name == COUNT_METHOD
             fold_count(receiver, truthiness, args)
           end
         end
 
-        # Issue #1333 — `min_by` / `max_by` with a block and no count on a non-empty Tuple or a non-empty
-        # constant integer `Range` answer the receiver's element type: the RBS `Elem?` return adds `nil` for
-        # the empty receiver, and `[1, 2].min_by { |s| rand(3) } + 1` then reported a nil receiver on correct
-        # code. The block's value picks which element, and one `block_type` typed from the call's entry scope
-        # cannot say which, so the answer is the whole element union. An empty receiver, one whose size is
-        # not static (`Array[T]`), and the count form (`min_by(2) { … }`, an Array) decline to RBS.
-        def fold_edge_by(receiver, args)
+        # Issue #1333 — `min_by` / `max_by` / `minmax_by` with a block and no count on a Tuple or constant
+        # integer `Range` answer the receiver's element type without `nil` when non-empty (or `[nil, nil]`
+        # for an empty `minmax_by`), avoiding false `nil` receivers on `min_by` / `minmax_by` calls.
+        def fold_edge_by(receiver, method_name, args)
           return nil unless args.empty?
-          return nil unless receiver_emptiness(receiver) == :non_empty
 
+          emptiness = receiver_emptiness(receiver)
+          if method_name == :minmax_by && emptiness == :empty
+            nil_const = Type::Combinator.constant_of(nil)
+            return Type::Combinator.tuple_of(nil_const, nil_const)
+          end
+          return nil unless emptiness == :non_empty
+
+          element = edge_by_element_type(receiver)
+          return nil if element.nil?
+
+          method_name == :minmax_by ? Type::Combinator.tuple_of(element, element) : element
+        end
+
+        def edge_by_element_type(receiver)
           case receiver
           when Type::Tuple then Type::Combinator.union(*receiver.elements)
           when Type::Constant then IteratorDispatch.element_type_of(receiver) if receiver.value.is_a?(Range)
@@ -288,13 +302,13 @@ module Rigor
           end
         end
 
-        # `find` / `detect` / `find_index` / `index` (block form) short-circuit to nil when the block is
-        # provably falsey. `index` and `find_index` also accept a non-block argument form
-        # (`arr.index(value)`); we decline whenever the call carries a positional argument so the RBS tier
-        # still answers the value-search variant correctly.
-        def fold_falsey_nil_short_circuit(_method_name, truthiness, args)
+        # `find` / `detect` / `find_index` (and Array-only `rfind` / `index` / `rindex`) short-circuit to
+        # nil when the block is provably falsey. Calls with a positional argument decline so the RBS tier
+        # answers value-search calls.
+        def fold_falsey_nil_short_circuit(receiver, method_name, truthiness, args)
           return nil unless args.empty?
           return nil unless truthiness == :falsey
+          return nil if ARRAY_ONLY_FALSEY_NIL_METHODS.include?(method_name) && filter_receiver_kind(receiver) != :array
 
           Type::Combinator.constant_of(nil)
         end

data/lib/rigor/inference/method_dispatcher/class_keyed_block_params.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+require_relative "../../type"
+
+module Rigor
+  module Inference
+    module MethodDispatcher
+      # Issue #2686 — `Rigor::Plugin::Base.node_rule(node_class) { |node, ...| }` yields instances of the class it is
+      # given, which RBS cannot say: `[N < ::Prism::Node] (singleton(N))` does not resolve (RBS has no
+      # `singleton(<type variable>)`). `sig/rigor/plugin/base.rbs` declares per-class overloads for the classes
+      # the bundled plugins register and a `Prism::Node` fallback. Read through the overloads alone, two calls bind
+      # `node` wrong:
+      #
+      # - a class with no overload of its own (`node_rule(Prism::IfNode)`) takes the fallback, so `node` is
+      #   `Prism::Node` and `node.predicate` reported `call.undefined-method`;
+      # - a class argument the engine cannot read (`def self.reg(k) = node_rule(k) { ... }`) matches every overload
+      #   gradually, and the block probe took the first, `Prism::CallNode`.
+      #
+      # This rebinds the block's first parameter from the class argument:
+      #
+      # - `singleton(X)` binds `X`, and a union of class objects the union of their instances;
+      # - any other argument (an untyped parameter, a `Class` value) binds `Dynamic[top]`, so the body is not
+      #   checked against a class the call may not register.
+      #
+      # The rest of the block's parameters keep the overload's binding; every overload declares them alike.
+      #
+      # A per-class overload set generated from Prism's node classes was the alternative. It was declined: the
+      # gemspec admits `prism >= 1.0, < 2.0`, and a generated set names classes later minors added, which an older
+      # Prism's RBS does not declare, so loading Rigor's own `sig/` would fail there.
+      #
+      # Only the declaration Rigor owns is read, by the method's RBS owner, so a project's own `node_rule` is not.
+      module ClassKeyedBlockParams
+        OWNER = "::Rigor::Plugin::Base"
+        METHOD = :node_rule
+        private_constant :OWNER, :METHOD
+
+        module_function
+
+        # @param method_definition — the RBS declaration the probe read.
+        # @param params — the block parameters the overloads bound.
+        # @return the block parameters, the first rebound for `Base.node_rule`.
+        def rebind(method_definition, method_name, args, params)
+          return params unless method_name == METHOD
+          return params unless method_definition.defined_in.to_s == OWNER
+
+          [instance_of(args.first), *params.drop(1)]
+        end
+
+        # The instances the class argument names, or `Dynamic[top]`.
+        def instance_of(arg)
+          case arg
+          when Type::Singleton
+            Type::Combinator.nominal_of(arg.class_name)
+          when Type::Union
+            return Type::Combinator.untyped unless arg.members.all?(Type::Singleton)
+
+            Type::Combinator.union(*arg.members.map { |member| Type::Combinator.nominal_of(member.class_name) })
+          else
+            Type::Combinator.untyped
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rigor/inference/method_dispatcher/core_enumerable_receiver.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+require_relative "../../type"
+
+module Rigor
+  module Inference
+    module MethodDispatcher
+      # Issue #3242 — whether a receiver's `find` / `detect` / `find_index` / `count` / `all?` / `any?` / `none?`
+      # may be other than core's. {BlockFolding}'s constant-block folds for those methods read no receiver shape, so
+      # they answer core's semantics, and they are sound only on a carrier known to be a core collection or
+      # enumerable. Anything else may define the method itself: a project class (`class Bag; def find = (yield; 8);
+      # end`), a subclass of a core class (its own `Nominal`), a class object (`def self.find`), a `Data.define` or
+      # `Struct.new` class, or a scalar that has no such method at all.
+      module CoreEnumerableReceiver
+        module_function
+
+        # The nominal receivers whose methods above are core's: Array's, Hash's, Set's, Range's own, or
+        # Enumerable's. `RBS::Unnamed::ENVClass` is `ENV`, which extends Enumerable.
+        NOMINALS = Ractor.make_shareable(
+          Set[
+            "Array", "Hash", "Set", "Range", "Enumerable", "Enumerator", "Enumerator::Lazy",
+            "Enumerator::ArithmeticSequence", "Enumerator::Chain", "Enumerator::Product", "Dir",
+            "RBS::Unnamed::ENVClass"
+          ].freeze
+        )
+
+        # False only for a carrier known to be a core collection or enumerable: a `Tuple` / `HashShape` literal
+        # shape, a `Constant` `Range` or `Set`, a `Nominal` in {NOMINALS}, `Top`, and a `Dynamic` / `Difference` /
+        # `Refined` / `Union` / `Intersection` over those. Every other receiver is true, so the folds decline.
+        def project_receiver?(receiver)
+          case receiver
+          when Type::Tuple, Type::HashShape, Type::Top then false
+          when Type::Constant then !(receiver.value.is_a?(Range) || receiver.value.is_a?(::Set))
+          when Type::Nominal then !NOMINALS.include?(receiver.class_name)
+          when Type::Difference, Type::Refined then project_receiver?(receiver.base)
+          when Type::Union, Type::Intersection then receiver.members.any? { |member| project_receiver?(member) }
+          when Type::Dynamic then project_receiver?(receiver.static_facet)
+          else true
+          end
+        end
+      end
+    end
+  end
+end