rigortype 0.4.2 → 0.4.4

data/lib/rigor/inference/definer_resolution.rb

@@ -39,6 +39,9 @@ module Rigor
       Hit = Data.define(:answer, :owner, :index, :side)
 
       QUESTIONS = %i[definer visibility arity override own_side].freeze
+      # The questions whose answer reads a recorded visibility: only they treat a contested visibility slot as a
+      # possible definer ({#possible?}).
+      VISIBILITY_QUESTIONS = %i[visibility override].freeze
       NONE = :rigor_definer_resolution_none
       STRAY = :rigor_definer_resolution_stray
       private_constant :NONE, :STRAY
@@ -58,12 +61,13 @@ module Rigor
         flavor = question == :arity ? :arity : :methods
         chain = Scope::ResolutionChain.for(scope, class_name.to_s, side, flavor)
 
-        hits = candidates(scope, chain, method_name, from, answer_in)
+        reads_visibility = VISIBILITY_QUESTIONS.include?(question)
+        hits = candidates(scope, chain, method_name, from, answer_in, reads_visibility)
         return UNKNOWN if hits.nil?
 
         verdict = chain.settle(scope, outcomes(hits), owner: hits.first&.owner, unknown_for: method_name) do |retro|
           retro_from = retro_position(chain, retro, from)
-          outcomes(retro_from && candidates(scope, retro, method_name, retro_from, answer_in))
+          outcomes(retro_from && candidates(scope, retro, method_name, retro_from, answer_in, reads_visibility))
         end
         return UNKNOWN unless verdict == :chain
         return UNKNOWN if side == :singleton && SingletonHookDecline.decline?(scope, chain, method_name, from, hits)
@@ -101,7 +105,7 @@ module Rigor
       # follows (the absent candidate). A cut chain, and a chain on which an external ancestor ahead of the
       # candidate (or, with no candidate, the implicit `Object`) may define the name, is a decline, answered by
       # nil instead of a set.
-      def candidates(scope, chain, method_name, from, answer_in)
+      def candidates(scope, chain, method_name, from, answer_in, reads_visibility)
         hits = []
         position = from
         loop do
@@ -113,7 +117,9 @@ module Rigor
           return nil if hit.nil? && chain.truncated?
 
           hits << hit
-          return decided(scope, chain, method_name, from, hits) if hit.nil? || !possible?(scope, hit, method_name)
+          if hit.nil? || !possible?(scope, hit, method_name, reads_visibility)
+            return decided(scope, chain, method_name, from, hits)
+          end
 
           position = hit.index + 1
         end
@@ -188,15 +194,18 @@ module Rigor
       end
 
       # A definer that rests on a fact the walk could not prove executes: the member's `possible` sibling, or a
-      # contested slot of one of the single-valued members.
-      def possible?(scope, hit, method_name)
+      # contested slot of one of the single-valued members. A contested visibility slot counts only for a question
+      # that reads the visibility (`reads_visibility`): a slot is contested there for a visibility call the walk
+      # cannot place (an uncertain toggle, `private(*names)`, `private def self.x`), which leaves the definer and its
+      # `def` certain; a possible `def` or `attr_*` call contests its def-node slot or its name's `possible` side too.
+      def possible?(scope, hit, method_name, reads_visibility)
         discovery = scope.discovery
         owner = hit.owner
         kind = hit.side == :singleton ? :singleton : :instance
         nodes = kind == :singleton ? :discovered_singleton_def_nodes : :discovered_def_nodes
         discovery.possible_method?(owner, method_name, kind) ||
           discovery.contested?(nodes, [owner, method_name.to_sym]) ||
-          discovery.contested?(:discovered_method_visibilities, [owner, method_name.to_sym]) ||
+          (reads_visibility && discovery.contested?(:discovered_method_visibilities, [owner, method_name.to_sym])) ||
           discovery.contested?(:discovered_parameter_envelopes, [owner, [kind, method_name.to_sym]])
       end
 

data/lib/rigor/inference/expression_typer.rb

@@ -321,6 +321,37 @@ module Rigor
           try_project_singleton_inference(receiver, node, arg_types, method_name: :[])
       end
 
+      # Issue #1889 — the type a block-form `inject` / `reduce` accumulator parameter holds across the block's runs,
+      # or nil when the call is not one {#try_block_inject_fold} folds. The RBS tier binds the parameter to the seed
+      # alone, so the statement pass and the ADR-56 write-back typed every run's accumulator as `0` for `inject(0)`,
+      # and a capture assigned from it (`m = a`) was written back as `0`.
+      #
+      # The fold records the answer as it types the call ({#record_inject_accumulator}): the constant arm the
+      # accumulator values the block receives (`0 | 1` for `[1, 2].inject(0) { |a, e| a + e }`), the nominal
+      # arm its seed joined with the converged accumulator. The statement pass types the call from the same scope
+      # just before it enters the block, so the recorded answer is read back rather than computed again — each
+      # computation types the body, and a nested `inject` multiplied that by its depth.
+      def inject_accumulator_type(call_node, receiver, arg_types)
+        block = call_node.block
+        return nil unless INJECT_METHODS.include?(call_node.name) && block.is_a?(Prism::BlockNode)
+
+        recorded = self.class.recorded_inject_accumulator(block, scope)
+        return recorded if recorded
+
+        try_block_inject_fold(call_node, receiver, arg_types)
+        self.class.recorded_inject_accumulator(block, scope)
+      end
+
+      INJECT_ACCUMULATOR_KEY = :__rigor_inject_accumulator__
+      private_constant :INJECT_ACCUMULATOR_KEY
+
+      # The accumulator type {#record_inject_accumulator} stored for `block` when the call was typed from `scope`
+      # itself (by identity), else nil.
+      def self.recorded_inject_accumulator(block, scope)
+        slot = Thread.current[INJECT_ACCUMULATOR_KEY]&.[](block)
+        slot && slot[0].equal?(scope) ? slot[1] : nil
+      end
+
       # ADR-89 WD2 — the current run's return memo bucket as `{ def_node => [MemoEntry, …] }` (only entries
       # that carry a call descriptor, i.e. every stored entry). Read by the incremental session right after a
       # recording run to harvest each analyzed callee's observed call keys → return descriptors. Returns an
@@ -1047,12 +1078,15 @@ module Rigor
       #
       # The `case ... in` pattern-matching form (`CaseMatchNode`) and the predicate-less form (`case; when
       # c1; ...`) bypass the `===` analysis: pattern matching has richer semantics, and a predicate-less
-      # `case` reduces to a `if c1; ...; elsif c2` chain that statement-level narrowing already handles.
+      # `case` reduces to a `if c1; ...; elsif c2` chain. Issue #1495 — like {#type_of_conditional}, that
+      # chain delegates to the statement evaluator, which narrows each arm by its conditions' edges, so
+      # `[case; when x.nil? then "n"; else x end]` reads `"n" | String` as the statement form does.
       # Issue #1429 — each arm is typed under the subject's clause narrowing (`Narrowing.case_when_scopes`), the
       # scope the statement evaluator runs the arm in: `when Symbol then n` on `n: Integer | Symbol` answers
       # `Symbol`, and the `else` arm reads the subject every earlier clause has ruled out.
       def type_of_case(node)
-        return type_of_case_simple_union(node) if node.is_a?(Prism::CaseMatchNode) || node.predicate.nil?
+        return type_of_case_simple_union(node) if node.is_a?(Prism::CaseMatchNode)
+        return scope.evaluate(node, tracer: tracer).first if node.predicate.nil?
 
         subject_type = type_of(node.predicate)
         candidates = []
@@ -1952,19 +1986,20 @@ module Rigor
       # replaces (a refined `String#upcase` must not fold, a refined `map` must not fold per element, a top-level
       # `def` must not bind ahead of a refinement of `Object`, a plugin models the class's own method). An unreadable
       # body, or a list that may hold any refinement, answers `Dynamic[top]`, never the replaced method's signature.
-      # A union receiver is decided per member; a `Dynamic` receiver, a class object and a call no refinement wins
-      # fall through. A call site no refinement is in effect at answers nil at once and records nothing: its answer
-      # cannot change without an edit to its own file.
+      # A union receiver is decided per member; a `Dynamic` receiver and a call no refinement wins fall through. A
+      # class object walks its own lookup (issue #1752): under `refine(Object) { def oo = :o }` a refinement that wins
+      # `Integer.oo` answers `Dynamic[top]` ({#refined_class_object_result}). A call site no refinement is in effect
+      # at answers nil at once and records nothing: its answer cannot change without an edit to its own file.
       #
       # ADR-121 WD7 (A2) — inside the span of an activation that puts an opaque module in effect
-      # ({InEffectRefinements.opaque_module?}), any method of any instance may be replaced, so every instance-receiver
-      # call answers `Dynamic[top]`; a class object falls through, as it does below.
+      # ({InEffectRefinements.opaque_module?}), any method of any object may be replaced, so every call on an instance
+      # or a class object answers `Dynamic[top]`.
       def try_refined_dispatch(node, receiver, arg_types, block_type)
         list = scope.in_effect_refinements(node)
         return nil if list.empty?
 
         InEffectRefinements.record_refinement_names(node.name)
-        return dynamic_top if refined_instance_receiver?(receiver) && opaque_refinement_span?(node, list)
+        return dynamic_top if refined_receiver?(receiver) && opaque_refinement_span?(node, list)
         return nil if scope.discovered_refinements.empty?
 
         refined_indirect_result(node, receiver, list) ||
@@ -2010,6 +2045,9 @@ module Rigor
       def refined_name_for?(receiver, name, list)
         members = receiver.is_a?(Type::Union) ? receiver.members : [receiver]
         members.any? do |member|
+          next !RefinedDispatch.winner(scope, member.class_name, name, list, kind: :singleton).nil? if
+            member.is_a?(Type::Singleton)
+
           class_name = refined_receiver_class_name(member)
           !class_name.nil? && !RefinedDispatch.winner(scope, class_name, name, list).nil?
         end
@@ -2033,11 +2071,11 @@ module Rigor
         InEffectRefinements.opaque_in?(scope, lexical)
       end
 
-      # Does `receiver` (or a member of a union) have a class the refined arm answers for: an instance, not a class
-      # object or `Dynamic`?
-      def refined_instance_receiver?(receiver)
+      # Does `receiver` (or a member of a union) have a lookup the refined arm answers for: an instance of a class,
+      # or a class object (issue #1752), not `Dynamic`?
+      def refined_receiver?(receiver)
         members = receiver.is_a?(Type::Union) ? receiver.members : [receiver]
-        members.any? { |member| !refined_receiver_class_name(member).nil? }
+        members.any? { |member| member.is_a?(Type::Singleton) || !refined_receiver_class_name(member).nil? }
       end
 
       def refined_receiver_result(node, receiver, list, arg_types, block_type)
@@ -2053,6 +2091,9 @@ module Rigor
       end
 
       def refined_member_result(node, receiver, list, arg_types, block_type)
+        return refined_class_object_result(node, receiver, list, arg_types, block_type) if
+          receiver.is_a?(Type::Singleton)
+
         class_name = refined_receiver_class_name(receiver)
         return nil if class_name.nil?
 
@@ -2064,6 +2105,16 @@ module Rigor
           dynamic_top
       end
 
+      # Issue #1752 — a call on a class object, walked through its singleton levels. A refinement that wins answers
+      # `Dynamic[top]`, never its refine body's type: a hook on any ancestor (an RBS-declared `include Singleton`, a
+      # gem concern, `define_singleton_method(:included)`, a `Module#included` patch) can install the class object's
+      # own method where no table sees it, and the body's type then fires downstream on correct code. A walk that finds
+      # no winner keeps the class object's own answer (`Integer.sqrt(16)` stays `Integer`).
+      def refined_class_object_result(node, receiver, list, _arg_types, _block_type)
+        winner = RefinedDispatch.winner(scope, receiver.class_name, node.name, list, kind: :singleton)
+        dynamic_top unless winner.nil?
+      end
+
       # The winning refine body's inferred return, re-typed with the receiver's class as `self` and the call's
       # argument types bound as an undeclared method's are; nil when the body is not readable here.
       #
@@ -2082,8 +2133,9 @@ module Rigor
         nil
       end
 
-      # The class an instance-side receiver is an instance of, or nil for one a refinement does not answer here: a
-      # class object (refinements of singleton classes are not recorded), `Dynamic`, `top`, or a shape with no class.
+      # The class an instance-side receiver is an instance of, or nil for one this instance walk does not answer: a
+      # class object (it walks its own lookup, {#refined_class_object_result}), `Dynamic`, `top`, or a shape with no
+      # class.
       def refined_receiver_class_name(receiver)
         case receiver
         when Type::Nominal, Type::StructInstance, Type::DataInstance then receiver.class_name
@@ -2453,7 +2505,7 @@ module Rigor
         return every_definer_raises_type(raising, receiver, call_node, arg_types, block_type) if def_node.nil?
 
         result = infer_user_method_return(def_node, receiver, arg_types,
-                                          self_fold_safe: fold_safe_call_receiver?(call_node, receiver),
+                                          self_fold_safe: fold_safe_call_receiver?(call_node),
                                           yield_type: block_type)
         return result if result.nil?
 
@@ -2488,11 +2540,11 @@ module Rigor
       # This is only a property of the receiver expression; whether the grant is actually issued also needs
       # a `StructInstance` carrier and a body that survives the self-use scan, both decided in
       # {#build_user_method_body_scope}.
-      def fold_safe_call_receiver?(call_node, receiver)
+      def fold_safe_call_receiver?(call_node)
         return false if call_node.nil?
 
         case call_node.receiver
-        when Prism::CallNode then materialization_call?(call_node.receiver, receiver)
+        when Prism::CallNode then materialization_call?(call_node.receiver)
         when Prism::LocalVariableReadNode then scope.struct_fold_safe?(call_node.receiver.name)
         when nil, Prism::SelfNode then scope.struct_fold_safe?(:self)
         else false
@@ -2502,10 +2554,10 @@ module Rigor
       # Issue #595 — the materialisation test lives ONCE, in
       # [`struct_materialization.rb`](method_dispatcher/struct_materialization.rb), because the direct
       # member-read gate ({MethodDispatcher::StructFolding}`#fresh_receiver?`) needs the identical answer;
-      # see {MethodDispatcher::StructMaterialization.materialization_call?}. It resolves its own `.with`
-      # guard through `Scope`, so neither consumer supplies a lookup and neither can answer differently.
-      def materialization_call?(node, receiver)
-        MethodDispatcher::StructMaterialization.materialization_call?(node, receiver, scope)
+      # see {MethodDispatcher::StructMaterialization.materialization_call?}. A `.with` call is never one
+      # (`Struct` has no `#with`, #1335), so the test needs no lookup from either consumer.
+      def materialization_call?(node)
+        MethodDispatcher::StructMaterialization.materialization_call?(node, scope)
       end
 
       # Module-singleton call resolution (ADR-57 follow-up) — resolves `Foo.<name>` on a `Singleton[Foo]`
@@ -2674,7 +2726,7 @@ module Rigor
       def every_definer_raises_type(defs, receiver, call_node, arg_types, block_type)
         return nil if defs.nil?
 
-        self_fold_safe = fold_safe_call_receiver?(call_node, receiver)
+        self_fold_safe = fold_safe_call_receiver?(call_node)
         defs.each do |def_node|
           result = infer_user_method_return(def_node, receiver, arg_types,
                                             self_fold_safe: self_fold_safe, yield_type: block_type)
@@ -3865,6 +3917,12 @@ module Rigor
       # default — or `Dynamic` when the shape is open or absent; `**kwrest`, `&block`, and destructured
       # positionals bind `Dynamic`. Binding `Dynamic` is monotone-safe (wider in → wider out), so the only
       # declines left are the shapes where positional CORRESPONDENCE itself is unknowable.
+      #
+      # The scope carries no `source_path:`: the body is re-typed for call sites in any file, so a rule that
+      # asks "did this file write it?" by comparing `scope.source_path` with census paths answers wrongly
+      # through it. Record a per-file write kind in the census instead, as {ScopeIndexer::CONSTANT_MEMO} does
+      # (#1276). Setting `source_path` here was rejected: plugins read it, and the return memo would become
+      # caller-dependent.
       def build_user_method_body_scope(def_node, receiver, arg_types, self_fold_safe: false)
         params = def_node.parameters
         locals = bind_params_from_call_types(params, arg_types)
@@ -3875,7 +3933,7 @@ module Rigor
         # allocated a fresh frozen Scope per field, run per user-method-call inference (ADR-44). The
         # discovery index is inherited whole by reference (ADR-53 Track A); the hand-copied per-field list
         # this replaces had silently dropped `data_member_layouts` and `discovered_method_visibilities`.
-        Scope.new(
+        body_scope = Scope.new(
           environment: scope.environment,
           locals: locals.freeze,
           self_type: receiver,
@@ -3893,6 +3951,7 @@ module Rigor
           # Issue #1358 — the callee runs in a frame of its own ({Scope#with_match_frame}).
           match_frame: MatchRebinding::Frame.new(def_node.body, def_node.parameters)
         )
+        body_scope.with_repeated_or_writes(RepeatedOrWrites.straight_line_sites(def_node.body, body_scope))
       end
 
       # Issue #681 / #707 — the ONE place in `lib/` that answers "what `Module.nesting` was recorded for this
@@ -5417,13 +5476,39 @@ module Rigor
         acc, rest = inject_constant_start(members, seed, has_seed)
         return nil if acc.nil?
 
-        rest.each do |element_value|
-          acc = inject_constant_step(block, acc, element_value)
+        captured = inject_captured_bindings(block, rest.map { |value| Type::Combinator.constant_of(value) })
+        received = [acc]
+        rest.each_with_index do |element_value, position|
+          acc = inject_constant_step(block, acc, element_value, captured, position)
           return nil if acc.nil?
+
+          received << acc
         end
+        received.pop if received.size > 1
+        record_inject_accumulator(block, Type::Combinator.union(*received))
         acc
       end
 
+      # Records `type` as the accumulator `block` receives when typed from this typer's scope
+      # ({.recorded_inject_accumulator}). The keys are weak, so a finished file's nodes do not stay reachable, and
+      # the values strong, so a record outlives a collection while its node does. Prism nodes compare by identity.
+      def record_inject_accumulator(block, type)
+        (Thread.current[INJECT_ACCUMULATOR_KEY] ||= ObjectSpace::WeakKeyMap.new)[block] = [scope, type].freeze
+      end
+
+      # Issue #1332 — the #587 (b) captured-block binding ({#captured_block_bindings}) both inject arms lay under
+      # every step, as the Tuple / Range per-element folds and the per-pair `HashShape` fold do. Without it each
+      # step reads a captured variable at its entry binding, so a body that rebinds or mutates one (`n += 1`,
+      # `log << e`, `cache[:k] ||= e`) pinned the result: `n = 0; [1, 2].inject(0) { |a, e| r = a + n; n += 1;
+      # r }` folded to `0` where Ruby answers `1`. The fixpoint binds the accumulator parameter to `Dynamic[top]`
+      # rather than to a type the inject fixpoint has not converged yet: a captured name that reads the
+      # accumulator widens rather than pins. `element_types` is the constant arm's steps, one position per block
+      # run, which {RepeatedOrWrites} reads; nil for the nominal arm, which marks every repeated site.
+      def inject_captured_bindings(block, element_types, element: nil)
+        element ||= Type::Combinator.union(*element_types)
+        captured_block_bindings(block, [Type::Combinator.untyped, element], element_types: element_types)
+      end
+
       # Extracts the receiver's foldable constant values, size-capped before enumeration, or nil to decline.
       def inject_constant_members(receiver)
         case receiver
@@ -5475,9 +5560,9 @@ module Rigor
       # Evaluates the block body once with the running constant accumulator + the next constant element
       # bound to the block params, returning the result when it is a foldable `Constant` within the
       # magnitude cap, else nil to decline the whole fold.
-      def inject_constant_step(block, acc, element_value)
+      def inject_constant_step(block, acc, element_value, captured, position)
         element = Type::Combinator.constant_of(element_value)
-        result = type_block_body_with_param(block, [acc, element])
+        result = type_block_body_with_param(block, [acc, element], captured: captured, position: position)
         return nil unless result.is_a?(Type::Constant)
         return nil unless inject_foldable?(result.value)
         return nil if inject_magnitude_too_large?(result.value)
@@ -5507,17 +5592,20 @@ module Rigor
         seed_acc = has_seed ? seed : element
         return nil if seed_acc.nil?
 
+        captured = inject_captured_bindings(block, nil, element: element)
         converged = BodyFixpoint.converge(
           names: [:__inject_acc__],
           seed_bindings: { __inject_acc__: seed_acc },
           widen: method(:widen_value_pinned),
           evaluate_body: lambda do |bindings|
             acc = bindings[:__inject_acc__]
-            result = type_block_body_with_param(block, [acc, element])
+            result = type_block_body_with_param(block, [acc, element], captured: captured)
             result.nil? ? {} : { __inject_acc__: result }
           end
         )
-        converged[:__inject_acc__] || seed_acc
+        result = converged[:__inject_acc__] || seed_acc
+        record_inject_accumulator(block, Type::Combinator.union(seed_acc, result))
+        result
       end
 
       def assemble_per_element_result(method_name, per_position, element_types)

data/lib/rigor/inference/guard_rebinding.rb

@@ -223,6 +223,12 @@ module Rigor
         end || Type::Combinator.untyped
       end
 
+      # Issue #1596 — true when `name` runs code chosen by name or by a String, or a block or String it is given
+      # ({CODE_RUNNING_NAMES}, {BLOCK_OR_CODE_NAMES}), whatever its receiver.
+      def code_running_name?(name)
+        CODE_RUNNING_NAMES.include?(name) || BLOCK_OR_CODE_NAMES.include?(name)
+      end
+
       # True when `method_name` on a value of `type` may run foreign code ({.foreign_target?}).
       def type_method_foreign?(type, method_name, scope)
         targets = ProjectMethodOwnership.targets(type)
@@ -326,8 +332,7 @@ module Rigor
       private_class_method :scan, :guarded_ivar_write?, :scan_call, :receiver_targets, :foreign_target?,
                            :universal_delegate_foreign?, :method_owner, :deferred_block_call?,
                            :compound_write_foreign?,
-                           :compound_receiver_type, :compound_accessors, :compound_read_type, :variable_type,
-                           :type_method_foreign?
+                           :compound_receiver_type, :compound_accessors, :compound_read_type, :variable_type
     end
 
     module GuardRebinding

data/lib/rigor/inference/in_effect_refinements/scope_reads.rb

@@ -148,35 +148,26 @@ module Rigor
         # define any name), and a row whose class the walk could not name ({.class_wildcard_key?}), which reaches
         # every receiver.
         #
+        # Issue #1752 — `kind: :singleton` asks for the class object `class_name`: a refinement of any class or module
+        # on its lookup reaches it (`Class`, `Module`, `Object`, `Kernel`, `BasicObject`, a module it or a superclass
+        # extends; {RefinedDispatch::ClassObject.reach}). Where that lookup cannot be read, every row counts whose class
+        # a class object may reach ({RefinedDispatch::ClassObject.reachable?}).
+        #
         # ADR-46 — the answer is a function of every refinement of this name in the project, so the consumer
         # depends on the name whichever way it answers; a refine body edited in another file must re-check it
         # (`IncrementalSession#refinement_affected`). It also depends on the wildcard rows (`refinement:*`).
-        def refining_modules(scope, class_name, method_name)
+        def refining_modules(scope, class_name, method_name, kind = :instance)
           record_refinement_names(method_name)
           refinements = scope.discovered_refinements
           return nil if refinements.empty?
 
+          reaches = receiver_reach(scope, class_name, kind)
           modules = nil
           refinements.each do |refined, methods|
             names = methods[method_name]
             unread = methods[WILDCARD]
             next if names.nil? && unread.nil?
-            next unless refined_receiver_class?(scope, class_name, refined) || class_wildcard_key?(scope, refined)
-
-            modules = (modules || []).concat(names || EMPTY, unread || EMPTY)
-          end
-          modules
-        end
-
-        # ADR-121 WD7 — {.refining_modules} for a receiver the class rows do not reach (a class object): only the rows
-        # whose class the walk could not name ({.class_wildcard_key?}), for the name or as a names-wildcard.
-        def class_unknown_refining_modules(scope, method_name)
-          record_refinement_names(method_name)
-          modules = nil
-          scope.discovered_refinements.each do |refined, methods|
-            names = methods[method_name]
-            unread = methods[WILDCARD]
-            next if (names.nil? && unread.nil?) || !class_wildcard_key?(scope, refined)
+            next unless reaches.call(refined) || class_wildcard_key?(scope, refined)
 
             modules = (modules || []).concat(names || EMPTY, unread || EMPTY)
           end
@@ -258,6 +249,19 @@ module Rigor
           end
         end
 
+        # Does a row keyed on a refined class reach the receiver? A class object's lookup is read once, on the first
+        # row that asks.
+        def receiver_reach(scope, class_name, kind)
+          return ->(refined) { refined_receiver_class?(scope, class_name, refined) } unless kind == :singleton
+
+          reach = nil
+          lambda do |refined|
+            reach ||= [RefinedDispatch::ClassObject.reach(scope, class_name)]
+            names = reach.first
+            names.nil? ? RefinedDispatch::ClassObject.reachable?(scope, refined) : names.include?(refined)
+          end
+        end
+
         def refined_receiver_class?(scope, class_name, refined)
           return true if class_name == refined
 

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

@@ -45,7 +45,7 @@ module Rigor
       #   `X.send(:define_method, :m, blk)`), whose body may be a block the file wrote anywhere, an eval of a
       #   String, whose code may do any of these, and a `const_set`, which may make a class a `class` body reopens;
       # - one name: a `def` of it anywhere (`def self.gets` at the top level defines it on `main`, which
-      #   {BlockCallTiming.project_defines_anywhere?} does not record), and a Symbol or String literal naming it,
+      #   {BlockCallTiming.project_defines_anywhere?} does not count), and a Symbol or String literal naming it,
       #   which a macro may define it through (`def_delegators :@io, :gets`, `attr_reader :gets`,
       #   `undef_method :gets`), other than `&:gets` and the first argument of a call that only names a method
       #   (`respond_to?(:gets)`, `send(:gets)`).

data/lib/rigor/inference/match_rebinding.rb

@@ -16,7 +16,7 @@ require_relative "last_line"
 
 module Rigor
   module Inference
-    # Which code may rebind the regex match globals (`$~` and the `$&` / `` $` `` / `$'` / `$+` / `$1`..`$9` family
+    # Which code may rebind the regex match globals (`$~` and the `$&` / `` $` `` / `$'` / `$+` / `$1`..`$N` family
     # derived from it) that a scope's narrowing speaks for. Ruby keeps them in the method frame's special-variable
     # slot, and every block and closure made in the method reaches that same slot, so a match a block body runs
     # rebinds the enclosing method's `$~` (issue #1358). A `def`, class or module body runs in a frame of its own,

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

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Rigor
+  module Inference
+    module MethodDispatcher
+      # What a call's AST says about its argument types that the types alone cannot: shared by the RBS tier's
+      # overload selection and the constructor folds, so the two readings of one call cannot drift.
+      module ArgumentNodes
+        module_function
+
+        # Issue #1727 — whether `args`' last entry is the call's keyword hash (`f(a, k: 1)`), which the overload
+        # selector then matches against an overload's keywords. Only the AST tells a keyword hash from a
+        # braced positional one (`f(a, { k: 1 })`), so a dispatch without the call node, or one whose
+        # arguments are not the node's own (a forwarded `...`, a `send` re-dispatch), answers false and keeps
+        # reading every argument positionally.
+        def keyword_hash_last?(call_node, args)
+          return false if args.empty? || !call_node.respond_to?(:arguments)
+
+          arguments = call_node.arguments&.arguments
+          !arguments.nil? && arguments.size == args.size && arguments.last.is_a?(Prism::KeywordHashNode)
+        end
+      end
+    end
+  end
+end

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

@@ -3,6 +3,7 @@
 require_relative "../../type"
 require_relative "constant_folding"
 require_relative "random_folding"
+require_relative "unit_denominator_rational"
 
 module Rigor
   module Inference
@@ -346,8 +347,8 @@ module Rigor
         # is a numeric Constant. The actual Ruby constructor runs at fold time (host-side), so the result
         # respects Ruby's normalisation (`Rational(2, 4)` → `Rational(1, 2)`).
         def try_numeric_constructor(method_name, args)
-          return nil unless [1, 2].include?(args.size)
-          return nil unless args.all? { |arg| numeric_constant?(arg) }
+          foldable = [1, 2].include?(args.size) && args.all? { |arg| numeric_constant?(arg) }
+          return UnitDenominatorRational.answer(method_name, args) unless foldable
 
           values = args.map(&:value)
           result = NUMERIC_CONSTRUCTORS[method_name].call(*values)

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

@@ -35,8 +35,8 @@ module Rigor
       #   beginless),
       # - the slice is empty.
       #
-      # K is read from `$1`..`$9` only: `Scope#forget_match_globals` does not clear `$10` and above (#1384), so a
-      # binding there may belong to an earlier match.
+      # K is read from `$1`..`$9` only: the fold declines an index above nine rather than widen its reach.
+      # `Scope#forget_match_globals` clears `$10` and above too (#1384), so a binding there is never stale.
       module MatchDataFolding
         MAX_GROUP_GLOBAL = 9
         private_constant :MAX_GROUP_GLOBAL

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

@@ -12,9 +12,9 @@ module Rigor
       # The member-shape projections shared by {DataFolding} and {StructFolding}. A `DataInstance` and a
       # `StructInstance` expose the same surface — an ordered `members` map, `member_names`, and a
       # `class_name` — so the value projections off that surface (`[]` / `to_h` / `deconstruct` /
-      # `deconstruct_keys` / `members` / `with`) and the reader-redefinition guard are identical between the
-      # two folders. Only `#with`'s carrier constructor differs (`data_instance_of` vs
-      # `struct_instance_of`), so it takes a block that builds the new instance from the merged member map.
+      # `deconstruct_keys` / `members`) and the reader-redefinition guard are identical between the two
+      # folders. `#with` is a projection of `Data` only (`Struct` has no `#with`, #1335); it takes a block that
+      # builds the new instance from the merged member map, so the carrier constructor stays with the caller.
       #
       # Both folders `extend` this module so the projections resolve as their own module functions
       # (matching their `module_function` style).

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

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+require_relative "../../type"
+
+module Rigor
+  module Inference
+    module MethodDispatcher
+      # Issue #1393 — `min` / `max` / `min_by` / `max_by` take an OPTIONAL count, and Ruby reads a `nil` count as
+      # "no count" (except blockless `Range#min` / `Range#max`, which raise; those are left alone):
+      # `[1, 2].min_by(nil) { |s| s }` is `1`, not `[1]`, and `[1, 2].max(nil)` is `2`. The RBS
+      # declares only `() ...` and `(Integer) ...` arms, so a `nil` argument matched none of them and the selector
+      # fell back to the blockless `Enumerator` arm — a confidently wrong type, and a false `call.undefined-method`
+      # on `xs.min_by(limit) { … }.succ` where `limit` may be `nil`.
+      #
+      # This splits the count argument. A `nil` part is dispatched as the no-argument call (so every no-count
+      # answer, including the #1333 non-empty fold, applies); a non-`nil` part is dispatched as written; a union
+      # of both answers the union of the two results. A count that has no `nil` part is left to the caller
+      # untouched. Only the core receivers whose methods these are (`Array`, `Hash`, `Range`, `Set`, and their
+      # shape and constant carriers) are rewritten, so a user class's own `min(limit)` is not reinterpreted.
+      module OptionalCount
+        module_function
+
+        METHODS = Set[:min, :max, :min_by, :max_by].freeze
+        # `Range` defines its own blockless `min` / `max`, which raise `TypeError` for a `nil` count in Ruby 4.0;
+        # only with a block does it fall through to `Enumerable`'s, which read `nil` as no count.
+        COUNTED_BY_ENUMERABLE_ONLY = Set[:min, :max].freeze
+        RECEIVER_CLASSES = Set["Array", "Hash", "Range", "Set"].freeze
+
+        # @return nil when the call is not a nil-count call; otherwise a one-element list holding the non-`nil`
+        #   part of the count (itself nil when the count is only `nil`).
+        def split(receiver, method_name, args, block: true)
+          return nil unless METHODS.include?(method_name) && args.size == 1 && core_receiver?(receiver)
+          return nil if !block && COUNTED_BY_ENUMERABLE_ONLY.include?(method_name) && range_receiver?(receiver)
+
+          arg = args.first
+          members = arg.is_a?(Type::Union) ? arg.members : [arg]
+          return nil unless members.any? { |m| nil_constant?(m) }
+
+          rest = members.reject { |m| nil_constant?(m) }
+          [rest.empty? ? nil : Type::Combinator.union(*rest)]
+        end
+
+        def range_receiver?(receiver)
+          (receiver.is_a?(Type::Constant) && receiver.value.is_a?(Range)) ||
+            (receiver.is_a?(Type::Nominal) && receiver.class_name == "Range")
+        end
+
+        def nil_constant?(type)
+          type.is_a?(Type::Constant) && type.value.nil?
+        end
+
+        def core_receiver?(receiver)
+          case receiver
+          when Type::Tuple, Type::HashShape then true
+          when Type::Constant then receiver.value.is_a?(Range) || receiver.value.is_a?(::Set)
+          when Type::Nominal then RECEIVER_CLASSES.include?(receiver.class_name)
+          else false
+          end
+        end
+      end
+    end
+  end
+end