rigortype 0.4.0 → 0.4.2

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

@@ -243,7 +243,8 @@ module Rigor
             method_name: context.method_name,
             args: context.args,
             environment: environment,
-            scope: context.scope
+            scope: context.scope,
+            call_node: context.call_node
           )
         end
 
@@ -277,6 +278,11 @@ module Rigor
 
           def dispatch_one(receiver, method_name, args, environment, block_type, self_type_override = nil, # rubocop:disable Metrics/ParameterLists
                            public_only: false, scope: nil, call_node: nil)
+            # Issue #1794 — a sequence's inherited Enumerable surface reads its Rigor-private element argument, with
+            # `self` still the sequence.
+            element = ArithmeticSequenceElements.element_receiver(receiver, method_name, environment)
+            self_type_override ||= receiver if element
+            receiver = element || receiver
             descriptor = receiver_descriptor(receiver)
             return nil unless descriptor
 
@@ -564,11 +570,11 @@ module Rigor
 
             memo = core_stdlib_memo(environment, scope)
             key = [class_name.to_s, method_name.to_sym]
-            return memo[key] if memo&.key?(key)
+            return memo[key] if memo.key?(key)
 
-            answer = compute_core_stdlib_ancestor_method(environment, class_name, method_name, scope)
-            memo[key] = answer if memo
-            answer
+            store_unless_recorded(memo, key) do
+              compute_core_stdlib_ancestor_method(environment, class_name, method_name, scope)
+            end
           end
 
           # Issue #1173 — the include-edge sibling of {#core_stdlib_ancestor_method}: a discovered
@@ -596,11 +602,11 @@ module Rigor
 
             memo = mixin_ancestor_memo(environment, scope)
             key = [class_name.to_s, method_name.to_sym]
-            return memo[key] if memo&.key?(key)
+            return memo[key] if memo.key?(key)
 
-            answer = compute_included_module_method(environment, class_name, method_name, scope)
-            memo[key] = answer if memo
-            answer
+            store_unless_recorded(memo, key) do
+              compute_included_module_method(environment, class_name, method_name, scope)
+            end
           end
 
           # The declines are conjunctive and ordered as {compute_core_stdlib_ancestor_method}'s are:
@@ -626,20 +632,12 @@ module Rigor
           end
 
           # The same one-slot memo shape as {#core_stdlib_memo}; see there for why it is one slot keyed
-          # on the discovery index's identity, and why a recording run bypasses it.
+          # on the discovery index's identity, and what a recording run may store in it.
           MIXIN_ANCESTOR_MEMO_KEY = :__rigor_mixin_ancestor_dispatch__
           private_constant :MIXIN_ANCESTOR_MEMO_KEY
 
           def mixin_ancestor_memo(environment, scope)
-            return nil if Rigor::Analysis::DependencyRecorder.active?
-
-            discovery = scope.discovery
-            slot = Thread.current[MIXIN_ANCESTOR_MEMO_KEY]
-            unless slot && slot[0].equal?(discovery) && slot[1].equal?(environment)
-              slot = [discovery, environment, {}]
-              Thread.current[MIXIN_ANCESTOR_MEMO_KEY] = slot
-            end
-            slot[2]
+            ancestor_memo_slot(MIXIN_ANCESTOR_MEMO_KEY, environment, scope)
           end
 
           # The declines are conjunctive, so their ORDER is free — and it is chosen so the two that walk
@@ -800,8 +798,10 @@ module Rigor
           # Memo for the whole decision. Every call site of a class asks the same `(class, method)`
           # question, and the answer is a pure function of the frozen discovery index and the
           # environment, so it is cacheable on their identity. A run that is RECORDING ADR-46
-          # dependency edges bypasses it: the shadow probes above read the project's method tables, and
-          # a memo would swallow that edge for every file after the first.
+          # dependency edges stores only the answers whose computation recorded nothing
+          # ({#store_unless_recorded}): the shadow probes above read the project's method tables, and
+          # serving an answer that read them from the memo would swallow those edges for every later
+          # caller.
           #
           # ONE slot, replaced rather than accumulated — see {ExternalAncestorResolution}'s twin for
           # the measurement. A `Scope` hands each analysed file its own discovery index, so an
@@ -811,15 +811,38 @@ module Rigor
           private_constant :CORE_STDLIB_ANCESTOR_MEMO_KEY
 
           def core_stdlib_memo(environment, scope)
-            return nil if Rigor::Analysis::DependencyRecorder.active?
+            ancestor_memo_slot(CORE_STDLIB_ANCESTOR_MEMO_KEY, environment, scope)
+          end
 
+          # The slot behind both memos. Whether this thread is recording is part of its key, so a slot
+          # filled with every answer is never read by a recording caller, which may only reuse the
+          # answers {#store_unless_recorded} lets through.
+          def ancestor_memo_slot(memo_key, environment, scope)
             discovery = scope.discovery
-            slot = Thread.current[CORE_STDLIB_ANCESTOR_MEMO_KEY]
-            unless slot && slot[0].equal?(discovery) && slot[1].equal?(environment)
-              slot = [discovery, environment, {}]
-              Thread.current[CORE_STDLIB_ANCESTOR_MEMO_KEY] = slot
+            recording = Rigor::Analysis::DependencyRecorder.recording?
+            slot = Thread.current[memo_key]
+            unless slot && slot[0].equal?(discovery) && slot[1].equal?(environment) && slot[2] == recording
+              slot = [discovery, environment, recording, {}]
+              Thread.current[memo_key] = slot
             end
-            slot[2]
+            slot[3]
+          end
+
+          # Computes an answer, stores it under `key` when it may be served again, and returns it.
+          # Outside recording every answer is stored. Under ADR-46 recording the block runs in an
+          # ADR-84 WD2 capture window, which sees every edge the block files for the current consumer
+          # (the reads it withholds are not among them). An answer whose window stayed empty is stored:
+          # computing it again would read the same frozen tables and file nothing again, so serving it
+          # from the memo records exactly what recomputing does. That is most of them, since both
+          # computations withhold their ancestry walk and return before any recorded probe unless an
+          # RBS declaration answered. Any other answer is recomputed on every call, which files its
+          # edges each time, as a recording run always did.
+          def store_unless_recorded(memo, key, &)
+            return memo[key] = yield unless Rigor::Analysis::DependencyRecorder.recording?
+
+            answer, read_set = Rigor::Analysis::DependencyRecorder.capture(&)
+            memo[key] = answer if read_set.reads.empty? && read_set.missing.empty?
+            answer
           end
 
           # BFS over the scope's as-written ancestry tables — include edges first, then the
@@ -889,6 +912,7 @@ module Rigor
               # The class's own `def self.x` sits ahead of every `extend` — once it has run.
               # `singleton_def_shadows_call?` orders the def against the call site, so a `def self.sig`
               # written AFTER this `sig {}` does not suppress the bridge.
+              # ADR-119: shadowing already withholds the bridge, so a possible def withholds too.
               return nil if scope.singleton_def_shadows_call?(current, method_name, call_node)
 
               resolved = rbs_complete_extended_module_for(current, extends, environment, scope,
@@ -927,6 +951,8 @@ module Rigor
             nil
           end
 
+          # ADR-119: "defines" here stops the allow-list walk (a withholding answer), so a possible def stays
+          # a definer — treating it as absent would let a later extend bridge a call the def may own.
           def extend_owner_defines?(owner, method_name, call_node, scope, environment)
             return true if scope.instance_def_shadows_call?(owner, method_name, call_node)
 
@@ -986,41 +1012,147 @@ module Rigor
             return override if override
 
             instance_type = Type::Combinator.nominal_of(class_name)
-            resolved_self_type =
-              case kind
-              when :singleton then Type::Combinator.singleton_of(class_name)
-              else                 instance_type
-              end
             # `self_type_override` lets the user-class fallback path preserve the ORIGINAL receiver as the
             # substitute for `Bases::Self` — so `Kernel#dup: () -> self` resolved through the Object
             # fallback returns the caller's type, not Object. `dispatch_one` also routes the receiver's
             # type-argument-bearing projection through it ({SelfSubstitute}, #1092).
-            self_type = self_type_override || resolved_self_type
+            self_type = self_type_override ||
+                        (kind == :singleton ? Type::Combinator.singleton_of(class_name) : instance_type)
+
+            keywords_last = keyword_arguments_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,
+                                                       block_type, scope, call_node, call_site, environment)
+              return distributed unless distributed.equal?(NOT_DISTRIBUTED)
+            end
 
             candidates = OverloadSelector.select_candidates(
               method_definition,
               arg_types: args,
+              keywords_last: keywords_last, splats: splat_indices(call_node, args),
               # A `Dynamic` self (#1092) is a return-side answer; overload selection and ReceiverAffinity
               # read the static facet, as they did before the substitute carried the wrapping.
               self_type: self_type.is_a?(Type::Dynamic) ? self_type.static_facet : self_type,
-              instance_type: instance_type,
-              type_vars: type_vars,
+              instance_type: instance_type, type_vars: type_vars,
               block_required: !block_type.nil?,
               environment: environment
             )
             return nil if candidates.empty?
 
-            call_site = [class_name, method_name, kind]
             record_dispatch_provenance(method_definition, candidates.first, scope, call_node, call_site)
             join_candidate_returns(
               candidates,
               method_definition: method_definition,
               self_type: self_type, instance_type: instance_type, type_vars: type_vars,
               args: args, block_type: block_type, scope: scope, call_node: call_node, call_site: call_site,
-              alias_expander: environment.rbs_loader
+              alias_expander: environment.rbs_loader, keywords_last: keywords_last
             )
           end
 
+          # Issue #1746 — a keyword hash holding a union value (`headers: flag` with `flag : bool`) selects per member
+          # at runtime, so the return reads one overload per {KeywordArguments.distributions} list and joins their
+          # returns, as the block probe does for its parameters (#1737). Selecting once for the whole value took one
+          # member's overload (`Symbol` for `(headers: true) -> Symbol | (?headers: false) -> Integer`). Each list
+          # counts only a genuine match: a member no overload takes, or more lists than the limit, answers
+          # `Dynamic[top]` rather than lend the first-overload fallback to the join. A precise union value joins the
+          # returns as a union; a `Dynamic` value keeps the answer `Dynamic`, as the #521 join does, since the split
+          # dropped the value's `nil` and the untyped input behind it. A keyword hash with no union value answers
+          # {NOT_DISTRIBUTED}, and the call selects as before; so does one whose values do not split (#1779) and that no
+          # overload genuinely takes.
+          NOT_DISTRIBUTED = Object.new.freeze
+          private_constant :NOT_DISTRIBUTED
+
+          # rubocop:disable Metrics/ParameterLists
+          def distributed_keyword_return(method_definition, self_type, instance_type, type_vars, args, block_type,
+                                         scope, call_node, call_site, environment)
+            # rubocop:enable Metrics/ParameterLists
+            # One overload is the only one any member can select, and a wide union value (`receiver_type: Type::t`)
+            # spelled out member by member would only pass the distribution limit.
+            method_types = method_definition.method_types
+            return NOT_DISTRIBUTED if method_types.size < 2
+            # A keyword hash no overload takes as keywords is a positional `Hash` throughout (#1737).
+            return NOT_DISTRIBUTED unless KeywordArguments.any_declares?(method_types)
+
+            keywords = args.last
+            return NOT_DISTRIBUTED if keywords.pairs.none? { |_name, value| KeywordArguments.union_members(value) }
+
+            selector_self = self_type.is_a?(Type::Dynamic) ? self_type.static_facet : self_type
+            per_list = distributed_keyword_matches(method_definition, args, selector_self, instance_type, type_vars,
+                                                   !block_type.nil?, environment, splat_indices(call_node, args))
+            return NOT_DISTRIBUTED if per_list.equal?(NOT_DISTRIBUTED)
+            return Type::Combinator.untyped if per_list.nil?
+
+            overloads = per_list.flat_map(&:last).uniq
+            if overloads.size == 1
+              record_dispatch_provenance(method_definition, overloads.first, scope, call_node, call_site)
+            end
+            returns = per_list.map do |arg_types, matches|
+              join_candidate_returns(
+                matches,
+                method_definition: method_definition,
+                self_type: self_type, instance_type: instance_type, type_vars: type_vars,
+                args: arg_types, block_type: block_type, scope: scope, call_node: call_node, call_site: call_site,
+                alias_expander: environment.rbs_loader, keywords_last: true
+              )
+            end
+            join_distributed_returns(returns, keywords)
+          end
+
+          # Each distribution list with its genuine matches, or nil past the distribution limit or when a list has
+          # none. When no value split (no union value's key discriminates between the overloads, #1779), the one list
+          # is the call as given, and one with no genuine match answers {NOT_DISTRIBUTED}: the call then selects as it
+          # did before #1746, first-overload fallback included (`1.step(10, by: (c ? 1 : 2.0))` is
+          # `Enumerator::ArithmeticSequence` through the incomplete stdlib RBS).
+          # rubocop:disable Metrics/ParameterLists
+          def distributed_keyword_matches(method_definition, args, selector_self, instance_type, type_vars,
+                                          block_required, environment, splats)
+            # rubocop:enable Metrics/ParameterLists
+            distributions = keyword_distributions(method_definition, args, selector_self, instance_type, type_vars,
+                                                  environment, splats)
+            return nil if distributions.nil?
+
+            distributions.map do |arg_types|
+              matches = keyword_matches(method_definition, arg_types, selector_self, instance_type, type_vars,
+                                        block_required, environment, splats)
+              return arg_types.equal?(args) ? NOT_DISTRIBUTED : nil if matches.empty?
+
+              [arg_types, matches]
+            end
+          end
+
+          def join_distributed_returns(returns, keywords)
+            return nil if returns.any?(&:nil?)
+
+            joined = Type::Combinator.union(*returns.uniq)
+            dynamic_value = keywords.pairs.any? { |_name, value| value.is_a?(Type::Dynamic) }
+            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.
+          def splat_indices(call_node, args)
+            return nil if args.empty? || !call_node.respond_to?(:arguments)
+
+            arguments = call_node.arguments&.arguments
+            return nil if arguments.nil? || arguments.size != args.size || arguments.none?(Prism::SplatNode)
+
+            arguments.each_index.select { |index| arguments[index].is_a?(Prism::SplatNode) }
+          end
+
           # The two provenance side-tables the return-typing tier is the last place able to populate, recorded
           # together because they share one gate (`scope` && `call_node`) and one call site.
           #
@@ -1054,10 +1186,16 @@ module Rigor
           # A candidate whose return does not translate leaves the join incomplete — decline (fail-soft
           # to Dynamic downstream) rather than answer a join missing an arm the runtime can take.
           # rubocop:disable-next Metrics/ParameterLists
+          # rubocop:disable Metrics/ParameterLists
           def join_candidate_returns(candidates, method_definition:, self_type:, instance_type:, type_vars:, args:,
-                                     block_type:, scope:, call_node:, call_site:, alias_expander: nil)
+                                     block_type:, scope:, call_node:, call_site:, alias_expander: nil,
+                                     keywords_last: false)
+            # rubocop:enable Metrics/ParameterLists
             returns = candidates.map do |method_type|
-              full_type_vars = compose_type_vars(method_type, type_vars, args, block_type, scope, call_node, call_site)
+              # An overload that takes the keyword hash as its keywords binds no positional parameter to it.
+              positional = KeywordArguments.positional(method_type, args, keywords_last)
+              full_type_vars = compose_type_vars(method_type, type_vars, args, positional, block_type, scope,
+                                                 call_node, call_site)
               returned = RbsTypeTranslator.translate(
                 method_type.type.return_type,
                 self_type: self_type,
@@ -1067,7 +1205,7 @@ module Rigor
               )
               next returned unless combining_overload?(method_definition, method_type, call_site)
 
-              class_level_sum(returned, method_type, args)
+              class_level_sum(returned, method_type, positional)
             end
             return returns.first if returns.size == 1
             return nil if returns.any?(&:nil?)
@@ -1078,11 +1216,17 @@ module Rigor
             Type::Combinator.dynamic(Type::Combinator.union(*distinct))
           end
 
-          def compose_type_vars(method_type, type_vars, args, block_type, scope, call_node, call_site)
+          # `positional` is `args` less a keyword hash the overload takes as its keywords (#1727). The block-return
+          # rule reads every argument, the keyword hash included: a keyword parameter naming the block's variable
+          # (`[T] (?default: T) { () -> T } -> T`) is an argument reaching it. The positional binding reads only the
+          # arguments that land in positional parameters.
+          # rubocop:disable Metrics/ParameterLists
+          def compose_type_vars(method_type, type_vars, args, positional, block_type, scope, call_node, call_site)
+            # rubocop:enable Metrics/ParameterLists
             vars = compose_block_type_vars(method_type, type_vars, block_type, args,
                                            scope: scope, call_node: call_node, call_site: call_site)
-            compose_arg_type_vars(method_type, vars, args, scope: scope, call_node: call_node,
-                                                           call_site: call_site)
+            compose_arg_type_vars(method_type, vars, positional, scope: scope, call_node: call_node,
+                                                                 call_site: call_site)
           end
 
           # Whether the overload is one `Enumerable` declares for `sum`, whose declared return the tier reads
@@ -1248,7 +1392,8 @@ module Rigor
           # Whether an argument the call passes may land in a parameter whose type names `name`, anywhere
           # inside it (`hash[_Key, K2]` names `K2`). The argument count is not matched against the
           # parameter list: a `*splat` argument stands for any number of arguments, and keyword arguments
-          # arrive as one more entry in `args`, so any argument counts as reaching every parameter.
+          # arrive as one more entry in `args` (untrimmed, #1727), so any argument counts as reaching every
+          # parameter.
           def argument_reaches_variable?(method_type, name, args)
             return false if args.empty?
 
@@ -1582,11 +1727,15 @@ module Rigor
 
           # ----- block parameter probe (Phase C sub-phase 1) -----
 
-          def probe_block_param_types(receiver:, method_name:, args:, environment:, scope: nil)
+          def probe_block_param_types(receiver:, method_name:, args:, environment:, scope: nil, call_node: nil)
             args ||= []
+            keywords_last = keyword_arguments_last?(call_node, args)
+            splat = splat_indices(call_node, args)
             case receiver
-            when Type::Union then probe_block_param_types_union(receiver, method_name, args, environment, scope)
-            else                  probe_block_param_types_one(receiver, method_name, args, environment, scope)
+            when Type::Union
+              probe_block_param_types_union(receiver, method_name, args, environment, scope, keywords_last, splat)
+            else
+              probe_block_param_types_one(receiver, method_name, args, environment, scope, keywords_last, splat)
             end
           end
 
@@ -1594,9 +1743,9 @@ module Rigor
           # member resolves the same arity and types (otherwise the call sites would have to thread
           # per-member binders, which the slice does not support yet). Mismatches degrade to the empty
           # array so the binder defaults all params to Dynamic[Top].
-          def probe_block_param_types_union(receiver, method_name, args, environment, scope)
+          def probe_block_param_types_union(receiver, method_name, args, environment, scope, keywords_last, splat)
             results = receiver.members.map do |member|
-              probe_block_param_types_one(member, method_name, args, environment, scope)
+              probe_block_param_types_one(member, method_name, args, environment, scope, keywords_last, splat)
             end
             return [] if results.empty?
             return [] unless results.all? { |r| r == results.first }
@@ -1604,7 +1753,9 @@ module Rigor
             results.first
           end
 
-          def probe_block_param_types_one(receiver, method_name, args, environment, scope)
+          def probe_block_param_types_one(receiver, method_name, args, environment, scope, keywords_last, splat)
+            receiver = ArithmeticSequenceElements.element_receiver(receiver, method_name, environment, block: true) ||
+                       receiver
             descriptor = receiver_descriptor(receiver)
             return [] unless descriptor
 
@@ -1622,7 +1773,8 @@ module Rigor
               environment: environment,
               receiver: receiver,
               receiver_args: receiver_args,
-              method_name: method_name
+              method_name: method_name,
+              keywords_last: keywords_last, positional_splat: splat
             )
           rescue StandardError
             []
@@ -1631,7 +1783,7 @@ module Rigor
           # rubocop:disable Metrics/ParameterLists
           def extract_block_param_types(method_definition, class_name:, kind:, args:, type_vars:,
                                         environment: nil, receiver: nil, receiver_args: [],
-                                        method_name: nil)
+                                        method_name: nil, keywords_last: false, positional_splat: nil)
             # rubocop:enable Metrics/ParameterLists
             instance_type = Type::Combinator.nominal_of(class_name)
             self_type =
@@ -1652,12 +1804,25 @@ module Rigor
             substitute = SelfSubstitute.for(receiver, receiver_args, method_name, args, nil)
             self_type = Type::Combinator.nominal_of(class_name, type_args: receiver_args) if substitute
 
+            selector_self = self_type.is_a?(Type::Dynamic) ? self_type.static_facet : self_type
+            if keywords_last
+              return agreed_keyword_block_params(method_definition, args, self_type, selector_self, instance_type,
+                                                 type_vars, environment, positional_splat)
+            end
+
+            # A splat (#1801) leaves the positional count open, so every overload some count reaches must agree.
+            if positional_splat || FacetDistribution.faceted?(args)
+              matches = facet_matches(method_definition, args, selector_self, instance_type, type_vars, true,
+                                      environment, false, positional_splat)
+              return agreed_block_params(matches, self_type, instance_type, type_vars, environment)
+            end
+
             method_type = OverloadSelector.select(
               method_definition,
               arg_types: args,
               # Overload selection reads a `Dynamic` self's static facet, mirroring the return path;
               # the substitution verdict here is built from the receiver's type arguments alone.
-              self_type: self_type.is_a?(Type::Dynamic) ? self_type.static_facet : self_type,
+              self_type: selector_self,
               instance_type: instance_type,
               type_vars: type_vars,
               block_required: true,
@@ -1665,8 +1830,20 @@ module Rigor
             )
             return [] unless method_type
 
+            block_params_of(method_type, self_type, instance_type, type_vars, environment) || []
+          end
+
+          # The block parameters every overload in `matches` declares alike, or no information (`[]`).
+          def agreed_block_params(matches, self_type, instance_type, type_vars, environment)
+            answers = matches.uniq.map do |method_type|
+              block_params_of(method_type, self_type, instance_type, type_vars, environment)
+            end
+            answers.uniq.size == 1 && answers.first ? answers.first : []
+          end
+
+          def block_params_of(method_type, self_type, instance_type, type_vars, environment)
             block = method_type.respond_to?(:block) ? method_type.block : nil
-            return [] unless block
+            return nil unless block
 
             translate_block_positional_params(
               block,
@@ -1677,6 +1854,80 @@ module Rigor
             )
           end
 
+          # {KeywordArguments.distributions} for the call's keyword hash. An overload that declares no keywords may read
+          # the hash as a positional `Hash`, and then every union value splits: with
+          # `(a: Integer) -> Integer | (Hash[Symbol, String]) -> String`, `a: Integer | String`'s `String` member takes
+          # the second overload and its `Integer` member the first. A parameter that cannot take a `Hash` (`(String)`)
+          # leaves the split to the keyword declarations.
+          # `splats`: a splat argument hides how many positional arguments precede the hash.
+          def keyword_distributions(method_definition, args, selector_self, instance_type, type_vars, environment,
+                                    splats)
+            hash = Type::Combinator.nominal_of("Hash")
+            count = splats ? nil : args.size
+            KeywordArguments.distributions(args, true, method_definition.method_types, count) do |param|
+              param_type = RbsTypeTranslator.translate(
+                param.type, self_type: selector_self, instance_type: instance_type, type_vars: type_vars,
+                            alias_expander: environment.rbs_loader
+              )
+              !param_type.accepts(hash, mode: :gradual).no?
+            end
+          end
+
+          # rubocop:disable Metrics/ParameterLists
+          def agreed_keyword_block_params(method_definition, args, self_type, selector_self, instance_type, type_vars,
+                                          environment, splats)
+            # rubocop:enable Metrics/ParameterLists
+            distributions = keyword_distributions(method_definition, args, selector_self, instance_type, type_vars,
+                                                  environment, splats)
+            return [] if distributions.nil?
+
+            candidates = []
+            distributions.each do |arg_types|
+              # Genuine matches only (`member` true): a member no overload takes must not lend the first-overload
+              # fallback to the agreement, which bound `headers: (true | nil)`'s block to the `true` arm.
+              matches = keyword_matches(method_definition, arg_types, selector_self, instance_type, type_vars, true,
+                                        environment, splats)
+              return [] if matches.empty?
+
+              candidates.concat(matches)
+            end
+            agreed_block_params(candidates, self_type, instance_type, type_vars, environment)
+          end
+
+          # One distribution's genuine matches. A faceted positional argument (a `Dynamic` with sealed facet members) is
+          # read member-wise as `OverloadSelector.select_candidates` reads it, but every list answers only a genuine
+          # match: the first-overload fallback must not count toward the block probe's agreement or the return path's
+          # join.
+          # rubocop:disable Metrics/ParameterLists
+          def keyword_matches(method_definition, arg_types, selector_self, instance_type, type_vars, block_required,
+                              environment, splats)
+            # rubocop:enable Metrics/ParameterLists
+            unless FacetDistribution.faceted?(arg_types)
+              return OverloadSelector.select_declared(method_definition, arg_types, selector_self, instance_type,
+                                                      type_vars, block_required, environment, true, true, splats)
+            end
+
+            facet_matches(method_definition, arg_types, selector_self, instance_type, type_vars, block_required,
+                          environment, true, splats)
+          end
+
+          # Issue #1750 — the overloads a faceted argument list may reach, read member-wise with genuine matches only.
+          # Where `FacetDistribution.select` falls back to the arguments as given (overloads not provable, more lists
+          # than its cap, or a member no overload takes), the bare `Dynamic` gradually matches every arm and the
+          # strict pass's pick is the first by position, so the answer is every gradual match
+          # (`OverloadSelector.select_declared`'s `:gradual`) and the caller binds only what they all agree on.
+          # rubocop:disable Metrics/ParameterLists
+          def facet_matches(method_definition, arg_types, selector_self, instance_type, type_vars, block_required,
+                            environment, keywords_last, splats = nil)
+            # rubocop:enable Metrics/ParameterLists
+            FacetDistribution.select(arg_types, method_definition, member_wise: true, environment:) do |list, member|
+              # The fallback list (`member` false) answers every gradual match rather than the strict pass's pick.
+              OverloadSelector.select_declared(method_definition, list, selector_self, instance_type, type_vars,
+                                               block_required, environment, member || :gradual, keywords_last,
+                                               splats)
+            end
+          end
+
           # `RBS::Types::Block#type` is normally an `RBS::Types::Function` carrying the block's parameter
           # list; some signatures use `RBS::Types::UntypedFunction` (a `(?)` block) which exposes no
           # parameter types -- we treat it as "no information" and return an empty array so the binder

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

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+module Rigor
+  module Inference
+    module MethodDispatcher
+      # How `OverloadSelector` reads a call whose positional arguments include a splat (`f(*xs, a: v)`), #1801.
+      #
+      # A splat stands for any number of arguments, so the call's positional count is not known statically. The
+      # selector sees each splat as one untyped entry of the argument list, and counted that way it ruled out every
+      # overload whose arity the splat may still meet: `ph(*xs, a: "s")` skipped `(Hash[Symbol, String]) -> String`,
+      # which takes `{ a: "s" }` when `xs` is empty (`def ph(h) = h; ph(*[], a: "s")` is `{ a: "s" }`). Instead, an
+      # overload matches when some count of the splats' elements fits its arity and every argument, the splats'
+      # untyped elements included, is accepted at the parameter that count binds it to.
+      module SplatArity
+        # The most argument lists {.expansions} spells out; past it, the selector only asks that every other argument
+        # fit some positional parameter of the overload.
+        LIMIT = 32
+        private_constant :LIMIT
+
+        module_function
+
+        # The argument lists `arg_types` stands for against `fun`, each splat entry (at `splats`, indices into
+        # `arg_types`) repeated as often as `fun`'s positional parameters can take, from none upward; nil past
+        # {LIMIT}. An untyped `(?)` parameter list takes any count, so the list as given stands for all of them.
+        def expansions(fun, arg_types, splats)
+          return [arg_types] unless fun.respond_to?(:required_positionals)
+
+          indices = splats.select { |index| index < arg_types.size }
+          return [arg_types] if indices.empty?
+
+          bound = element_bound(fun, arg_types.size - indices.size)
+          counts = counts(indices.size, bound)
+          return nil if counts.nil?
+
+          counts.map { |count| expand(arg_types, indices, count) }
+        end
+
+        # The most splat elements a call with `fixed` other positional arguments can pass to `fun`: up to its maximum
+        # arity, or, with a `*rest`, one past filling every other parameter, since further elements land in the rest
+        # parameter alike.
+        def element_bound(fun, fixed)
+          declared = fun.required_positionals.size + fun.optional_positionals.size + fun.trailing_positionals.size
+          return declared + 1 if fun.rest_positionals
+
+          [declared - fixed, 0].max
+        end
+
+        # Every way to give `splats` splats at most `bound` elements in all, or nil past {LIMIT}.
+        def counts(splats, bound)
+          combinations = [[]]
+          splats.times do
+            combinations = combinations.flat_map do |partial|
+              (0..(bound - partial.sum)).map { |count| partial + [count] }
+            end
+            return nil if combinations.size > LIMIT
+          end
+          combinations
+        end
+
+        def expand(arg_types, indices, counts)
+          expanded = []
+          arg_types.each_with_index do |arg, index|
+            position = indices.index(index)
+            position ? expanded.concat([arg] * counts[position]) : expanded << arg
+          end
+          expanded
+        end
+      end
+    end
+  end
+end