rigortype 0.4.1 → 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
 
@@ -1006,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.
           #
@@ -1074,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,
@@ -1087,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?)
@@ -1098,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
@@ -1268,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?
 
@@ -1602,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
 
@@ -1614,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 }
@@ -1624,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
 
@@ -1642,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
             []
@@ -1651,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 =
@@ -1672,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,
@@ -1685,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,
@@ -1697,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

data/lib/rigor/inference/method_dispatcher.rb

@@ -18,6 +18,7 @@ require_relative "method_dispatcher/data_folding"
 require_relative "method_dispatcher/struct_folding"
 require_relative "method_dispatcher/rbs_dispatch"
 require_relative "method_dispatcher/iterator_dispatch"
+require_relative "method_dispatcher/arithmetic_sequence_elements"
 require_relative "method_dispatcher/reduce_folding"
 require_relative "method_dispatcher/block_folding"
 require_relative "method_dispatcher/array_to_h_folding"
@@ -101,7 +102,7 @@ module Rigor
       # the tier commits the buffer only if it goes on to answer. See {#try_composite_receiver}.
       def resolve(receiver_type:, method_name:, arg_types:, # rubocop:disable Metrics/AbcSize, Metrics/MethodLength, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity, Metrics/ParameterLists
                   block_type: nil, environment: nil,
-                  call_node: nil, scope: nil, plugin_typed_sink: nil)
+                  call_node: nil, scope: nil, plugin_typed_sink: nil, skip_project_patched: false)
         return nil if receiver_type.nil?
 
         # Build the call context once and thread it — unchanged — through every tier
@@ -205,7 +206,10 @@ module Rigor
         # the pre-pass populated `ProjectPatchedMethods` with the `(class, method, kind)` triple;
         # this tier surfaces it as `Dynamic[top]` so the patched call resolves cross-file without
         # `call.undefined-method`.
-        patched_result = try_project_patched_method(receiver_type, method_name, environment)
+        patched_result =
+          unless skip_project_patched
+            try_project_patched_method(receiver_type, method_name, arg_types, block_type, environment)
+          end
         if patched_result
           scope&.record_dynamic_origin(call_node, DynamicOrigin::EXTERNAL_GEM_WITHOUT_RBS)
           return patched_result
@@ -614,7 +618,7 @@ module Rigor
       # `def to_url; "hello"; end` patched onto `String` now resolves `s.to_url` to
       # `Dynamic[Nominal[String]]` instead of the pre-3a `Dynamic[Top]`. Falls back to
       # `Dynamic[Top]` when the heuristic declined (non-literal tail expression).
-      def try_project_patched_method(receiver_type, method_name, environment)
+      def try_project_patched_method(receiver_type, method_name, arg_types, block_type, environment)
         registry = environment&.project_patched_methods
         return nil if registry.nil? || registry.empty?
 
@@ -624,9 +628,25 @@ module Rigor
         kind = receiver_type.is_a?(Type::Singleton) ? :singleton : :instance
         entry = registry.lookup(class_name: class_name, method_name: method_name, kind: kind)
         return nil if entry.nil?
-        return Type::Combinator.untyped if entry.return_type.nil?
+        return Type::Combinator.dynamic(entry.return_type) if entry.return_type
+
+        aliased = project_patched_alias_target(entry, receiver_type, arg_types, block_type, environment)
+        aliased ? Type::Combinator.dynamic(aliased) : Type::Combinator.untyped
+      end
 
-        Type::Combinator.dynamic(entry.return_type)
+      # Issue #1702 — an alias in a `pre_eval:` patch whose old name no earlier patch binding defines
+      # (`alias old_plus +` on Integer, or `alias_method :orig_succ, :succ` ahead of the patch's own `def succ`)
+      # names the method the class had before the patch, so it answers what that method answers for the same
+      # arguments, behind the `Dynamic` every patched method carries. The re-entry skips this tier: a later patch
+      # `def` of the old name is not the body the alias copied, and the skip is also what ends an alias cycle. It
+      # carries no call node or scope, so it answers a type and records nothing at the call site.
+      def project_patched_alias_target(entry, receiver_type, arg_types, block_type, environment)
+        return nil if entry.alias_of.nil?
+
+        resolve(
+          receiver_type: receiver_type, method_name: entry.alias_of, arg_types: arg_types,
+          block_type: block_type, environment: environment, skip_project_patched: true
+        )
       end
 
       # ADR-10 slice 2b-ii. Consults the per-run `Analysis::DependencySourceInference::Index`
@@ -847,7 +867,8 @@ module Rigor
       private_constant :STDLIB_SINGLETON_FOLDERS
 
       PRECISE_TIERS_TAIL = Ractor.make_shareable([
-        MethodFolding, ReduceFolding, ArrayToHFolding, HashTransformKeysFolding, BlockFolding
+        MethodFolding, ReduceFolding, ArrayToHFolding, HashTransformKeysFolding, BlockFolding,
+        ArithmeticSequenceElements
       ].freeze)
       private_constant :PRECISE_TIERS_TAIL
 
@@ -1104,14 +1125,23 @@ module Rigor
       # `instance_of?(self)` later as the rule catalogue grows; for now only `class` is handled.
       def try_meta_introspection(receiver_type, method_name, arg_types = [], context = nil)
         case method_name
-        when :class then meta_class(receiver_type)
+        when :class then meta_class(receiver_type, context&.environment)
         when :new then meta_new(receiver_type, arg_types, context)
         end
       end
 
-      def meta_class(receiver_type)
+      def meta_class(receiver_type, environment = nil)
         case receiver_type
-        when Type::Nominal then Type::Combinator.singleton_of(receiver_type.class_name)
+        when Type::Nominal
+          # An instance of module `M` is an instance of some class that includes `M`, never of `M`
+          # itself: `self.class` in `M`'s instance method is that includer, which no RBS type names.
+          # `Dynamic[Class]` keeps the surface every class shares (`name`, `ancestors`) and answers
+          # nothing for the includer's own singleton methods.
+          if environment&.rbs_module?(receiver_type.class_name)
+            return Type::Combinator.dynamic(Type::Combinator.nominal_of("Class"))
+          end
+
+          Type::Combinator.singleton_of(receiver_type.class_name)
         when Type::Constant then constant_metaclass(receiver_type.value)
         end
       end
@@ -1555,13 +1585,16 @@ module Rigor
       # method definition, or selected overload does not provide statically declared block
       # parameter types. Callers MUST treat the empty array as "no information"; the binder
       # falls back to `Dynamic[Top]` for every parameter slot in that case.
+      #
+      # `call_node` lets the overload selector read the call's keyword arguments as keywords (#1727, #1737), as
+      # the return path does; without it they are read positionally.
       def expected_block_param_types(receiver_type:, method_name:, arg_types:, environment: nil,
-                                     scope: nil)
+                                     scope: nil, call_node: nil)
         return [] if receiver_type.nil?
 
         context = CallContext.build(
           receiver: receiver_type, method_name: method_name,
-          args: arg_types, environment: environment, scope: scope
+          args: arg_types, environment: environment, scope: scope, call_node: call_node
         )
         iterator_result = IteratorDispatch.block_param_types(context)
         return iterator_result if iterator_result

data/lib/rigor/inference/module_function_state.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require "prism"
+require_relative "../source/literals"
 require_relative "../source/node_children"
 
 module Rigor
@@ -204,7 +205,7 @@ module Rigor
 
       # The Symbol a `:name` or `"name"` literal argument names, or nil.
       def symbol_argument_name(arg)
-        arg.unescaped.to_sym if arg.is_a?(Prism::SymbolNode) || arg.is_a?(Prism::StringNode)
+        Source::Literals.symbol_or_string(arg)
       end
 
       private_class_method :prescan_call, :prescan_eval_call, :symbol_argument_name