rigortype 0.4.1 → 0.4.3

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

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+require_relative "../../type"
+
+module Rigor
+  module Inference
+    module MethodDispatcher
+      # `Integer#step`'s block parameter, reached through {IteratorDispatch.block_param_types} (issue #1783).
+      #
+      # `ruby/rbs` declares every `Numeric#step` overload with a `{ (Numeric) -> void }` block and `Integer` does
+      # not redeclare `step`, so `1.step(n, 2) { |i| i.even? }` reported `even?` on correct code. The block form
+      # yields Integer only while the limit and the step are Integer too: a Float step or a finite Float limit
+      # makes CRuby's `ruby_float_step` yield Floats (`1.step(10, 0.5)`, `1.step(10.0)`; an infinite limit with
+      # an Integer step still yields Integers, which this rule leaves on the RBS binding), and a Rational step yields
+      # Rationals after the first value. So:
+      #
+      # - every operand provably Integer (an absent one is the Integer default; a nil limit means "no limit")
+      #   binds `Integer`;
+      # - an operand that is `Dynamic` (an untyped parameter, `1.step(n, 2)`) could be either, so the binding is
+      #   `Dynamic[Numeric]`: Integer is unsound for `n = 0.5`, and the RBS `Numeric` reports `even?` on correct
+      #   Integer code, so the answer that holds for both declines the check;
+      # - anything else (a Float, a Rational, a union) falls through to the RBS `Numeric` binding, which a Float
+      #   or Rational receiver also keeps.
+      #
+      # The keyword forms (`step(by: 2, to: 10)`, `step(10, by: 2)`) arrive as a trailing hash shape.
+      module IntegerStepBlockParams
+        module_function
+
+        KEYWORD_ROLES = { to: :limit, by: :step }.freeze
+        private_constant :KEYWORD_ROLES
+
+        # @return the block-param types, or nil to fall through to the RBS tier.
+        def block_param_types(receiver, args)
+          element = element_type(receiver, args)
+          element && [element]
+        end
+
+        # The type of every value the call yields, or nil when the rule does not decide it. The block-less form
+        # shares it: the `Enumerator::ArithmeticSequence` it returns yields the same values as the block would,
+        # except past an infinite Float limit, which this rule already declines ({ArithmeticSequenceElements}).
+        def element_type(receiver, args)
+          return nil unless IteratorDispatch.integer_rooted?(receiver)
+
+          operands = operands(args)
+          return nil if operands.nil?
+
+          verdicts = operands.map { |role, type| verdict(role, type) }
+          return nil if verdicts.include?(:decline)
+          return Type::Combinator.nominal_of("Integer") if verdicts.all?(:integer)
+
+          Type::Combinator.dynamic(Type::Combinator.nominal_of("Numeric"))
+        end
+
+        # The `[role, type]` pairs of the call's limit and step operands, or nil when the argument list is not
+        # one of `step`'s shapes.
+        def operands(args)
+          positional = args
+          keywords = {}
+          if args.last.is_a?(Type::HashShape)
+            positional = args[0...-1]
+            keywords = args.last.pairs
+            return nil unless keywords.keys.all? { |key| KEYWORD_ROLES.key?(key) }
+          end
+          return nil if positional.size > 2
+
+          pairs = positional.zip(%i[limit step]).map { |type, role| [role, type] }
+          keywords.each { |key, type| pairs << [KEYWORD_ROLES.fetch(key), type] }
+          pairs
+        end
+
+        def verdict(role, type)
+          return :integer if IteratorDispatch.integer_rooted?(type)
+          return :integer if role == :limit && type.is_a?(Type::Constant) && type.value.nil?
+          return :unknown if type.is_a?(Type::Dynamic)
+
+          :decline
+        end
+      end
+    end
+  end
+end

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/kernel_dispatch.rb

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

data/lib/rigor/inference/method_dispatcher/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/match_data_folding.rb

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

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

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

data/lib/rigor/inference/method_dispatcher/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

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

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