rigortype 0.4.2 → 0.4.3

data/lib/rigor/environment.rb

@@ -97,7 +97,7 @@ module Rigor
       # for the overlay, instead of aborting the run outright (see {#hkt_registry}).
       @hkt_scan_failure = FailureSlot.new
       @constant_type_cache = ConstantTypeCacheHolder.new
-      # ADR-82 WD9 — `[gem_name, version]` pairs for the locked gems with no resolvable RBS. The
+      # ADR-82 WD9 — `[gem_name, version, variants]` entries for the locked gems with no resolvable RBS. The
       # root-constant ownership index over them is built lazily (first unresolved constant read) so runs
       # whose constants all resolve never pay the entry-file scan.
       @missing_rbs_gems = missing_rbs_gems.freeze
@@ -444,8 +444,8 @@ module Rigor
       end
 
       # The `:missing` classification (locked gems with no RBS through any resolution path), computed once
-      # and consumed twice: as `[gem_name, version]` pairs for the ADR-82 WD9 constant-ownership index, and
-      # as the eligible-gem set for the ADR-72 overlay resolution. Returns `[pairs, overlay_paths]`.
+      # and consumed twice: as `[gem_name, version, variants]` entries for the ADR-82 WD9 constant-ownership
+      # index, and as the eligible-gem set for the ADR-72 overlay resolution. Returns `[entries, overlay_paths]`.
       def missing_gems_and_overlay_paths(locked:, default_libraries:, bundle_sig_paths:,
                                          rbs_collection_paths:, plugin_registry:, signature_paths: [],
                                          bundle_root: nil)
@@ -458,7 +458,7 @@ module Rigor
           missing_gem_names: rows.map(&:gem_name), plugin_registry: plugin_registry,
           signature_paths: signature_paths
         )
-        [rows.map { |row| [row.gem_name, row.version] }, overlays]
+        [index_entries(rows, locked), overlays]
       end
 
       # Issue #530 — a project with no `Gemfile.lock` still has gems on disk, and before this it handed the
@@ -472,7 +472,14 @@ module Rigor
         return [[], []] if installed.empty?
 
         rows = missing_rows(installed, default_libraries, bundle_sig_paths, rbs_collection_paths)
-        [rows.map { |row| [row.gem_name, row.version] }, []]
+        [index_entries(rows, installed), []]
+      end
+
+      # The constant-ownership index's input: each `:missing` row with every `[version, platform]` variant its
+      # gem was locked (or found installed) under, because Bundler installs the variant matching the host —
+      # `commonmarker-2.10.0-arm64-darwin/` under a lockfile whose representative is the `ruby` one (#1844).
+      def index_entries(rows, gems)
+        rows.map { |row| [row.gem_name, row.version, gems[row.gem_name]&.variants] }
       end
 
       def missing_rows(gems, default_libraries, bundle_sig_paths, rbs_collection_paths)

data/lib/rigor/inference/builtins/cruby_definers.rb

@@ -16,6 +16,9 @@ module Rigor
       # (`Integer#quo` and `File#to_path`, whose CRuby owners are `Numeric` and `IO`), and declares a few CRuby no
       # longer defines (`Process::Status#&`). A class no catalogue covers answers false, as does a method its
       # catalogue does not list: the caller reads both as "not proven". The catalogue is one CRuby snapshot.
+      #
+      # Issue #1752 — the singleton side reads the catalogue's `singleton_methods` (each `rb_define_singleton_method`
+      # on the class), the record that `Integer.sqrt` is CRuby's own method of `Integer`'s singleton class.
       module CRubyDefiners
         module_function
 
@@ -25,7 +28,15 @@ module Rigor
           !names.nil? && names.include?(method_name.to_s)
         end
 
-        def build_index
+        # Does the catalogue prove CRuby defines `method_name` on `class_name`'s singleton class itself?
+        def singleton_defines?(class_name, method_name)
+          names = SINGLETON_INDEX[class_name.to_s.delete_prefix("::")]
+          !names.nil? && names.include?(method_name.to_s)
+        end
+
+        # `{class name => Set[method name]}` from each catalogued class's instance methods and aliases, or from its
+        # `singleton_methods` when `side` is `:singleton`.
+        def build_index(side = :instance)
           index = Hash.new { |hash, key| hash[key] = Set.new }
           MethodCatalog.topic_paths.each do |path|
             data = YAML.safe_load_file(path, permitted_classes: [Symbol])
@@ -35,9 +46,7 @@ module Rigor
             classes.each do |name, klass|
               next if klass["rdoc_only"]
 
-              names = index[name]
-              names.merge(defined_names(klass["instance_methods"]))
-              names.merge(defined_names(klass["aliases"]))
+              merge_names(index[name], klass, side)
             end
           end
           Ractor.make_shareable(index.to_h { |name, names| [name, names.freeze] })
@@ -45,6 +54,13 @@ module Rigor
           Ractor.make_shareable({})
         end
 
+        def merge_names(names, klass, side)
+          return names.merge(defined_names(klass["singleton_methods"])) if side == :singleton
+
+          names.merge(defined_names(klass["instance_methods"]))
+          names.merge(defined_names(klass["aliases"]))
+        end
+
         # The names of `entries` CRuby defines at runtime: one the catalogue marks `rdoc_only` was registered only for
         # RDoc, inside an `#if 0` block.
         def defined_names(entries)
@@ -54,7 +70,8 @@ module Rigor
         end
 
         INDEX = build_index
-        private_constant :INDEX
+        SINGLETON_INDEX = build_index(:singleton)
+        private_constant :INDEX, :SINGLETON_INDEX
       end
     end
   end

data/lib/rigor/inference/captured_locals.rb

@@ -310,23 +310,63 @@ module Rigor
 
       # The mutation sites under `body` whose reads name a variable {.captured_target?} accepts, keyed by name.
       # The block yields the names the enclosing construct introduces, asked only when a local site is found.
+      #
+      # A site whose receiver is a body local that aliases a capture (`l2 = log; l2 << e`) mutates that capture's
+      # object, so it is attributed to the capture as well ({.aliased_captures}): left out, the next iteration
+      # read `log` at its entry `[]` and `[1, 2].inject(0) { |a, e| r = a + log.size; l2 = log; l2 << e; r }`
+      # folded to `0` where Ruby answers `1` (issue #1332).
       def body_mutation_sites(body, base_scope, non_locals, &)
         sites = nil
         evaluator = nil
+        aliases = nil
         Source::NodeWalker.each_with_ancestors(body) do |descendant, ancestors|
           # A callee is resolved in the call-site scope, as the straight-line callee floor resolves it.
           site = mutation_site(descendant) { evaluator ||= StatementEvaluator.new(scope: base_scope) }
           next if site.nil?
 
           site_reads(site).each do |read|
-            next unless captured_target?(read, ancestors, base_scope, non_locals, &)
-
-            ((sites ||= {})[read.name] ||= []) << site
+            targets = captured_target?(read, ancestors, base_scope, non_locals, &) ? [read] : []
+            if read.is_a?(Prism::LocalVariableReadNode)
+              aliases ||= local_aliases(body)
+              targets.concat(aliased_captures(read.name, aliases, base_scope, non_locals, Set.new, &))
+            end
+            targets.each { |target| ((sites ||= {})[target.name] ||= []) << site }
           end
         end
         sites || NO_SITES
       end
 
+      # `{ name => [[read, ancestors], ...] }`: every variable read a local write under `body` may store
+      # ({ReceiverAlias.candidates} of its value), with the ancestors {.captured_target?} resolves it against.
+      def local_aliases(body)
+        aliases = {}
+        Source::NodeWalker.each_with_ancestors(body) do |node, ancestors|
+          next unless node.is_a?(Prism::LocalVariableWriteNode) || node.is_a?(Prism::LocalVariableOrWriteNode)
+
+          ReceiverAlias.candidates(node.value).each do |read|
+            (aliases[node.name] ||= []) << [read, ancestors + [node]]
+          end
+        end
+        aliases
+      end
+
+      # The captured reads the local `name` may alias, followed through local-to-local copies (`l3 = l2 = log`).
+      # It over-approximates — a write in any branch, or in a nested scope reusing the name, counts — which only
+      # widens a capture's binding.
+      def aliased_captures(name, aliases, base_scope, non_locals, visited, &)
+        return [] unless visited.add?(name)
+
+        aliases.fetch(name, NO_NAMES).flat_map do |read, ancestors|
+          if captured_target?(read, ancestors, base_scope, non_locals, &)
+            [read]
+          elsif read.is_a?(Prism::LocalVariableReadNode)
+            aliased_captures(read.name, aliases, base_scope, non_locals, visited, &)
+          else
+            NO_NAMES
+          end
+        end
+      end
+
       # The mutation site `node` is — the node itself, or a {UnknownStoreWidening::CalleeStore} for a self-call
       # whose callee content-mutates a local it is passed — or nil. A self-call is resolved by the
       # `StatementEvaluator` the block yields, which the caller builds only when one is needed. A mutator name

data/lib/rigor/inference/expression_typer.rb

@@ -1952,19 +1952,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 +2011,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 +2037,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 +2057,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 +2071,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 +2099,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 +2471,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 +2506,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 +2520,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 +2692,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)
@@ -5417,13 +5435,27 @@ 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) })
+        rest.each_with_index do |element_value, position|
+          acc = inject_constant_step(block, acc, element_value, captured, position)
           return nil if acc.nil?
         end
         acc
       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 +5507,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,13 +5539,14 @@ 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
         )

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/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

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

@@ -1019,7 +1019,7 @@ module Rigor
             self_type = self_type_override ||
                         (kind == :singleton ? Type::Combinator.singleton_of(class_name) : instance_type)
 
-            keywords_last = keyword_arguments_last?(call_node, args)
+            keywords_last = ArgumentNodes.keyword_hash_last?(call_node, args)
             call_site = [class_name, method_name, kind]
             if keywords_last && args.last.is_a?(Type::HashShape)
               distributed = distributed_keyword_return(method_definition, self_type, instance_type, type_vars, args,
@@ -1129,21 +1129,9 @@ module Rigor
             dynamic_value && !joined.is_a?(Type::Dynamic) ? Type::Combinator.dynamic(joined) : joined
           end
 
-          # 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_arguments_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
-
           # Issue #1801 — the indices of `args` the call passes as splat arguments (`f(*xs, k: 1)`), whose positional
-          # count is not known statically, or nil without one. As for {#keyword_arguments_last?}, only a call whose
-          # node's arguments are exactly `args` answers.
+          # count is not known statically, or nil without one. As for {ArgumentNodes.keyword_hash_last?}, only a call
+          # whose node's arguments are exactly `args` answers.
           def splat_indices(call_node, args)
             return nil if args.empty? || !call_node.respond_to?(:arguments)
 
@@ -1729,7 +1717,7 @@ module Rigor
 
           def probe_block_param_types(receiver:, method_name:, args:, environment:, scope: nil, call_node: nil)
             args ||= []
-            keywords_last = keyword_arguments_last?(call_node, args)
+            keywords_last = ArgumentNodes.keyword_hash_last?(call_node, args)
             splat = splat_indices(call_node, args)
             case receiver
             when Type::Union