rigortype 0.4.6 → 0.4.8

data/lib/rigor/inference/loop_value_record.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require_relative "../typing_state"
+
 module Rigor
   module Inference
     # The value the statement evaluator last gave a loop node, and the scope it evaluated the loop from, so
@@ -13,40 +15,90 @@ module Rigor
     # evaluation would. It is not compared with `Scope#==`, which ignores several fields (`match_frame`,
     # `declared_refinements`, `struct_fold_safe_locals`, the opaque-block flags, `lexical_nesting`, the origins tables,
     # `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 whose keys are held weakly, so a record goes when its parse tree
-    # does.
+    # 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 ({TypingState.release_run_scoped}),
+    # emptied when the run that filled it ends.
     module LoopValueRecord
-      KEY = :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
 
-      COUNT_KEY = :rigor_loop_value_count
-      private_constant :COUNT_KEY
+      # 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
+
+      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,22 @@ 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
+        # zero-argument `super` ({RemoverHolderScan}).
+        attr_reader :parameters
+
         # The nodes that bind a local in a body: the writes, and a block's, lambda's, `rescue`'s or pattern's own
         # parameters and targets.
         LOCAL_BINDINGS = Set[
@@ -37,6 +54,8 @@ module Rigor
           @scans = nil
           @last_line_closure = nil
           @last_line_fallback = nil
+          @body_locals = nil
+          @parameter_names = nil
         end
 
         def matching_closure?(scope = nil)
@@ -88,6 +107,17 @@ module Rigor
           @forwarded_block == name
         end
 
+        # Issue #2354 — whether `name` is a local of the frame's own body: the body binds it (a write, or a block's,
+        # lambda's, `rescue`'s or pattern's own parameter or target) and no parameter of the method names it. A
+        # method parameter is the caller's object wherever the body also writes the name (`h = h.dup if f`, a
+        # later `h = {}`), so it never counts. Kept per name for the rest of the body.
+        def body_local?(name)
+          bound = (@body_locals ||= {})
+          return bound[name] if bound.key?(name)
+
+          bound[name] = !parameter_names.include?(name) && binds_local?(@body, name)
+        end
+
         # Issue #1157 — whether a call's `&expr` block argument hands on the block THIS method was called with: the
         # anonymous `&` of a method that declares an anonymous `&` parameter, or {#forwarded_block?} for `&name`.
         # Anything else (`&:sym`, a proc made here, a rebound name) is a block of this frame's own making.
@@ -144,6 +174,33 @@ module Rigor
           !block.nil? && block.name.nil?
         end
 
+        # The names the method's own parameters bind: positional (destructured ones included), optional, rest,
+        # keyword, keyword-rest and block. Empty for a class, module or file body.
+        def parameter_names
+          @parameter_names ||= begin
+            parameters = @parameters
+            names = Set.new
+            if parameters.is_a?(Prism::ParametersNode)
+              [*parameters.requireds, *parameters.optionals, parameters.rest, *parameters.posts,
+               *parameters.keywords, parameters.keyword_rest, parameters.block].each do |parameter|
+                collect_parameter_names(parameter, names)
+              end
+            end
+            names.freeze
+          end
+        end
+
+        def collect_parameter_names(node, names)
+          case node
+          when Prism::MultiTargetNode
+            [*node.lefts, node.rest, *node.rights].each { |target| collect_parameter_names(target, names) }
+          when Prism::SplatNode then collect_parameter_names(node.expression, names)
+          else
+            name = node.respond_to?(:name) ? node.name : nil
+            names << name if name
+          end
+        end
+
         # The method's own `&block` parameter's name, or nil.
         def block_parameter_name
           parameters = @parameters

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

@@ -0,0 +1,101 @@
+# frozen_string_literal: true
+
+require "prism"
+
+module Rigor
+  module Inference
+    module MatchRebinding
+      # 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 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}), 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
+        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 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
+
+        # 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 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 :string_entry, :grep_entry, :project_method?, :refined?, :pattern_argument,
+                             :own_block_call?
+      end
+    end
+  end
+end

data/lib/rigor/inference/match_rebinding.rb

@@ -7,11 +7,14 @@ 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"
 require_relative "match_rebinding/calls"
 require_relative "match_rebinding/self_calls"
+require_relative "match_rebinding/yielding_match"
 require_relative "last_line"
 
 module Rigor
@@ -363,21 +366,41 @@ 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, #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)
         return FreshFrameBlocks.entry(scope, call_node) if FreshFrameBlocks.fresh_entry?(call_node, scope)
 
         scope = FreshFrameBlocks.closure_entry(scope, block_node, call_node)
         scope = LastLine.block_entry(scope, block_node, call_node)
+        YieldingMatch.entry(frame_entry(scope, block_node, call_node), block_node, call_node, operand_scope)
+      end
+
+      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)
+
+        FreshFrameBlocks.deferred_constructor?(block_node, call_node, scope) ? scope.untyped_match_globals : scope
+      end
 
-        scope.forget_match_globals
+      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)
@@ -386,7 +409,7 @@ module Rigor
 
         body.is_a?(Prism::Node) && scan(body, scope, base: true)
       end
-      private_class_method :entry_may_match?
+      private_class_method :frame_entry, :entry_forgets?, :entry_may_match?
     end
   end
 end

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

@@ -7,7 +7,7 @@ module Rigor
         # Canonical RBS-core aliases shipped by `core/builtin.rbs` whose body is `<Nominal> | _DuckType`.
         # Matching an overload against an Integer literal should pick the `(int) -> Array[Elem]` body over
         # the `(string) -> String` body because Integer satisfies `int`'s strict arm and not `string`'s.
-        # The translator collapses both aliases to `Dynamic[Top]` (interfaces are not structurally matched
+        # The translator reads each alias's interface arm as `Dynamic[Top]` (interfaces are not structurally matched
         # yet), so a dedicated pass 1.5 between strict and gradual consults this map to pick the alias
         # whose strict arm matches.
         #

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

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+require_relative "../../type"
+
+module Rigor
+  module Inference
+    module MethodDispatcher
+      # The positional argument lists a call with a precise union argument stands for (#2379): one per combination
+      # of the union arguments' members, since the runtime selects an overload per value. `RbsDispatch` selects an
+      # overload for each list and joins their returns.
+      module ArgumentDistribution
+        # The most lists {.lists} spells out when more than one argument is a union. One union argument is linear in
+        # its members and is not capped.
+        LIMIT = 8
+        private_constant :LIMIT
+
+        # {.lists}' answer past {LIMIT}: the call's overloads cannot be read per value, and it answers `Dynamic[top]`.
+        OVER_LIMIT = :over_limit
+
+        module_function
+
+        # The lists, nil when no argument is a union, or {OVER_LIMIT}.
+        def lists(arg_types)
+          unions = arg_types.count { |arg| arg.is_a?(Type::Union) }
+          return nil if unions.zero?
+
+          if unions > 1
+            count = arg_types.reduce(1) { |product, arg| arg.is_a?(Type::Union) ? product * arg.members.size : product }
+            return OVER_LIMIT if count > LIMIT
+          end
+
+          arg_types.reduce([[]]) do |partials, arg|
+            members = arg.is_a?(Type::Union) ? arg.members : [arg]
+            partials.flat_map { |partial| members.map { |member| partial + [member] } }
+          end
+        end
+      end
+    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
@@ -317,7 +331,7 @@ module Rigor
         end
 
         # Returns the receiver's known finite element count, or nil when the carrier does not pin a size.
-        # Tuple and HashShape are pinned by construction; `Constant<…>` exposes the literal's `.size`. Other
+        # Tuple and HashShape are pinned by construction, and a `Constant` Range by its bounds. Other
         # shapes (Array[T], Range[T], Nominal) decline so the RBS tier widens.
         def finite_size(receiver)
           case receiver

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/constant_folding.rb

@@ -192,8 +192,8 @@ module Rigor
 
         # #2115 — the numeric twin of `STRING_FOLD_BYTE_LIMIT`. A folded Integer (and each Integer part of a
         # folded Rational / Complex) is at most this many bits, the largest bit length whose decimal
-        # rendering still fits in `STRING_FOLD_BYTE_LIMIT` digits: `2 ** 13_605` folds, `2 ** 13_606`
-        # (bit length 13_607) does not. Computing `2 ** 100_000_000` takes Ruby milliseconds, but
+        # rendering still fits in `STRING_FOLD_BYTE_LIMIT` digits: `2 ** 13_605` folds,
+        # `2 ** 13_606` (bit length 13_607) does not. Computing `2 ** 100_000_000` takes Ruby milliseconds, but
         # rendering it in decimal — which describing, sorting and printing the `Constant` does — takes
         # minutes. `**` / `pow` / `<<` / `>>` also check their operands before invoking, so the big value
         # is never computed.
@@ -380,7 +380,7 @@ module Rigor
         # Normalises an input type into one of:
         # - `Array<Object>` for a `Constant` (1-element) or `Union[Constant…]` (n-element) — concrete values
         #   to enumerate.
-        # - `Type::IntegerRange` — bounded interval.
+        # - `Type::IntegerRange` / `Type::FloatRange` — bounded interval.
         # - `nil` — the input shape is not foldable.
         def numeric_set_of(type)
           case type