rigortype 0.3.8 → 0.4.0

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

@@ -0,0 +1,191 @@
+# frozen_string_literal: true
+
+require_relative "../../type"
+
+module Rigor
+  module Inference
+    module MethodDispatcher
+      # `Hash#transform_keys(mapping)` return type, with or without a block.
+      #
+      # CRuby's `transform_keys_hash_i` looks each old key up in the mapping with `rb_hash_lookup2`, which
+      # ignores a default. A hit takes the mapping's value as the new key and never reaches the block. A miss
+      # yields the old key to the block, or keeps it when no block is given. The new key type is therefore the
+      # mapping's value type joined with the block's return type, or with the receiver's key type when there is
+      # no block. The values are the receiver's, untouched.
+      #
+      # Neither RBS line says that. rbs 4.2 declares `[K2] (hash[_Key, K2] replacements) { (K old_key) -> K2 }
+      # -> Hash[K2, V]`, and {RbsDispatch} leaves `K2` untyped because the mapping and the block both decide it.
+      # The blockless `[K2] (hash[_Key, K2]) -> Hash[K | K2, V]` leaves `K2` unbound too. rbs 3.x declares no
+      # mapping overload at all; `data/core_overlay/hash_rbs3.rbs` supplies rbs 4.2's on that line, with the same gaps.
+      # This tier answers ahead of both, so the forms it accepts get one answer on either RBS line.
+      #
+      # A mapping the analysis cannot read contributes a `Dynamic[top]` key arm instead of nothing. That covers an
+      # untyped argument, a `to_hash`-convertible object, a Hash subclass, the unlisted entries of an open shape,
+      # and an empty closed shape, which is what a mapping filled through an alias the engine does not track still
+      # reads as. A block the call carries but the block pass could not type contributes `Dynamic[top]` too. A
+      # literal with a `**splat` entry needs no arm of its own: its type joins the splatted hash's pairs and a
+      # `Dynamic[top]` arm, which also keeps a copy the code writes into (`m = { **o }; m[:b] = :w`) growing. A
+      # non-empty shape filled through an alias still reads narrower than it is: that is a gap in the binding's
+      # own type.
+      #
+      # Declines, leaving the RBS answer, when:
+      #
+      # - the method is not `transform_keys`. `transform_keys!` returns `self` and stays with RBS.
+      # - the argument count is not one, or is unknown with no block. A `*splat`, a forwarded `...`, or a lone
+      #   `**splat` may pass no argument, and with no block that call answers an `Enumerator`. With a block, the
+      #   call is the block form or the mapping form, and a `Dynamic[top]` mapping arm covers both.
+      # - a receiver member is not a `Hash` carrier: a `HashShape` other than the empty closed one, a `Hash`
+      #   nominal, or a difference over one (`non-empty-hash[K, V]`). A subclass may override the method
+      #   (`ActiveSupport::HashWithIndifferentAccess` does), and an empty closed shape answers `{}` whatever the
+      #   mapping says.
+      module HashTransformKeysFolding
+        module_function
+
+        def try_dispatch(context)
+          return nil unless context.method_name == :transform_keys
+
+          block = block_arm(context)
+          renamed = mapping_arm(context, block)
+          return nil if renamed.nil?
+
+          receiver = context.receiver
+          members = receiver.is_a?(Type::Union) ? receiver.members : [receiver]
+          answers = members.map { |member| answer_for(member, renamed, block) }
+          return nil if answers.any?(&:nil?)
+
+          Type::Combinator.union(*answers)
+        end
+
+        # The mapping form's block parameter: the receiver's key type, as rbs 4.2's `{ (K old_key) -> K2 }`
+        # declares it, and as `data/core_overlay/hash_rbs3.rbs` restates it on the rbs 3.x line. The RBS probe
+        # does not bind it for a union of receiver shapes. Reached through {IteratorDispatch.block_param_types};
+        # nil falls through to the RBS probe.
+        def block_param_types(context)
+          return nil unless context.args.size == 1
+
+          receiver = context.receiver
+          members = receiver.is_a?(Type::Union) ? receiver.members : [receiver]
+          keys = members.map { |member| receiver_key_value(member)&.first }
+          return nil if keys.any?(&:nil?)
+
+          [Type::Combinator.union(*keys)]
+        end
+
+        # `Hash[unmapped | renamed, V]` for one receiver member, or nil when the member is not a `Hash` carrier.
+        def answer_for(receiver, renamed, block)
+          key_value = receiver_key_value(receiver)
+          return nil if key_value.nil?
+
+          key, value = key_value
+          new_key = Type::Combinator.union(block || key, renamed)
+          Type::Combinator.nominal_of("Hash", type_args: [new_key, value])
+        end
+
+        # The receiver's `[K, V]`, projected the way {RbsDispatch} projects a shape, or nil when the receiver
+        # is not a `Hash` carrier. An open shape may hold entries it does not list, so its key and value take
+        # a `Dynamic[top]` arm.
+        def receiver_key_value(receiver)
+          case receiver
+          when Type::HashShape then shape_key_value(receiver)
+          when Type::Nominal then nominal_key_value(receiver)
+          when Type::Difference then receiver_key_value(receiver.base)
+          end
+        end
+
+        def shape_key_value(shape)
+          return nil if shape.pairs.empty? && shape.closed?
+
+          key = Type::Combinator.union(*shape.pairs.keys.map { |k| Type::Combinator.constant_of(k) })
+          value = Type::Combinator.union(*shape.pairs.values)
+          return [key, value] if shape.closed?
+
+          [Type::Combinator.union(key, unknown), Type::Combinator.union(value, unknown)]
+        end
+
+        def nominal_key_value(nominal)
+          return nil unless nominal.class_name == "Hash"
+          return [unknown, unknown] unless nominal.type_args.size == 2
+
+          nominal.type_args
+        end
+
+        # The new keys the mapping supplies, or nil when the call is not one this tier answers (see the module
+        # comment for the argument-count rule).
+        def mapping_arm(context, block)
+          arguments = argument_nodes(context.call_node)
+          return block.nil? ? nil : unknown if unresolved_argument_count?(arguments)
+          return nil unless context.args.size == 1
+
+          mapping_value_type(context.args.first)
+        end
+
+        # The mapping's value type. Anything whose value type cannot be read contributes `Dynamic[top]`,
+        # including a member that is not a Hash at all (`to_hash` may still convert it, and a `TypeError` for one
+        # that cannot is not this tier's to report).
+        def mapping_value_type(mapping)
+          case mapping
+          when Type::HashShape then shape_value_type(mapping)
+          when Type::Nominal then nominal_value_type(mapping)
+          when Type::Difference then mapping_value_type(mapping.base)
+          when Type::Union then Type::Combinator.union(*mapping.members.map { |member| mapping_value_type(member) })
+          else unknown
+          end
+        end
+
+        # An empty closed shape contributes `Dynamic[top]`, not `bot`: the engine records no aliasing, so
+        # `m = {}; m.tap { |x| x[:a] = :z }` still reads `{}` after the store, and a `bot` arm would drop `:z`.
+        # A non-empty shape filled through an alias has the same gap, which this rule does not close.
+        def shape_value_type(shape)
+          return unknown if shape.pairs.empty? && shape.closed?
+
+          value = Type::Combinator.union(*shape.pairs.values)
+          shape.closed? ? value : Type::Combinator.union(value, unknown)
+        end
+
+        def nominal_value_type(nominal)
+          return unknown unless nominal.class_name == "Hash" && nominal.type_args.size == 2
+
+          nominal.type_args[1]
+        end
+
+        # The block's return type; `Dynamic[top]` when the call carries a block the block pass left untyped (it
+        # rescues to nil); nil when there is no block, so the unmapped keys keep the receiver's key type. `&nil`
+        # passes no block, whatever type the block pass gave it.
+        def block_arm(context)
+          block_node = context.call_node.is_a?(Prism::CallNode) ? context.call_node.block : nil
+          return nil if block_node.is_a?(Prism::BlockArgumentNode) && block_node.expression.is_a?(Prism::NilNode)
+          return context.block_type if context.block_type
+
+          block_node ? unknown : nil
+        end
+
+        # The call's argument nodes, or an empty list for a nil or non-call node (an internal caller, whose
+        # argument types are authoritative).
+        def argument_nodes(call_node)
+          return EMPTY_ARGUMENTS unless call_node.is_a?(Prism::CallNode)
+
+          call_node.arguments&.arguments || EMPTY_ARGUMENTS
+        end
+
+        EMPTY_ARGUMENTS = [].freeze
+        private_constant :EMPTY_ARGUMENTS
+
+        # A `*splat`, a forwarded `...`, or keyword arguments made only of `**splat` entries: each may pass no
+        # argument at all (`transform_keys(**{})` passes none), so whether there is a mapping is not static.
+        def unresolved_argument_count?(arguments)
+          arguments.any? do |argument|
+            case argument
+            when Prism::SplatNode, Prism::ForwardingArgumentsNode then true
+            when Prism::KeywordHashNode then argument.elements.all?(Prism::AssocSplatNode)
+            else false
+            end
+          end
+        end
+
+        def unknown
+          Type::Combinator.untyped
+        end
+      end
+    end
+  end
+end

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

@@ -2,6 +2,7 @@
 
 require_relative "../../type"
 require_relative "singleton_folding"
+require_relative "hash_transform_keys_folding"
 
 module Rigor
   module Inference
@@ -16,16 +17,18 @@ module Rigor
       # Each rule mirrors Ruby's actual iteration semantics:
       #
       # - `n.times { |i| … }` yields `i ∈ [0, n-1]` when `n > 0`, nothing otherwise. The block-param type is
-      #   therefore `int<0, n-1>` for a `Constant<Integer>` receiver, `int<0, upper-1>` for a finite
+      #   therefore `Integer[0..n-1]` for a `Constant<Integer>` receiver, `Integer[0..upper-1]` for a finite
       #   `IntegerRange`, and `non_negative_int` for any unbounded-above shape.
       # - `a.upto(b) { |i| … }` yields `i ∈ [a, b]` when `a <= b`. Lower bound from the receiver, upper
       #   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.
+      # - `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
         module_function
 
-        # @return [Array<Rigor::Type>, nil] block-param types, or
+        # @return block-param types, or
         #   nil to fall through to the next tier.
         def block_param_types(context)
           receiver = context.receiver
@@ -41,6 +44,7 @@ module Rigor
           when :group_by, :partition then single_element_block_params(receiver)
           when :each_slice, :each_cons then slice_block_params(receiver)
           when :new then class_new_block_params(receiver, args)
+          when :transform_keys then HashTransformKeysFolding.block_param_types(context)
           end
         end
 

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

@@ -41,7 +41,7 @@ module Rigor
 
         module_function
 
-        # @return [Rigor::Type, nil] folded result, or nil to defer.
+        # @return folded result, or nil to defer.
         def try_dispatch(context)
           receiver = context.receiver
           method_name = context.method_name

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

@@ -2,6 +2,7 @@
 
 require_relative "../../type"
 require_relative "constant_folding"
+require_relative "random_folding"
 
 module Rigor
   module Inference
@@ -43,7 +44,7 @@ module Rigor
         # every entry is spelling-parity checked. Public (not private_constant) and Ractor-shareable
         # because the gate and the spec both read it.
         INTRINSIC_NAMES = Ractor.make_shareable(
-          Set[:Array, :Integer, :Float, :Rational, :Complex, :p, :pp, :String, :Hash, :format, :sprintf]
+          Set[:Array, :Integer, :Float, :Rational, :Complex, :p, :pp, :String, :Hash, :format, :sprintf, :rand]
         )
 
         # `Kernel#Rational` / `Kernel#Complex` constructor folds. When every argument is a `Type::Constant`
@@ -101,6 +102,11 @@ module Rigor
           return try_string(context) if method_name == :String
           return try_hash(context) if method_name == :Hash
           return try_format(context) if FORMAT_METHODS.include?(method_name)
+          # ADR-109 / #833 — `Kernel#rand(a..b)` lands in the literal range, a bounded carrier of the
+          # range's own class (never a constant: the generator advances). The other argument shapes
+          # stay unfolded on purpose; {RandomFolding} owns the `Random.rand` spelling and the reading.
+          # A splat still declines: the reading needs exactly one literal-Range argument.
+          return RandomFolding.interval_for_args(args) if method_name == :rand
 
           nil
         end

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

@@ -0,0 +1,159 @@
+# frozen_string_literal: true
+
+require_relative "../../type"
+require_relative "regexp_folding"
+
+module Rigor
+  module Inference
+    module MethodDispatcher
+      # Issue #1381 — slice reads of the proven `$~`. On a proven-match edge the flow engine narrows `$~` to
+      # `MatchData` and each unconditional group's `$N` to `String` (see `Narrowing#regex_match_predicate_scopes`).
+      # The Integer overload of RBS `MatchData#[]` already reads `String`, but the Range and `(start, length)`
+      # overloads and `values_at` read `Array[String?]`, and destructuring that binds every slot `String?`.
+      # This tier answers those reads with a Tuple, one slot per group, using the rule
+      # {RegexpFolding.fold_last_match_group} applies to `Regexp.last_match(N)`: `String` when `$N` is bound,
+      # `String?` when it is not (an optional or alternation-reachable group is nil on a successful match).
+      # Index 0 is the whole match, always a `String`.
+      #
+      # Supported, all with compile-time constant Integer arguments:
+      #
+      # * `$~[a..b]` / `$~[a...b]`
+      # * `$~[start, length]`
+      # * `$~.values_at(i, j, ...)`
+      #
+      # The receiver must be the `$~` read itself or a no-argument `Regexp.last_match`: a local MatchData carries
+      # no group facts, and the scope's `$N` describe only the frame's current match.
+      #
+      # The scope does not record the regex's group count, and a slice past the last group is shorter than the
+      # range asked for (`$~[1..3]` on a one-group match is `["x"]`) while `values_at` pads with nil. The highest
+      # bound `$K` is a lower bound on the count — `Scope#join_bindings` keeps a key only when both sides bind
+      # it — so every index must be at most K. Declines (RBS answers) when:
+      #
+      # - `$~` is not proven non-nil, or no scope is threaded through,
+      # - no `$1`..`$9` narrows to `String` (every group optional, no group at all, `when /a/, /b/`),
+      # - any index is above K, negative, or not a constant Integer, or a Range bound is nil (endless /
+      #   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.
+      module MatchDataFolding
+        MAX_GROUP_GLOBAL = 9
+        private_constant :MAX_GROUP_GLOBAL
+
+        module_function
+
+        # @return folded Tuple, or nil to defer.
+        def try_dispatch(context)
+          receiver = context.receiver
+          return nil unless receiver.is_a?(Type::Nominal) && receiver.class_name == "MatchData"
+
+          scope = context.scope
+          return nil if scope.nil?
+          return nil unless last_match_read?(context.call_node, scope)
+          return nil unless RegexpFolding.proven_match?(scope.global(:$~))
+
+          highest = highest_bound_group(scope)
+          return nil if highest.nil?
+
+          indices = slot_indices(context.method_name, context.args, highest)
+          return nil if indices.nil?
+
+          Type::Combinator.tuple_of(*indices.map { |index| slot_type(index, scope) })
+        end
+
+        # The receiver expression reads the frame's current match: `$~`, or `last_match` with no arguments and no block
+        # on an expression that types as the core `Regexp` class. A project class that happens to be named `Regexp`
+        # (`Foo::Regexp` read as `Regexp` inside `module Foo`) types as its own singleton and does not count.
+        def last_match_read?(call_node, scope)
+          return false unless call_node.is_a?(Prism::CallNode)
+
+          receiver = call_node.receiver
+          case receiver
+          when Prism::GlobalVariableReadNode
+            receiver.name == :$~
+          when Prism::CallNode
+            receiver.name == :last_match && receiver.arguments.nil? && receiver.block.nil? &&
+              regexp_class?(receiver.receiver, scope)
+          else
+            false
+          end
+        end
+
+        def regexp_class?(node, scope)
+          return false if node.nil?
+
+          type = scope.type_of(node)
+          type.is_a?(Type::Singleton) && type.class_name == "Regexp"
+        end
+
+        # The highest N in 1..9 whose `$N` is narrowed to `String`, or nil when none is.
+        def highest_bound_group(scope)
+          MAX_GROUP_GLOBAL.downto(1).find { |index| string_global?(scope.global(:"$#{index}")) }
+        end
+
+        def string_global?(type)
+          type.is_a?(Type::Nominal) && type.class_name == "String"
+        end
+
+        # The group indices the call reads, in result order, or nil when the call shape is not folded or any index
+        # falls outside `0..highest`.
+        def slot_indices(method_name, args, highest)
+          indices =
+            case method_name
+            when :[] then index_slice(args)
+            when :values_at then values_at_indices(args)
+            end
+          return nil if indices.nil? || indices.none?
+          return nil unless indices.all? { |index| index.between?(0, highest) }
+
+          indices.to_a
+        end
+
+        # `[range]` or `[start, length]`. A single Integer index is left to RBS, which already reads `String`.
+        def index_slice(args)
+          case args.size
+          when 1 then range_indices(args.first)
+          when 2 then start_length_indices(*args)
+          end
+        end
+
+        def range_indices(arg)
+          range = constant_value(arg)
+          return nil unless range.is_a?(Range)
+
+          first = range.begin
+          last = range.end
+          return nil unless first.is_a?(Integer) && last.is_a?(Integer)
+          return nil if first.negative? || last.negative?
+
+          range
+        end
+
+        def start_length_indices(start_arg, length_arg)
+          start = constant_value(start_arg)
+          length = constant_value(length_arg)
+          return nil unless start.is_a?(Integer) && length.is_a?(Integer)
+          return nil if start.negative? || length.negative?
+
+          start...(start + length)
+        end
+
+        def values_at_indices(args)
+          indices = args.map { |arg| constant_value(arg) }
+          indices.all?(Integer) ? indices : nil
+        end
+
+        def constant_value(type)
+          type.is_a?(Type::Constant) ? type.value : nil
+        end
+
+        def slot_type(index, scope)
+          return Type::Combinator.nominal_of("String") if index.zero?
+
+          RegexpFolding.fold_last_match_group(Type::Combinator.constant_of(index), scope)
+        end
+      end
+    end
+  end
+end

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

@@ -44,11 +44,23 @@ module Rigor
         MATH_BINARY = Set[:atan2, :hypot, :ldexp].freeze
         MATH_TUPLE_UNARY = Set[:frexp, :lgamma].freeze
 
-        private_constant :MATH_UNARY, :MATH_BINARY, :MATH_TUPLE_UNARY
+        # ADR-109 — the monotone non-decreasing functions, each with the inclusive lower edge of its
+        # domain (`nil` for every real). Over a bounded argument the image is the closed range between the
+        # images of the bounds: `Math.sqrt(Integer[0..])` is `Float[0.0..]`, `Math.exp(Float[..0.0])` is
+        # `Float[0.0..1.0]`. A bound below the domain edge raises at run time for the value that reaches
+        # it, so the fold declines. Not listed: the non-monotone functions (`sin`, `cos`, `tan`, `gamma`,
+        # `erfc` decreases, `acos` decreases) and the ones whose image needs a sign split.
+        MATH_MONOTONE_DOMAIN = {
+          sqrt: 0.0, cbrt: nil, exp: nil, expm1: nil,
+          log: 0.0, log2: 0.0, log10: 0.0, log1p: -1.0,
+          atan: nil, sinh: nil, tanh: nil, asinh: nil, erf: nil
+        }.freeze
+
+        private_constant :MATH_UNARY, :MATH_BINARY, :MATH_TUPLE_UNARY, :MATH_MONOTONE_DOMAIN
 
         module_function
 
-        # @return [Rigor::Type, nil] folded result, or nil to defer.
+        # @return folded result, or nil to defer.
         def try_dispatch(context)
           receiver = context.receiver
           method_name = context.method_name
@@ -77,13 +89,38 @@ module Rigor
           return nil unless args.size == 1
 
           x = numeric_constant(args.first)
-          return nil if x.nil?
+          return fold_monotone_range(method_name, args.first) if x.nil?
 
           fold_float_result(Math.public_send(method_name, x))
         rescue Math::DomainError, RangeError
           nil
         end
 
+        # The bounded-argument arm of {fold_unary} / {fold_log}: an `IntegerRange` or `FloatRange`
+        # argument to a monotone function folds to the range between the images of its bounds.
+        def fold_monotone_range(method_name, arg)
+          return nil unless MATH_MONOTONE_DOMAIN.key?(method_name)
+
+          lower, upper = range_bounds(arg)
+          return nil if lower.nil?
+
+          edge = MATH_MONOTONE_DOMAIN[method_name]
+          return nil if edge && lower < edge
+
+          Type::Combinator.float_range(Math.public_send(method_name, lower), Math.public_send(method_name, upper))
+        rescue Math::DomainError, RangeError, ArgumentError
+          nil
+        end
+
+        # `[lower, upper]` as doubles for a bounded numeric carrier, `nil` for anything else. An
+        # exclusive Float end reads as its canonical closed bound, one double below.
+        def range_bounds(arg)
+          case arg
+          when Type::FloatRange then [arg.min, arg.canonical_max]
+          when Type::IntegerRange then [arg.lower.to_f, arg.upper.to_f]
+          end
+        end
+
         def fold_binary(method_name, args)
           return nil unless args.size == 2
 
@@ -101,6 +138,7 @@ module Rigor
           return nil unless [1, 2].include?(args.size)
 
           values = args.map { |a| numeric_constant(a) }
+          return fold_monotone_range(:log, args.first) if args.size == 1 && values.first.nil?
           return nil if values.any?(&:nil?)
 
           fold_float_result(Math.log(*values))

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

@@ -29,11 +29,8 @@ module Rigor
         # `.method("name")` with a precisely-known Symbol / String argument. Declines on every other shape
         # so the RBS tier still answers `Method` for non-folding cases.
         #
-        # @param receiver [Rigor::Type] caller's receiver
-        # @param method_name [Symbol] the method being dispatched on `receiver` — only `:method` triggers
-        #   the fold.
-        # @param args [Array<Rigor::Type>] caller's argument types in order. Only the single-argument case
-        #   matches; other arities decline.
+        # Reads `context.receiver`, `context.method_name` (only `:method` triggers the fold) and `context.args`
+        # (only the single-argument case matches; other arities decline).
         def try_dispatch(context)
           receiver = context.receiver
           method_name = context.method_name