rigortype 0.1.8 → 0.1.9

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

@@ -0,0 +1,149 @@
+# frozen_string_literal: true
+
+require_relative "../../type"
+
+module Rigor
+  module Inference
+    module MethodDispatcher
+      # Folds `Math` module-function calls on statically known numeric
+      # constants.
+      #
+      # `Math` is a pure, side-effect-free module whose functions are
+      # deterministic over their inputs — the same number always
+      # produces the same result. When every relevant argument is a
+      # `Constant` carrying a `Numeric` value, the analyzer evaluates
+      # the call at inference time and returns the concrete result.
+      #
+      # === Supported methods
+      #
+      # * Single-argument transcendental functions (`sqrt`, `cbrt`,
+      #   `exp`, `log2`, `log10`, `log1p`, `expm1`, `sin`, `cos`,
+      #   `tan`, `asin`, `acos`, `atan`, `sinh`, `cosh`, `tanh`,
+      #   `asinh`, `acosh`, `atanh`, `erf`, `erfc`, `gamma`) — return
+      #   `Constant[Float]`.
+      #
+      # * Two-argument functions (`atan2`, `hypot`, `ldexp`) — return
+      #   `Constant[Float]`.
+      #
+      # * `log(x)` / `log(x, base)` — variadic; folds the 1- and
+      #   2-argument forms to `Constant[Float]`.
+      #
+      # * `frexp(x)` / `lgamma(x)` — return a two-element array, lifted
+      #   to `Tuple[Constant[Float], Constant[Integer]]`.
+      #
+      # === Non-constant / unsupported cases
+      #
+      # Any call where the receiver is not `Singleton[Math]`, an
+      # argument is not a numeric `Constant`, the method is not in the
+      # supported set, or the Ruby call raises `Math::DomainError` /
+      # `RangeError` (domain-error inputs like `Math.sqrt(-1)`) returns
+      # `nil`, deferring to the next dispatcher tier.
+      #
+      # An infinite or NaN result (`Math.log(0.0)` → `-Infinity`) is
+      # still folded — `Constant[Float]` carries those values, matching
+      # `ConstantFolding`'s treatment of `Float / 0`.
+      module MathFolding
+        MATH_UNARY = Set[
+          :sqrt, :cbrt, :exp, :log2, :log10, :log1p, :expm1,
+          :sin, :cos, :tan, :asin, :acos, :atan,
+          :sinh, :cosh, :tanh, :asinh, :acosh, :atanh,
+          :erf, :erfc, :gamma
+        ].freeze
+        MATH_BINARY = Set[:atan2, :hypot, :ldexp].freeze
+        MATH_TUPLE_UNARY = Set[:frexp, :lgamma].freeze
+
+        private_constant :MATH_UNARY, :MATH_BINARY, :MATH_TUPLE_UNARY
+
+        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)
+
+          # `log` is variadic (1 or 2 args), so it cannot live in the
+          # fixed-arity sets above.
+          return fold_log(args) if method_name == :log
+          return fold_unary(method_name, args) if MATH_UNARY.include?(method_name)
+          return fold_binary(method_name, args) if MATH_BINARY.include?(method_name)
+          return fold_tuple_unary(method_name, args) if MATH_TUPLE_UNARY.include?(method_name)
+
+          nil
+        end
+
+        def dispatch_target?(receiver)
+          receiver.is_a?(Type::Singleton) && receiver.class_name == "Math"
+        end
+
+        # Unwraps a numeric `Constant` argument to its Ruby value.
+        # Returns nil for any non-`Constant` or non-`Numeric` carrier.
+        def numeric_constant(arg)
+          return nil unless arg.is_a?(Type::Constant)
+
+          value = arg.value
+          value.is_a?(Numeric) ? value : nil
+        end
+
+        def fold_unary(method_name, args)
+          return nil unless args.size == 1
+
+          x = numeric_constant(args.first)
+          return nil if x.nil?
+
+          fold_float_result(Math.public_send(method_name, x))
+        rescue Math::DomainError, RangeError
+          nil
+        end
+
+        def fold_binary(method_name, args)
+          return nil unless args.size == 2
+
+          a = numeric_constant(args[0])
+          b = numeric_constant(args[1])
+          return nil if a.nil? || b.nil?
+
+          fold_float_result(Math.public_send(method_name, a, b))
+        rescue Math::DomainError, RangeError
+          nil
+        end
+
+        # `Math.log(x)` and `Math.log(x, base)` — the only variadic
+        # `Math` function.
+        def fold_log(args)
+          return nil unless [1, 2].include?(args.size)
+
+          values = args.map { |a| numeric_constant(a) }
+          return nil if values.any?(&:nil?)
+
+          fold_float_result(Math.log(*values))
+        rescue Math::DomainError, RangeError
+          nil
+        end
+
+        # `Math.frexp` / `Math.lgamma` return a two-element array;
+        # lift it to `Tuple[Constant[Float], Constant[Integer]]`.
+        def fold_tuple_unary(method_name, args)
+          return nil unless args.size == 1
+
+          x = numeric_constant(args.first)
+          return nil if x.nil?
+
+          result = Math.public_send(method_name, x)
+          return nil unless result.is_a?(Array) && result.size == 2
+
+          Type::Combinator.tuple_of(
+            Type::Combinator.constant_of(result[0]),
+            Type::Combinator.constant_of(result[1])
+          )
+        rescue Math::DomainError, RangeError
+          nil
+        end
+
+        def fold_float_result(result)
+          return nil unless result.is_a?(Float)
+
+          Type::Combinator.constant_of(result)
+        end
+      end
+    end
+  end
+end

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

@@ -122,13 +122,30 @@ module Rigor
           return match if match
           return overloads.find { |mt| overload_has_block?(mt) } if block_required
 
-          overloads.first
+          # No block at the call site: prefer an overload that does
+          # not REQUIRE a block over `overloads.first`. Methods like
+          # `Array#filter` / `Enumerable#map` declare the block-
+          # bearing overload first (`() { ... } -> Array[Elem]`) and
+          # the bare-call overload second (`() -> Enumerator[...]`).
+          # Without this, a no-block `[1, 2].filter` would adopt the
+          # block overload's `Array[Elem]` return when the call
+          # actually yields an `Enumerator`.
+          overloads.find { |mt| !overload_requires_block?(mt) } || overloads.first
         end
 
         def overload_has_block?(method_type)
           method_type.respond_to?(:block) && method_type.block
         end
 
+        # True when the overload declares a block that the caller
+        # MUST supply (`{ ... }` in RBS). An optional block
+        # (`?{ ... }`) does NOT count — that overload is a valid
+        # match for a block-less call.
+        def overload_requires_block?(method_type)
+          block = overload_has_block?(method_type)
+          !!block && block.required
+        end
+
         class << self
           private
 
@@ -163,6 +180,7 @@ module Rigor
 
             overloads.find do |method_type|
               next false if block_required && !OverloadSelector.overload_has_block?(method_type)
+              next false if !block_required && OverloadSelector.overload_requires_block?(method_type)
               next false if strict && !strictly_typed_params?(method_type, arg_types.size)
 
               matches?(
@@ -199,6 +217,7 @@ module Rigor
           def find_matching_overload_via_aliases(overloads, arg_types:, block_required:)
             overloads.find do |method_type|
               next false if block_required && !OverloadSelector.overload_has_block?(method_type)
+              next false if !block_required && OverloadSelector.overload_requires_block?(method_type)
 
               fun = method_type.type
               next false unless arity_compatible?(fun, arg_types.size)

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

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+require_relative "../../type"
+
+module Rigor
+  module Inference
+    module MethodDispatcher
+      # Folds `Regexp` class-method calls on statically known arguments.
+      #
+      # === Supported methods
+      #
+      # * `escape(str)` / `quote(str)` — escapes regexp meta-characters.
+      #   Returns `Constant[String]`.
+      # * `new(str)` / `new(str, opts)` — constructs a Regexp at fold time
+      #   when the pattern argument is a `Constant[String]`. The optional
+      #   second argument may be a `Constant[Integer]` (flag bits), a
+      #   `Constant[true/false]` (IGNORECASE shorthand), or absent.
+      #   Returns `Constant[Regexp]`.
+      #
+      # === Non-constant / unsupported cases
+      #
+      # Returns `nil` (deferring to the next dispatcher tier) when:
+      # - the receiver is not `Singleton[Regexp]`,
+      # - the required pattern argument is not a `Constant[String]`,
+      # - the method is not in the supported set.
+      module RegexpFolding
+        REGEXP_ESCAPE_METHODS = Set[:escape, :quote].freeze
+        private_constant :REGEXP_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 fold_escape(args) if REGEXP_ESCAPE_METHODS.include?(method_name)
+          return fold_new(args) if method_name == :new
+
+          nil
+        end
+
+        def dispatch_target?(receiver)
+          receiver.is_a?(Type::Singleton) && receiver.class_name == "Regexp"
+        end
+
+        # `Regexp.escape(str)` / `.quote(str)` — one String arg.
+        def fold_escape(args)
+          return nil unless args.size == 1
+
+          arg = args.first
+          return nil unless arg.is_a?(Type::Constant) && arg.value.is_a?(String)
+
+          Type::Combinator.constant_of(Regexp.escape(arg.value))
+        end
+
+        # `Regexp.new(pattern)` / `Regexp.new(pattern, opts)` — constructs
+        # the pattern at inference time. Delegates to Ruby's real
+        # `Regexp.new` so all option forms (Integer flags, `true`/`false`,
+        # option strings) are handled without case-analysis; non-constant or
+        # invalid arguments decline through to the RBS tier.
+        def fold_new(args)
+          return nil if args.empty? || args.size > 2
+
+          pattern_arg = args.first
+          return nil unless pattern_arg.is_a?(Type::Constant) &&
+                            pattern_arg.value.is_a?(String)
+
+          opts = args.size == 2 ? constant_value_or_nil(args[1]) : 0
+          return nil if args.size == 2 && opts.nil?
+
+          Type::Combinator.constant_of(Regexp.new(pattern_arg.value, opts))
+        rescue StandardError
+          nil
+        end
+
+        def constant_value_or_nil(type)
+          type.is_a?(Type::Constant) ? type.value : nil
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+require_relative "../../type"
+
+module Rigor
+  module Inference
+    module MethodDispatcher
+      # Folds `Set` constructor calls into `Constant[Set]` when all
+      # arguments are statically known.
+      #
+      # Ruby 3.2+ implements Set in C (`set.c`). The constructor is
+      # deterministic — it reads only its arguments and writes nothing
+      # to global state.
+      #
+      # === Supported methods
+      #
+      # * `Set[]` — variadic constructor; each argument must be a
+      #   `Constant[T]`. Returns `Constant[Set]`.
+      # * `Set.new` — zero-argument form; returns `Constant[Set.new]`.
+      # * `Set.new(tuple)` — the argument must be a `Tuple` whose
+      #   every element is a `Constant[T]`. Returns `Constant[Set]`.
+      #
+      # === Non-constant / unsupported cases
+      #
+      # Returns `nil` (deferring to the next dispatcher tier) when:
+      # - the receiver is not `Singleton[Set]`,
+      # - the method is not `[]` or `new`,
+      # - any argument is non-constant or structurally opaque.
+      module SetFolding
+        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)
+
+          case method_name
+          when :[] then fold_bracket(args)
+          when :new then fold_new(args)
+          end
+        end
+
+        def dispatch_target?(receiver)
+          receiver.is_a?(Type::Singleton) && receiver.class_name == "Set"
+        end
+
+        # `Set["a", "b", "c"]` — all positional args must be Constant.
+        def fold_bracket(args)
+          values = args.map do |a|
+            return nil unless a.is_a?(Type::Constant)
+
+            a.value
+          end
+
+          Type::Combinator.constant_of(::Set.new(values))
+        rescue StandardError
+          nil
+        end
+
+        # `Set.new` / `Set.new(tuple_of_constants)`.
+        def fold_new(args)
+          return Type::Combinator.constant_of(::Set.new) if args.empty?
+          return nil if args.size > 1
+
+          arg = args.first
+          values = case arg
+                   when Type::Tuple
+                     return nil unless arg.elements.all?(Type::Constant)
+
+                     arg.elements.map(&:value)
+                   else
+                     return nil
+                   end
+
+          Type::Combinator.constant_of(::Set.new(values))
+        rescue StandardError
+          nil
+        end
+      end
+    end
+  end
+end