rigortype 0.4.1 → 0.4.2

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

@@ -3,6 +3,7 @@
 require_relative "../../type"
 require_relative "singleton_folding"
 require_relative "hash_transform_keys_folding"
+require_relative "integer_step_block_params"
 
 module Rigor
   module Inference
@@ -23,6 +24,10 @@ module Rigor
       #   bound from the argument.
       # - `a.downto(b) { |i| … }` yields the same domain `[b, a]`, just iterated in reverse. Lower bound
       #   from the argument, upper bound from the receiver.
+      # - `a.step(limit, by) { |i| … }` (and the `by:` / `to:` keyword forms) yields `Integer` when the receiver,
+      #   the limit and the step are all Integer; any other operand keeps the RBS `(Numeric)` binding
+      #   (`1.step(10, 0.5)` yields Floats). RBS declares every `Numeric#step` block as `(Numeric)`, which reports
+      #   `even?` on correct Integer loops (issue #1783); see {IntegerStepBlockParams}.
       # - `h.transform_keys(mapping) { |k| … }` yields the receiver's keys, a rule the RBS probe does not state for
       #   a union of receiver shapes ({HashTransformKeysFolding.block_param_types}).
       module IteratorDispatch
@@ -38,6 +43,7 @@ module Rigor
           when :times then times_block_params(receiver)
           when :upto  then upto_block_params(receiver, args.first)
           when :downto then downto_block_params(receiver, args.first)
+          when :step then IntegerStepBlockParams.block_param_types(receiver, args)
           when :each_with_index then each_with_index_block_params(receiver)
           when :each_with_object then each_with_object_block_params(receiver, args.first)
           when :inject, :reduce then inject_block_params(receiver, args)

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

@@ -0,0 +1,267 @@
+# frozen_string_literal: true
+
+require_relative "../../type"
+
+module Rigor
+  module Inference
+    module MethodDispatcher
+      # How `OverloadSelector` reads a call's keyword arguments (#1727).
+      #
+      # A call's arguments reach the selector as one positional list, the keyword hash (`f(a, k: 1)`) typed as its
+      # last entry. Only the AST tells it from a braced positional hash (`f(a, { k: 1 })`), so the caller says which
+      # it is (`keywords_last`). An overload that declares keywords takes that hash as its keywords; one that
+      # declares none reads it as a trailing positional `Hash`, as Ruby passes it.
+      module KeywordArguments
+        NO_PARAMS = [].freeze
+        private_constant :NO_PARAMS
+
+        # The most argument lists {.distributions} spells out; past it, the block probe answers no information.
+        DISTRIBUTION_LIMIT = 8
+        private_constant :DISTRIBUTION_LIMIT
+
+        module_function
+
+        # The actuals `method_type`'s positional parameters read: every argument, less the trailing keyword hash
+        # when the call passes one and the overload declares keywords to take it.
+        def positional(method_type, arg_types, keywords_last)
+          return arg_types unless keywords_last && !arg_types.empty? && declares?(method_type.type)
+
+          arg_types[0...-1]
+        end
+
+        # {.positional} for the selector's `shared` bundle, computed once per selection: every overload that takes the
+        # keyword hash reads the same trimmed list. A bundle rebuilt with other arguments must reset the cache.
+        def selection_positional(method_type, shared)
+          return shared[:arg_types] unless shared[:keywords_last] && declares?(method_type.type)
+
+          shared[:positional_arguments] ||= positional(method_type, shared[:arg_types], true)
+        end
+
+        # The argument lists a call with a keyword hash stands for, one per combination of the members of its
+        # union-typed keyword values (`headers: bool` stands for `headers: true` and `headers: false`, and so does a
+        # `Dynamic[bool]`, which the #521 join produces), or nil when that is more than {DISTRIBUTION_LIMIT} lists. A
+        # precise union value selects per member at runtime, so an answer that holds for the call must hold for every
+        # member (#1737). Only a key that discriminates between `method_types` ({.discriminating?}) splits (#1779):
+        # every overload reads any other key's members alike, so splitting it only multiplies the lists toward the
+        # limit (`(a: Symbol, b: Symbol)` with two three-member values made nine). An overload that declares no
+        # keywords but may take the hash as a positional `Hash` ({.positional_hash_reader?}, whose block says whether
+        # a positional parameter may accept a `Hash`) reads every value against that parameter, so then every union
+        # value splits. `count` is the call's argument count, nil when a splat hides it. Without a keyword hash, or
+        # with no discriminating union value, the one list, `arg_types` itself.
+        def distributions(arg_types, keywords_last, method_types, count = arg_types.size, &hash_param)
+          keywords = keywords_last && arg_types.last
+          return [arg_types] unless keywords.is_a?(Type::HashShape)
+
+          choices = split_choices(keywords, method_types) do
+            hash_param && positional_hash_reader?(method_types, count, &hash_param)
+          end
+          return [arg_types] if choices.nil?
+          return nil if choices.reduce(1) { |count, (_, members)| count * members.size } > DISTRIBUTION_LIMIT
+
+          combinations(choices).map do |pairs|
+            shape = Type::HashShape.new(
+              pairs, required_keys: keywords.required_keys, optional_keys: keywords.optional_keys,
+                     read_only_keys: keywords.read_only_keys, extra_keys: keywords.extra_keys
+            )
+            arg_types[0...-1] + [shape]
+          end
+        end
+
+        # Each key of `keywords` with the values its lists take: a discriminating union value's members, any other
+        # value whole. Nil when no value splits. The block answers whether every union value splits (read once).
+        def split_choices(keywords, method_types)
+          split = false
+          every = nil
+          choices = keywords.pairs.map do |name, value|
+            members = union_members(value)
+            next [name, [value]] unless members
+
+            unless discriminating?(name, method_types)
+              every = yield ? true : false if every.nil?
+              next [name, [value]] unless every
+            end
+
+            split = true
+            [name, members]
+          end
+          choices if split
+        end
+
+        # Whether the members of `name`'s value may select different overloads among `method_types`: the overloads
+        # that take the key (by name or through `**rest`) declare it with different types (`headers: true` in one,
+        # `?headers: false` in another). Where they all declare one type, a member it rejects is rejected by every
+        # overload, so the split only adds lists: four `flag: bool` keywords alone made sixteen. An overload that
+        # declares others but not this key rejects it whatever its value. One that declares no keywords reads the
+        # hash positionally, which {.positional_hash_reader?} decides for every key at once.
+        def discriminating?(name, method_types)
+          first = nil
+          method_types.any? do |method_type|
+            fun = method_type.type
+            next false unless declares?(fun)
+
+            type = (fun.required_keywords[name] || fun.optional_keywords[name] || fun.rest_keywords)&.type
+            next false if type.nil?
+
+            first ||= type
+            type != first
+          end
+        end
+
+        # Whether an overload of `method_types` that declares no keywords takes `count` arguments and may read the last,
+        # the keyword hash, as a positional `Hash`: the block answers for the RBS parameter at that position (the
+        # `(String)` of `(a: Symbol) | (String)` cannot take one, the `(Hash[Symbol, String])` of
+        # `(a: Integer) | (Hash[Symbol, String])` can, and its members then select per value), and an untyped `(?)`
+        # parameter list may take anything. A nil `count` (a splat hides how many arguments precede the hash, and
+        # `ph(*[], a: v)` passes `{ a: v }` to a one-parameter `(Hash)`) asks about every positional parameter.
+        def positional_hash_reader?(method_types, count, &)
+          method_types.any? do |method_type|
+            fun = method_type.type
+            next false if declares?(fun)
+            next true unless fun.respond_to?(:required_positionals)
+            next positional_params(fun).any?(&) if count.nil?
+
+            param = positional_param_at(fun, count, count - 1)
+            !param.nil? && yield(param)
+          end
+        end
+
+        def positional_params(fun)
+          params = fun.required_positionals + fun.optional_positionals + fun.trailing_positionals
+          fun.rest_positionals ? params + [fun.rest_positionals] : params
+        end
+
+        # The positional parameter `fun` binds the argument at `index` to when called with `count` arguments, or nil
+        # when the count does not fit its arity.
+        def positional_param_at(fun, count, index)
+          required = fun.required_positionals
+          trailing = fun.trailing_positionals
+          optional = fun.optional_positionals
+          minimum = required.size + trailing.size
+          return nil if count < minimum || (fun.rest_positionals.nil? && count > minimum + optional.size)
+          return required[index] if index < required.size
+          return trailing[index - (count - trailing.size)] if index >= count - trailing.size
+
+          optional[index - required.size] || fun.rest_positionals
+        end
+
+        # The members a keyword value splits into: a union's, or those of a `Dynamic` whose static facet is a union,
+        # less `nil`, which the #521 join usually carries from an arm no call takes (as `FacetDistribution` reads a
+        # facet). One member left stands in for the value (`Dynamic[false | nil]` reads as `false`), since the bare
+        # `Dynamic` would gradually match every overload's keyword. A plain union keeps `nil`: there it is a value
+        # the call may pass.
+        def union_members(value)
+          return value.members if value.is_a?(Type::Union)
+          return nil unless value.is_a?(Type::Dynamic) && value.static_facet.is_a?(Type::Union)
+
+          members = value.static_facet.members.reject { |member| nil_member?(member) }
+          members.empty? ? nil : members
+        end
+
+        def nil_member?(member)
+          return member.value.nil? if member.is_a?(Type::Constant)
+
+          member.is_a?(Type::Nominal) && member.class_name == "NilClass"
+        end
+
+        def combinations(choices)
+          choices.reduce([{}]) do |partials, (name, members)|
+            partials.flat_map { |partial| members.map { |member| partial.merge(name => member) } }
+          end
+        end
+
+        def declares?(fun)
+          return false unless fun.respond_to?(:required_keywords)
+
+          !fun.required_keywords.empty? || !fun.optional_keywords.empty? || !fun.rest_keywords.nil?
+        end
+
+        # The keyword hash `fun` takes as its keywords, or nil when the call passes none or `fun` declares none.
+        def keyword_hash(fun, arg_types, keywords_last)
+          return nil unless keywords_last && !arg_types.empty? && declares?(fun)
+
+          arg_types.last
+        end
+
+        # {.accepted?} for the selector's `shared` bundle: the keyword hash `fun` takes, if any, against its keywords.
+        def accepted_by?(fun, shared, strict, &)
+          accepted?(fun, keyword_hash(fun, shared[:arg_types], shared[:keywords_last]), strict, &)
+        end
+
+        def any_declares?(method_types) = method_types.any? { |method_type| declares?(method_type.type) }
+
+        # Issue #1800 — a keyword hash an overload declares and takes as its keywords is no positional argument of
+        # another. Both RBS (the first overload in declared order that takes the call) and Ruby (a method that accepts
+        # keywords binds `a: 1` to them) read `(a: Integer) -> Integer | (Object) -> String`'s `ob(a: 1)` as the
+        # keyword overload, but `ReceiverAffinity` moves `(Object)` first and the strict pass took it, reading the hash
+        # positionally. `matches` is a selection pass's answer for a call with a keyword hash; the block answers the
+        # keyword-declaring overloads' proven (`:yes`, every pair accepted with a `yes`) or gradual (`false`) matches.
+        # A `maybe` proves nothing: a source-only class is a `maybe` instance of every declared class, so
+        # `(a: Integer) | (Object)` would have taken `i(a: Bar.new)` as `Integer`. When one is proven, a
+        # positional reader declared after it is dropped. One declared before it is what RBS takes, while a method
+        # accepting keywords still binds them as keywords, so both stay and the caller joins their returns. A keyword
+        # overload that only gradually takes the hash (an unshaped `**opts`, an imprecise value) proves nothing either
+        # way, so it joins the positional readers rather than replace them.
+        def prefer_takers(declared, matches)
+          readers = matches.reject { |method_type| declares?(method_type.type) }
+          return matches if readers.empty?
+
+          takers = declared.select { |method_type| declares?(method_type.type) }
+          proven = yield(takers, :yes).first
+          unless proven
+            joined = matches | yield(takers, false)
+            return joined.size == matches.size ? matches : in_declared_order(declared, joined)
+          end
+
+          position = declared.index(proven)
+          earlier = readers.select { |method_type| declared.index(method_type) < position }
+          kept = matches.select { |method_type| declares?(method_type.type) }
+          in_declared_order(declared, kept | [proven] | earlier)
+        end
+
+        def in_declared_order(declared, method_types)
+          method_types.sort_by { |method_type| declared.index(method_type) }
+        end
+
+        # Whether `fun`'s keywords take `keywords` (nil for a call without a keyword hash). Without one, an
+        # overload that requires a keyword is not viable. With one, a closed shape must carry every required
+        # keyword, and every key it carries must be declared (or taken by `**rest`) with a value the block accepts
+        # against the declaration. An unshaped keyword hash (`f(**opts)` over a `Hash`) or a shape that may lack a
+        # required key is a gradual match only, never a strict one.
+        #
+        # @yieldparam param — the keyword's `RBS::Types::Function::Param`.
+        # @yieldparam value — the type the call passes for it.
+        def accepted?(fun, keywords, strict)
+          return true unless fun.respond_to?(:required_keywords)
+          return fun.required_keywords.empty? if keywords.nil?
+          return !strict unless keywords.is_a?(Type::HashShape)
+
+          required_present?(fun, keywords, strict) &&
+            keywords.pairs.all? do |name, value|
+              param = fun.required_keywords[name] || fun.optional_keywords[name] || fun.rest_keywords
+              !param.nil? && yield(param, value)
+            end
+        end
+
+        # The declarations the keys of the call's keyword hash land in, for the selector's `shared` bundle; empty
+        # without a shaped keyword hash `fun` takes (a key nothing declares lands nowhere).
+        def passed_params(fun, shared)
+          keywords = keyword_hash(fun, shared[:arg_types], shared[:keywords_last])
+          return NO_PARAMS unless keywords.is_a?(Type::HashShape)
+
+          keywords.pairs.each_key.filter_map do |name|
+            fun.required_keywords[name] || fun.optional_keywords[name] || fun.rest_keywords
+          end
+        end
+
+        def required_present?(fun, keywords, strict)
+          fun.required_keywords.each_key.all? do |name|
+            next true if keywords.pairs.key?(name) && !keywords.optional_key?(name)
+
+            # Possibly absent: an optional key, or a key an open shape may carry unseen.
+            !strict && (keywords.pairs.key?(name) || keywords.open?)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require_relative "../../source/symbol_name"
 require_relative "../../type"
 
 module Rigor
@@ -94,7 +95,7 @@ module Rigor
 
           case arg.value
           when Symbol then arg.value
-          when String then arg.value.to_sym
+          when String then Source::SymbolName.of(arg.value)
           end
         end
       end