rigortype 0.1.8 → 0.1.9

data/lib/rigor/inference/expression_typer.rb

@@ -1056,6 +1056,9 @@ module Rigor
         per_element = try_per_element_block_fold(node, receiver)
         return per_element if per_element
 
+        hash_transform = try_hash_shape_block_fold(node, receiver)
+        return hash_transform if hash_transform
+
         result = MethodDispatcher.dispatch(
           receiver_type: receiver,
           method_name: node.name,
@@ -1455,10 +1458,17 @@ module Rigor
       # the dispatch chain untouched.
       PER_ELEMENT_TUPLE_METHODS = Set[
         :map, :collect, :filter_map, :flat_map,
+        :select, :filter, :reject,
         :find, :detect, :find_index, :index
       ].freeze
       private_constant :PER_ELEMENT_TUPLE_METHODS
 
+      HASH_SHAPE_TRANSFORM_METHODS = Set[
+        :transform_keys, :transform_keys!,
+        :transform_values, :transform_values!
+      ].freeze
+      private_constant :HASH_SHAPE_TRANSFORM_METHODS
+
       # Cardinality cap for per-element block fold over
       # finite-bound `Constant<Range>` receivers. Walking
       # `(1..1_000_000).map { … }` element-wise would balloon
@@ -1475,15 +1485,50 @@ module Rigor
         element_types = per_element_elements_of(receiver_type)
         return nil if element_types.nil? || element_types.empty?
 
-        block_node = call_node.block
-        return nil unless block_node.is_a?(Prism::BlockNode)
+        per_position = per_element_block_results(call_node.block, element_types)
+        return nil if per_position.nil? || per_position.any?(&:nil?)
 
-        per_position = element_types.map do |element_type|
-          type_block_body_with_param(block_node, [element_type])
+        assemble_per_element_result(call_node.name, per_position, element_types)
+      end
+
+      # Evaluates the call's block once per receiver element.
+      # Two block shapes are supported:
+      #
+      # - `Prism::BlockNode` — a full `do … end` / `{ … }` block;
+      #   the body is re-typed per position with the element
+      #   bound to the block parameter.
+      # - `Prism::BlockArgumentNode` wrapping a `SymbolNode` —
+      #   the `&:predicate` shorthand; the symbol is dispatched
+      #   as a zero-arg method on each element type.
+      #
+      # Any other shape (`&proc_local`, `&method(:foo)`, no
+      # block) returns `nil` so the fold declines.
+      def per_element_block_results(block, element_types)
+        case block
+        when Prism::BlockNode
+          element_types.map { |element_type| type_block_body_with_param(block, [element_type]) }
+        when Prism::BlockArgumentNode
+          per_element_symbol_results(block, element_types)
         end
-        return nil if per_position.any?(&:nil?)
+      end
 
-        assemble_per_element_result(call_node.name, per_position, element_types)
+      def per_element_symbol_results(block_arg, element_types)
+        expression = block_arg.expression
+        return nil unless expression.is_a?(Prism::SymbolNode)
+
+        method_name = expression.unescaped.to_sym
+        element_types.map do |element_type|
+          MethodDispatcher.dispatch(
+            receiver_type: element_type,
+            method_name: method_name,
+            arg_types: [],
+            block_type: nil,
+            environment: scope.environment,
+            scope: scope
+          )
+        end
+      rescue StandardError
+        nil
       end
 
       # Returns the per-position element types for a finite,
@@ -1532,11 +1577,37 @@ module Rigor
         when :map, :collect then Type::Combinator.tuple_of(*per_position)
         when :filter_map then assemble_filter_map_result(per_position)
         when :flat_map then assemble_flat_map_result(per_position)
+        when :select, :filter
+          assemble_filter_result(per_position, element_types, keep_on_truthy: true)
+        when :reject
+          assemble_filter_result(per_position, element_types, keep_on_truthy: false)
         when :find, :detect then assemble_find_result(per_position, element_types)
         when :find_index, :index then assemble_find_index_result(per_position)
         end
       end
 
+      # `select` / `filter` / `reject`: keeps each receiver
+      # element whose per-position predicate result folds to a
+      # decisive `Constant` — Ruby-truthy for `select` / `filter`,
+      # Ruby-falsey for `reject`. The surviving elements assemble
+      # into a `Tuple`, strictly tighter than the RBS-projected
+      # `Array[Elem]`.
+      #
+      # Folds tightly only when EVERY position is a `Constant`:
+      # a single non-`Constant` position leaves the result
+      # cardinality unknown (the element might or might not
+      # survive), so the dispatcher declines and the RBS tier
+      # widens to `Array[Elem]`. `[].select` style empty results
+      # are sound — an empty `Tuple` is the empty-array carrier.
+      def assemble_filter_result(per_position, element_types, keep_on_truthy:)
+        return nil unless per_position.all?(Type::Constant)
+
+        kept = element_types.each_index.filter_map do |index|
+          element_types[index] if truthy_constant?(per_position[index]) == keep_on_truthy
+        end
+        Type::Combinator.tuple_of(*kept)
+      end
+
       # `filter_map` folds tightly only when every per-position
       # result is a `Constant`: positions whose value is `nil`
       # or `false` drop, the rest survive in declaration order.
@@ -1611,6 +1682,94 @@ module Rigor
         type.is_a?(Type::Constant) && type.value && type.value != false
       end
 
+      # Per-pair block fold for `HashShape#transform_keys` and
+      # `HashShape#transform_values` (and their bang variants).
+      #
+      # When the receiver is a closed `HashShape` with no optional
+      # keys, applies the call's block (a `Prism::BlockNode` or
+      # `Prism::BlockArgumentNode`) to each key/value pair
+      # independently and assembles a new `HashShape`:
+      #
+      # - `transform_values` / `transform_values!`: re-types
+      #   each VALUE by binding it to the block parameter; keys
+      #   are preserved unchanged.
+      # - `transform_keys` / `transform_keys!`: re-types each
+      #   KEY by wrapping it in `Constant[k]` and passing it to
+      #   the block; values are preserved unchanged. The result
+      #   key must be a `Constant[Symbol | String]` — otherwise
+      #   the tier declines (the new key cannot be used as a
+      #   static HashShape index). Collisions (two old keys
+      #   mapping to the same new key) also decline.
+      #
+      # Returns `nil` on any decline so the dispatcher falls
+      # through to `RbsDispatch` and gets the widened `Hash[K, V]`
+      # answer.
+      def try_hash_shape_block_fold(call_node, receiver_type)
+        return nil unless HASH_SHAPE_TRANSFORM_METHODS.include?(call_node.name)
+        return nil unless receiver_type.is_a?(Type::HashShape)
+        return nil unless receiver_type.closed?
+        return nil unless receiver_type.optional_keys.empty?
+
+        block_arg = call_node.block
+        return nil if block_arg.nil?
+
+        if %i[transform_values transform_values!].include?(call_node.name)
+          fold_hash_shape_transform_values(receiver_type, block_arg)
+        else
+          fold_hash_shape_transform_keys(receiver_type, block_arg)
+        end
+      end
+
+      def fold_hash_shape_transform_values(shape, block_arg)
+        new_pairs = {}
+        shape.pairs.each do |key, value|
+          new_value = apply_hash_block(block_arg, value)
+          return nil if new_value.nil?
+
+          new_pairs[key] = new_value
+        end
+        Type::Combinator.hash_shape_of(new_pairs)
+      end
+
+      def fold_hash_shape_transform_keys(shape, block_arg)
+        new_pairs = {}
+        shape.pairs.each do |key, value|
+          key_type = Type::Combinator.constant_of(key)
+          new_key_type = apply_hash_block(block_arg, key_type)
+          return nil unless new_key_type.is_a?(Type::Constant)
+
+          new_key = new_key_type.value
+          return nil unless new_key.is_a?(Symbol) || new_key.is_a?(String)
+          return nil if new_pairs.key?(new_key)
+
+          new_pairs[new_key] = value
+        end
+        Type::Combinator.hash_shape_of(new_pairs)
+      end
+
+      # Applies a single-argument block (either a full BlockNode
+      # or a `&:symbol` BlockArgumentNode) to `param_type` and
+      # returns the resulting type, or `nil` on failure.
+      def apply_hash_block(block_arg, param_type)
+        case block_arg
+        when Prism::BlockNode
+          type_block_body_with_param(block_arg, [param_type])
+        when Prism::BlockArgumentNode
+          expression = block_arg.expression
+          return nil unless expression.is_a?(Prism::SymbolNode)
+
+          MethodDispatcher.dispatch(
+            receiver_type: param_type,
+            method_name: expression.unescaped.to_sym,
+            arg_types: [],
+            block_type: nil,
+            environment: scope.environment,
+            call_node: block_arg,
+            scope: scope
+          )
+        end
+      end
+
       def type_block_body_with_param(block_node, expected_param_types)
         bindings = BlockParameterBinder.new(expected_param_types: expected_param_types).bind(block_node)
         block_scope = bindings.reduce(scope) { |acc, (name, type)| acc.with_local(name, type) }

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

@@ -0,0 +1,109 @@
+# frozen_string_literal: true
+
+require "cgi/util"
+require_relative "../../type"
+
+module Rigor
+  module Inference
+    module MethodDispatcher
+      # Folds `CGI` module-function calls on statically known
+      # string constants.
+      #
+      # `CGI.escapeHTML` / `CGI.unescapeHTML` and related methods
+      # are pure, deterministic functions over their string inputs.
+      # When the argument is a `Constant[String]`, the analyzer can
+      # evaluate the call at inference time and return the concrete
+      # `Constant[String]` result.
+      #
+      # === Supported methods
+      #
+      # * `escapeHTML(str)` / `escape_html(str)` / `h(str)` —
+      #   HTML-escape. Returns `Constant[String]`.
+      # * `unescapeHTML(str)` / `unescape_html(str)` —
+      #   HTML-unescape. Returns `Constant[String]`.
+      # * `escape(str)` / `unescape(str)` —
+      #   URL-encode / decode (`application/x-www-form-urlencoded`).
+      #   Returns `Constant[String]`.
+      # * `escapeURIComponent(str)` / `escape_uri_component(str)`,
+      #   `unescapeURIComponent(str)` / `unescape_uri_component(str)` —
+      #   URI-component percent-encode / decode. Returns `Constant[String]`.
+      # * `escapeElement(str, *elements)` / `escape_element(str, *elements)`,
+      #   `unescapeElement(str, *elements)` / `unescape_element(str, *elements)` —
+      #   element-level escape / unescape (first arg is the string,
+      #   remaining args are element names). Returns `Constant[String]`.
+      #
+      # === Non-constant / unsupported cases
+      #
+      # Returns `nil` (deferring to the next dispatcher tier) when:
+      # - the receiver is not `Singleton[CGI]`,
+      # - the first argument is not a `Constant[String]`,
+      # - the method is not in the supported set.
+      module CGIFolding
+        CGI_HTML_ESCAPE_METHODS = Set[:escapeHTML, :escape_html, :h].freeze
+        CGI_HTML_UNESCAPE_METHODS = Set[:unescapeHTML, :unescape_html].freeze
+        CGI_URL_ESCAPE_METHODS = Set[:escape, :unescape].freeze
+        CGI_URI_ESCAPE_METHODS = Set[
+          :escapeURIComponent, :escape_uri_component,
+          :unescapeURIComponent, :unescape_uri_component
+        ].freeze
+        CGI_ELEMENT_ESCAPE_METHODS = Set[
+          :escapeElement, :escape_element,
+          :unescapeElement, :unescape_element
+        ].freeze
+        CGI_ALL_ESCAPE_METHODS = (
+          CGI_HTML_ESCAPE_METHODS | CGI_HTML_UNESCAPE_METHODS |
+          CGI_URL_ESCAPE_METHODS | CGI_URI_ESCAPE_METHODS |
+          CGI_ELEMENT_ESCAPE_METHODS
+        ).freeze
+
+        private_constant :CGI_HTML_ESCAPE_METHODS, :CGI_HTML_UNESCAPE_METHODS,
+                         :CGI_URL_ESCAPE_METHODS, :CGI_URI_ESCAPE_METHODS,
+                         :CGI_ELEMENT_ESCAPE_METHODS, :CGI_ALL_ESCAPE_METHODS
+
+        module_function
+
+        # @return [Rigor::Type, nil] folded result, or nil to defer.
+        def try_dispatch(receiver:, method_name:, args:)
+          return nil unless dispatch_target?(receiver)
+          return nil unless CGI_ALL_ESCAPE_METHODS.include?(method_name)
+
+          fold_cgi_call(method_name, args)
+        end
+
+        def dispatch_target?(receiver)
+          receiver.is_a?(Type::Singleton) && receiver.class_name == "CGI"
+        end
+
+        def fold_cgi_call(method_name, args)
+          return nil if args.empty?
+          return nil unless args.first.is_a?(Type::Constant) && args.first.value.is_a?(String)
+
+          str = args.first.value
+
+          if CGI_ELEMENT_ESCAPE_METHODS.include?(method_name)
+            fold_cgi_element(method_name, str, args.drop(1))
+          else
+            Type::Combinator.constant_of(CGI.public_send(method_name, str))
+          end
+        rescue StandardError
+          nil
+        end
+
+        # `CGI.escapeElement(str, "elem1", "elem2", ...)` — element-
+        # level escape / unescape. The remaining args after the first
+        # must be `Constant[String]` element names.
+        def fold_cgi_element(method_name, str, element_args)
+          elements = element_args.map do |arg|
+            return nil unless arg.is_a?(Type::Constant) && arg.value.is_a?(String)
+
+            arg.value
+          end
+
+          Type::Combinator.constant_of(CGI.public_send(method_name, str, *elements))
+        rescue StandardError
+          nil
+        end
+      end
+    end
+  end
+end

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

@@ -48,11 +48,21 @@ module Rigor
       module ConstantFolding # rubocop:disable Metrics/ModuleLength
         module_function
 
-        NUMERIC_BINARY = Set[:+, :-, :*, :/, :%, :<, :<=, :>, :>=, :==, :!=, :<=>].freeze
-        STRING_BINARY  = Set[:+, :*, :==, :!=, :<, :<=, :>, :>=, :<=>].freeze
+        NUMERIC_BINARY = Set[
+          :+, :-, :*, :/, :%, :**, :&, :|, :^, :<<, :>>,
+          :<, :<=, :>, :>=, :==, :!=, :<=>,
+          :gcd, :lcm, :fdiv
+        ].freeze
+        STRING_BINARY  = Set[
+          :+, :*, :==, :!=, :<, :<=, :>, :>=, :<=>,
+          :start_with?, :end_with?, :include?,
+          :delete_prefix, :delete_suffix,
+          :match?, :index, :rindex, :center, :ljust, :rjust
+        ].freeze
         SYMBOL_BINARY  = Set[:==, :!=, :<=>, :<, :<=, :>, :>=].freeze
-        BOOL_BINARY    = Set[:&, :|, :^, :==, :!=].freeze
+        BOOL_BINARY    = Set[:&, :|, :^, :==, :!=, :===].freeze
         NIL_BINARY     = Set[:==, :!=].freeze
+        RATIONAL_BINARY = Set[:div, :modulo, :%, :remainder, :fdiv].freeze
 
         # v0.0.3 C — pure unary catalogue. Each method must:
         # - take zero arguments,
@@ -74,20 +84,23 @@ module Rigor
           :odd?, :even?, :zero?, :positive?, :negative?,
           :succ, :pred, :next, :abs, :magnitude,
           :bit_length, :to_s, :to_i, :to_int, :to_f,
+          :floor, :ceil, :round, :truncate, :chr,
           :inspect, :hash, :-@, :+@, :~
         ].freeze
         FLOAT_UNARY = Set[
           :zero?, :positive?, :negative?,
           :nan?, :finite?, :infinite?,
           :abs, :magnitude, :floor, :ceil, :round, :truncate,
+          :next_float, :prev_float,
           :to_s, :to_i, :to_int, :to_f,
           :inspect, :hash, :-@, :+@
         ].freeze
         STRING_UNARY = Set[
           :upcase, :downcase, :capitalize, :swapcase,
           :reverse, :length, :size, :bytesize,
-          :empty?, :strip, :lstrip, :rstrip, :chomp,
+          :empty?, :strip, :lstrip, :rstrip, :chomp, :chop,
           :to_s, :to_str, :to_sym, :intern,
+          :to_i, :to_f, :ord, :chr, :hex, :oct, :succ, :next,
           :inspect, :hash
         ].freeze
         SYMBOL_UNARY = Set[
@@ -97,6 +110,11 @@ module Rigor
         ].freeze
         BOOL_UNARY = Set[:!, :to_s, :inspect, :hash, :&, :|, :^].freeze
         NIL_UNARY  = Set[:nil?, :!, :to_s, :to_a, :to_h, :inspect, :hash].freeze
+        RATIONAL_UNARY = Set[
+          :zero?, :integer?, :real, :abs2,
+          :conj, :conjugate, :nonzero?
+        ].freeze
+        COMPLEX_UNARY = Set[:zero?, :nonzero?].freeze
 
         STRING_FOLD_BYTE_LIMIT = 4096
 
@@ -283,6 +301,18 @@ module Rigor
           pathname_lift = try_fold_pathname_unary(receiver_values, method_name)
           return pathname_lift if pathname_lift
 
+          regexp_lift = try_fold_regexp_array_unary(receiver_values, method_name)
+          return regexp_lift if regexp_lift
+
+          set_lift = try_fold_set_array_unary(receiver_values, method_name)
+          return set_lift if set_lift
+
+          integer_lift = try_fold_integer_array_unary(receiver_values, method_name)
+          return integer_lift if integer_lift
+
+          numeric_lift = try_fold_numeric_array_unary(receiver_values, method_name)
+          return numeric_lift if numeric_lift
+
           # Type-level allow check on every receiver. If one member's
           # type does not have the method in its allow list (e.g.
           # `Union[String, nil].nil?` — `:nil?` is not in
@@ -309,7 +339,7 @@ module Rigor
         # Only fires on a single-receiver Range with finite integer
         # endpoints; mixed unions fall through so the existing
         # union-of-Constants path keeps the rest of the arms.
-        RANGE_FOLD_METHODS = Set[:to_a, :first, :last, :min, :max, :count, :size, :length].freeze
+        RANGE_FOLD_METHODS = Set[:to_a, :first, :last, :min, :max, :count, :size, :length, :entries, :minmax].freeze
         RANGE_TO_A_LIMIT = 16
         private_constant :RANGE_FOLD_METHODS, :RANGE_TO_A_LIMIT
 
@@ -326,10 +356,11 @@ module Rigor
 
         def range_constant_unary(range, method_name)
           case method_name
-          when :to_a then range_to_a_tuple(range)
+          when :to_a, :entries then range_to_a_tuple(range)
           when :first, :min then range_endpoint_constant(range, :first)
           when :last, :max then range_endpoint_constant(range, :last)
           when :count, :size, :length then Type::Combinator.constant_of(range.to_a.size)
+          when :minmax then range_minmax_tuple(range)
           end
         end
 
@@ -348,6 +379,21 @@ module Rigor
           Type::Combinator.constant_of(edge == :first ? values.first : values.last)
         end
 
+        def range_minmax_tuple(range)
+          values = range.to_a
+          if values.empty?
+            return Type::Combinator.tuple_of(
+              Type::Combinator.constant_of(nil),
+              Type::Combinator.constant_of(nil)
+            )
+          end
+
+          Type::Combinator.tuple_of(
+            Type::Combinator.constant_of(values.first),
+            Type::Combinator.constant_of(values.last)
+          )
+        end
+
         def try_fold_binary_set(receiver_values, method_name, arg_values)
           string_lift = try_fold_string_array_binary(receiver_values, method_name, arg_values)
           return string_lift if string_lift
@@ -377,6 +423,30 @@ module Rigor
                          :STRING_ARRAY_BINARY_METHODS,
                          :STRING_ARRAY_LIFT_LIMIT
 
+        # `Constant<Regexp>#names` returns an Array of capture-group name
+        # strings. Lifted to a Tuple so downstream narrowing can project
+        # per-element types. The catalog classifies the C body as `:leaf`
+        # so it is safe to evaluate at fold time; no `$~` side effect.
+        REGEXP_ARRAY_UNARY_METHODS = Set[:names].freeze
+        private_constant :REGEXP_ARRAY_UNARY_METHODS
+
+        # `Constant<Set>#to_a` returns an Array of the set's elements.
+        # Ruby 3.2+ Set is C-implemented with a Hash as its backing store,
+        # so element ordering is deterministic (insertion order).
+        # The catalog marks `to_a` as `:dispatch` (it calls through to the
+        # internal hash), so this dedicated handler bypasses the catalog gate.
+        SET_ARRAY_UNARY_METHODS = Set[:to_a, :entries].freeze
+        private_constant :SET_ARRAY_UNARY_METHODS
+
+        # `Constant<Integer>#digits` returns the base-10 (or base-n with
+        # an argument — only the no-arg form is folded here) place
+        # values as a little-endian Array of Integers. Lifted to a
+        # Tuple so downstream rules see the precise per-position type.
+        # `digits` raises `Math::DomainError` on a negative receiver,
+        # so the negative case bails to the RBS tier.
+        INTEGER_ARRAY_UNARY_METHODS = Set[:digits].freeze
+        private_constant :INTEGER_ARRAY_UNARY_METHODS
+
         # v0.0.7 — `Constant<Pathname>` delegates to a curated set
         # of pure path-manipulation methods. Pathname is immutable
         # in Ruby (per its docstring) and the catalog classifies
@@ -446,6 +516,83 @@ module Rigor
           nil
         end
 
+        # `Constant<Regexp>#names` — lift the Array[String] of named-capture
+        # group names to a Tuple[Constant[String]…]. Safe to evaluate at fold
+        # time: the C body reads only the regexp's internal names table,
+        # writes no global state, and always returns an Array of frozen Strings.
+        def try_fold_regexp_array_unary(receiver_values, method_name)
+          return nil unless REGEXP_ARRAY_UNARY_METHODS.include?(method_name)
+          return nil unless receiver_values.size == 1
+
+          receiver = receiver_values.first
+          return nil unless receiver.is_a?(Regexp)
+
+          lift_array_result(receiver.public_send(method_name))
+        rescue StandardError
+          nil
+        end
+
+        # `Constant<Set>#to_a` / `#entries` — lift the Array of set elements
+        # to a Tuple[Constant[…]…] when every element is a foldable scalar.
+        # Ruby 3.2+ Set is C-implemented; element order is deterministic
+        # (insertion order), so the result is stable across invocations.
+        def try_fold_set_array_unary(receiver_values, method_name)
+          return nil unless SET_ARRAY_UNARY_METHODS.include?(method_name)
+          return nil unless receiver_values.size == 1
+
+          receiver = receiver_values.first
+          return nil unless receiver.is_a?(::Set)
+
+          lift_array_result(receiver.to_a)
+        rescue StandardError
+          nil
+        end
+
+        # `Constant<Integer>#digits` — lift the Array of base-10 place
+        # values to a Tuple[Constant[Integer]…]. Safe to evaluate at
+        # fold time: the C body is pure arithmetic. Negative receivers
+        # raise `Math::DomainError`; the fold declines so the RBS tier
+        # answers with `Array[Integer]`.
+        def try_fold_integer_array_unary(receiver_values, method_name)
+          return nil unless INTEGER_ARRAY_UNARY_METHODS.include?(method_name)
+          return nil unless receiver_values.size == 1
+
+          receiver = receiver_values.first
+          return nil unless receiver.is_a?(Integer)
+          return nil if receiver.negative?
+
+          lift_array_result(receiver.digits)
+        rescue StandardError
+          nil
+        end
+
+        # `Constant<Complex>#rect` / `#rectangular` — lifts `[real, imaginary]`
+        # to `Tuple[Constant[re], Constant[im]]`. Both components are always
+        # numeric (Integer or Float for literal complexes), so they satisfy
+        # `foldable_constant_value?`.
+        #
+        # `Constant<Complex>#polar` — lifts `[abs, arg]` to
+        # `Tuple[Constant[Float], Constant[Float]]`. Evaluated at fold time
+        # via `Complex#polar` (which calls `Math.hypot` and `Math.atan2`).
+        # Deterministic: reads only the receiver's real and imaginary parts.
+        #
+        # Rational receivers also support `rect` / `rectangular` / `polar`:
+        # `Rational(r,1).rect` → `[r, 0]`, `Rational(r,1).polar` → `[abs, arg]`.
+        NUMERIC_ARRAY_UNARY_METHODS = Set[:rect, :rectangular, :polar].freeze
+        private_constant :NUMERIC_ARRAY_UNARY_METHODS
+
+        def try_fold_numeric_array_unary(receiver_values, method_name)
+          return nil unless NUMERIC_ARRAY_UNARY_METHODS.include?(method_name)
+          return nil unless receiver_values.size == 1
+
+          receiver = receiver_values.first
+          return nil unless receiver.is_a?(Complex) || receiver.is_a?(Rational)
+
+          lift_array_result(receiver.public_send(method_name))
+        rescue StandardError
+          nil
+        end
+
         # `Constant<String>#split(arg)` / `#scan(arg)` — lift the
         # Array result to a Tuple when both sides are statically
         # known and the cardinality fits.
@@ -1101,6 +1248,8 @@ module Rigor
           when Symbol         then SYMBOL_UNARY
           when true, false    then BOOL_UNARY
           when nil            then NIL_UNARY
+          when Rational       then RATIONAL_UNARY
+          when Complex        then COMPLEX_UNARY
           else                     Set.new
           end
         end
@@ -1126,11 +1275,15 @@ module Rigor
         # have their own shape carriers; this method picks
         # the conservative envelope of "values that already
         # round-trip through `Type::Combinator.constant_of`".
+        FOLDABLE_CONSTANT_CLASSES = [
+          Integer, Float, Rational, Complex, String, Symbol,
+          Regexp, Pathname, ::Set, Date, Time,
+          TrueClass, FalseClass, NilClass
+        ].freeze
+        private_constant :FOLDABLE_CONSTANT_CLASSES
+
         def foldable_constant_value?(value)
-          case value
-          when Integer, Float, Rational, Complex, String, Symbol, Regexp, Pathname, true, false, nil then true
-          else false
-          end
+          FOLDABLE_CONSTANT_CLASSES.any? { |klass| value.is_a?(klass) }
         end
 
         def safe?(receiver_value, method_name, arg_value)
@@ -1150,6 +1303,7 @@ module Rigor
           when Symbol         then SYMBOL_BINARY
           when true, false    then BOOL_BINARY
           when nil            then NIL_BINARY
+          when Rational       then RATIONAL_BINARY
           else                     Set.new
           end
         end
@@ -1169,10 +1323,19 @@ module Rigor
           case method_name
           when :+ then string_concat_blow_up?(receiver_value, arg_value)
           when :* then string_repeat_blow_up?(receiver_value, arg_value)
+          when :center, :ljust, :rjust then string_pad_blow_up?(arg_value)
           else false
           end
         end
 
+        # `"x".center(width)` / `#ljust` / `#rjust` produce a string
+        # of `max(width, len)` characters. A literal `width` far
+        # larger than the receiver would materialise a huge Constant;
+        # cap it at the same byte limit the concat / repeat paths use.
+        def string_pad_blow_up?(arg_value)
+          arg_value.is_a?(Integer) && arg_value > STRING_FOLD_BYTE_LIMIT
+        end
+
         def string_concat_blow_up?(receiver_value, arg_value)
           arg_value.is_a?(String) &&
             receiver_value.bytesize + arg_value.bytesize > STRING_FOLD_BYTE_LIMIT

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

@@ -57,11 +57,63 @@ module Rigor
           return nil if receiver.nil?
           return try_array(args) if method_name == :Array
           return try_numeric_constructor(method_name, args) if NUMERIC_CONSTRUCTORS.key?(method_name)
-          return try_integer_from_refinement(args) if method_name == :Integer
+          return try_integer(args) if method_name == :Integer
+          return try_float(args) if method_name == :Float
 
           nil
         end
 
+        # `Kernel#Integer(arg)` / `Integer(arg, base)`. Two folding
+        # paths, tried in order:
+        #
+        # 1. A `Refined[String, predicate]` argument whose predicate
+        #    is a digit-only carrier narrows to `non-negative-int`
+        #    (see {try_integer_from_refinement}).
+        # 2. A `Constant` String or Numeric argument — optionally
+        #    with a `Constant[Integer]` base — runs the actual
+        #    `Integer()` conversion and lifts the result to
+        #    `Constant[Integer]`.
+        def try_integer(args)
+          refined = try_integer_from_refinement(args)
+          return refined if refined
+
+          try_integer_constant(args)
+        end
+
+        # Constant-folding path for `Integer()`. A non-parseable
+        # string raises `ArgumentError` (or `TypeError` for a base
+        # against a non-string) at fold time; the handler declines
+        # so the RBS tier answers with the widened `Integer`.
+        def try_integer_constant(args)
+          return nil unless [1, 2].include?(args.size)
+          return nil unless args.all?(Type::Constant)
+
+          values = args.map(&:value)
+          return nil unless values[0].is_a?(String) || values[0].is_a?(Numeric)
+          return nil if values.size == 2 && !values[1].is_a?(Integer)
+
+          Type::Combinator.constant_of(Integer(*values))
+        rescue ArgumentError, TypeError
+          nil
+        end
+
+        # `Kernel#Float(arg)` — folds a `Constant` String or Numeric
+        # argument to `Constant[Float]`. A non-parseable string
+        # raises `ArgumentError` at fold time; the handler declines.
+        def try_float(args)
+          return nil unless args.size == 1
+
+          arg = args.first
+          return nil unless arg.is_a?(Type::Constant)
+
+          value = arg.value
+          return nil unless value.is_a?(String) || value.is_a?(Numeric)
+
+          Type::Combinator.constant_of(Float(value))
+        rescue ArgumentError, TypeError
+          nil
+        end
+
         # `Kernel#Integer(s)` over a `Refined[String, predicate]`
         # whose predicate is in {INTEGER_REFINEMENT_PREDICATES}.
         # Mirrors the `String#to_i` projection in `ShapeDispatch`