rigortype 0.0.5 → 0.0.7

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

@@ -13,6 +13,7 @@ require_relative "../builtins/comparable_catalog"
 require_relative "../builtins/enumerable_catalog"
 require_relative "../builtins/rational_catalog"
 require_relative "../builtins/complex_catalog"
+require_relative "../builtins/pathname_catalog"
 
 module Rigor
   module Inference
@@ -108,6 +109,16 @@ module Rigor
 
         # @return [Rigor::Type::Constant, Rigor::Type::Union, Rigor::Type::IntegerRange, nil]
         def try_fold(receiver:, method_name:, args:)
+          # v0.0.7 — `String#%` against a `Tuple` / `HashShape`
+          # argument runs Ruby's format-string engine when both
+          # sides are statically constant. The standard
+          # `numeric_set_of` path bails on Tuple / HashShape
+          # arguments because they are not scalar-Constant
+          # carriers, so the special-case sits ahead of the
+          # numeric path.
+          format_lift = try_fold_string_format(receiver, method_name, args)
+          return format_lift if format_lift
+
           receiver_set = numeric_set_of(receiver)
           return nil unless receiver_set
 
@@ -117,6 +128,59 @@ module Rigor
           dispatch_by_arity(receiver_set, method_name, arg_sets)
         end
 
+        # `Constant<String> % …` — runs the actual `String#%`
+        # operation when both sides are statically known. The
+        # argument may be:
+        # - A `Type::Constant` whose value is a scalar (Integer
+        #   / Float / String / Symbol). Already handled by the
+        #   numeric path; this method declines so the standard
+        #   binary path picks it up.
+        # - A `Type::Tuple` whose elements are all `Constant`.
+        #   Materialises the elements as a Ruby Array and runs
+        #   the format.
+        # - A `Type::HashShape` with no optional keys whose
+        #   values are all `Constant`. Materialises a Ruby Hash
+        #   and runs the format. Symbol keys are kept as
+        #   Symbols (matching Ruby's `%{key}` resolution).
+        # Anything else declines so the RBS tier widens.
+        # rubocop:disable Metrics/CyclomaticComplexity
+        def try_fold_string_format(receiver, method_name, args)
+          return nil unless method_name == :%
+          return nil unless args.size == 1
+          return nil unless receiver.is_a?(Type::Constant) && receiver.value.is_a?(String)
+
+          arg = args.first
+          ruby_arg = format_argument_value(arg)
+          return nil if ruby_arg.nil?
+
+          result = receiver.value % ruby_arg
+          return nil unless foldable_constant_value?(result)
+
+          Type::Combinator.constant_of(result)
+        rescue StandardError
+          nil
+        end
+        # rubocop:enable Metrics/CyclomaticComplexity
+
+        def format_argument_value(arg)
+          case arg
+          when Type::Tuple
+            return nil unless arg.elements.all?(Type::Constant)
+
+            arg.elements.map(&:value)
+          when Type::HashShape
+            hash_shape_format_value(arg)
+          end
+        end
+
+        def hash_shape_format_value(shape)
+          return nil unless shape.closed?
+          return nil unless shape.optional_keys.empty?
+          return nil unless shape.pairs.values.all?(Type::Constant)
+
+          shape.pairs.transform_values(&:value)
+        end
+
         def dispatch_by_arity(receiver_set, method_name, arg_sets)
           case arg_sets.size
           when 0 then try_fold_unary(receiver_set, method_name)
@@ -205,7 +269,17 @@ module Rigor
           [result]
         end
 
+        # rubocop:disable Metrics/CyclomaticComplexity
         def try_fold_unary_set(receiver_values, method_name)
+          range_lift = try_fold_range_constant_unary(receiver_values, method_name)
+          return range_lift if range_lift
+
+          string_lift = try_fold_string_array_unary(receiver_values, method_name)
+          return string_lift if string_lift
+
+          pathname_lift = try_fold_pathname_unary(receiver_values, method_name)
+          return pathname_lift if pathname_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
@@ -219,8 +293,68 @@ module Rigor
           end
           build_constant_type(results, source: receiver_values)
         end
+        # rubocop:enable Metrics/CyclomaticComplexity
+
+        # v0.0.7 — `Constant<Range>#to_a` and the no-arg
+        # `first` / `last` / `min` / `max` short-circuit through a
+        # Range-specific arm that catalog dispatch cannot reach:
+        # - `to_a` returns an Array (not foldable through
+        #   `foldable_constant_value?`) — lift to `Tuple[Constant…]`
+        #   when the cardinality fits within `RANGE_TO_A_LIMIT`.
+        # - `first` / `last` / `min` / `max` are catalog-classified
+        #   `:block_dependent` because of the optional-block forms,
+        #   but the no-arg form is pure for finite integer ranges.
+        #
+        # 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_TO_A_LIMIT = 16
+        private_constant :RANGE_FOLD_METHODS, :RANGE_TO_A_LIMIT
+
+        def try_fold_range_constant_unary(receiver_values, method_name)
+          return nil unless RANGE_FOLD_METHODS.include?(method_name)
+          return nil unless receiver_values.size == 1
+
+          range = receiver_values.first
+          return nil unless range.is_a?(Range)
+          return nil unless range.begin.is_a?(Integer) && range.end.is_a?(Integer)
+
+          range_constant_unary(range, method_name)
+        end
+
+        def range_constant_unary(range, method_name)
+          case method_name
+          when :to_a 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)
+          end
+        end
+
+        def range_to_a_tuple(range)
+          values = range.to_a
+          return Type::Combinator.tuple_of if values.empty?
+          return nil if values.size > RANGE_TO_A_LIMIT
+
+          Type::Combinator.tuple_of(*values.map { |v| Type::Combinator.constant_of(v) })
+        end
+
+        def range_endpoint_constant(range, edge)
+          values = range.to_a
+          return Type::Combinator.constant_of(nil) if values.empty?
 
+          Type::Combinator.constant_of(edge == :first ? values.first : values.last)
+        end
+
+        # rubocop:disable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
         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
+
+          pathname_lift = try_fold_pathname_binary(receiver_values, method_name, arg_values)
+          return pathname_lift if pathname_lift
+
           return nil if receiver_values.size * arg_values.size > UNION_FOLD_INPUT_LIMIT
           return nil unless receiver_values.all? { |rv| binary_method_allowed?(rv, method_name) }
 
@@ -229,22 +363,204 @@ module Rigor
           end
           build_constant_type(results, source: receiver_values + arg_values)
         end
+        # rubocop:enable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+
+        # v0.0.7 — `Constant<String>#chars` / `bytes` / `lines` /
+        # `split` (no-arg) return a Ruby Array of foldable
+        # scalars; `foldable_constant_value?` rejects Array
+        # results, so the standard unary path declines. Lift the
+        # Array to a per-position `Tuple[Constant…]` directly,
+        # capped at `STRING_ARRAY_LIFT_LIMIT` to keep the result
+        # bounded for long strings.
+        STRING_ARRAY_UNARY_METHODS = Set[:chars, :bytes, :lines, :split].freeze
+        STRING_ARRAY_BINARY_METHODS = Set[:split, :scan].freeze
+        STRING_ARRAY_LIFT_LIMIT = 32
+        private_constant :STRING_ARRAY_UNARY_METHODS,
+                         :STRING_ARRAY_BINARY_METHODS,
+                         :STRING_ARRAY_LIFT_LIMIT
+
+        # 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
+        # most methods `:dispatch` because the C body delegates to
+        # File / Dir / FileTest. The methods listed here are
+        # filesystem-independent — they read only `@path` — so
+        # invoking them at fold time produces a deterministic
+        # result regardless of the host filesystem state.
+        #
+        # Filesystem-touching methods (`exist?`, `file?`, `read`,
+        # `stat`, …) are intentionally NOT folded: their answer
+        # depends on the analysis machine's filesystem, which is
+        # neither stable nor relevant to the analyzed program.
+        PATHNAME_PURE_UNARY = Set[
+          :to_s, :to_path, :to_str,
+          :basename, :dirname, :extname, :cleanpath,
+          :parent, :sub_ext, :root?, :absolute?, :relative?,
+          :hash, :inspect
+        ].freeze
+        PATHNAME_PURE_BINARY = Set[
+          :+, :join, :sub_ext, :<=>, :==, :eql?, :===,
+          :relative_path_from
+        ].freeze
+        private_constant :PATHNAME_PURE_UNARY, :PATHNAME_PURE_BINARY
+
+        def try_fold_pathname_unary(receiver_values, method_name)
+          return nil unless PATHNAME_PURE_UNARY.include?(method_name)
+          return nil unless receiver_values.size == 1
+
+          receiver = receiver_values.first
+          return nil unless receiver.is_a?(Pathname)
+
+          result = receiver.public_send(method_name)
+          return nil unless foldable_constant_value?(result)
+
+          Type::Combinator.constant_of(result)
+        rescue StandardError
+          nil
+        end
+
+        # rubocop:disable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+        def try_fold_pathname_binary(receiver_values, method_name, arg_values)
+          return nil unless PATHNAME_PURE_BINARY.include?(method_name)
+          return nil unless receiver_values.size == 1 && arg_values.size == 1
+
+          receiver = receiver_values.first
+          arg = arg_values.first
+          return nil unless receiver.is_a?(Pathname)
+          return nil unless arg.is_a?(Pathname) || arg.is_a?(String)
+
+          result = receiver.public_send(method_name, arg)
+          return nil unless foldable_constant_value?(result)
+
+          Type::Combinator.constant_of(result)
+        rescue StandardError
+          nil
+        end
+        # rubocop:enable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+
+        def try_fold_string_array_unary(receiver_values, method_name)
+          return nil unless STRING_ARRAY_UNARY_METHODS.include?(method_name)
+          return nil unless receiver_values.size == 1
+
+          receiver = receiver_values.first
+          return nil unless receiver.is_a?(String)
+
+          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.
+        # rubocop:disable Metrics/CyclomaticComplexity
+        def try_fold_string_array_binary(receiver_values, method_name, arg_values)
+          return nil unless STRING_ARRAY_BINARY_METHODS.include?(method_name)
+          return nil unless receiver_values.size == 1 && arg_values.size == 1
+
+          receiver = receiver_values.first
+          arg = arg_values.first
+          return nil unless receiver.is_a?(String)
+          return nil unless arg.is_a?(String) || arg.is_a?(Regexp)
+
+          lift_array_result(receiver.public_send(method_name, arg))
+        rescue StandardError
+          nil
+        end
+        # rubocop:enable Metrics/CyclomaticComplexity
+
+        def lift_array_result(result)
+          return nil unless result.is_a?(Array)
+          return nil if result.size > STRING_ARRAY_LIFT_LIMIT
+          return nil unless result.all? { |v| foldable_constant_value?(v) }
+
+          Type::Combinator.tuple_of(*result.map { |v| Type::Combinator.constant_of(v) })
+        end
 
         # 2-arg fold dispatch. Used by `Comparable#between?(min, max)`,
         # `Comparable#clamp(min, max)`, and `Integer#pow(exp, mod)` —
         # methods the catalog classifies `:leaf` but that the prior
-        # 0/1-arg switch could not reach. Range receivers/args are
-        # held back: a precise 2-arg range fold (e.g.
-        # `int<0,10>.between?(0, 10)` → `Constant[true]`) is a
-        # follow-up; for now any IntegerRange operand bails to the
-        # RBS tier.
+        # 0/1-arg switch could not reach.
+        #
+        # v0.0.6 — IntegerRange-shaped receivers participate in
+        # `Comparable#between?` and `Comparable#clamp` folds.
+        # `int<a,b>.between?(min, max)` decides three-valued via
+        # the receiver's bounds against scalar args; `int<a,b>.clamp`
+        # narrows the receiver's bounds against the bracket. Other
+        # ternary methods over IntegerRange operands still decline.
         def try_fold_ternary(receiver_set, method_name, arg_sets)
-          return nil if receiver_set.is_a?(Type::IntegerRange)
+          return try_fold_ternary_range(receiver_set, method_name, arg_sets) if receiver_set.is_a?(Type::IntegerRange)
           return nil if arg_sets.any?(Type::IntegerRange)
 
           try_fold_ternary_set(receiver_set, method_name, arg_sets)
         end
 
+        # Receiver IntegerRange + two scalar `Constant<Integer>`
+        # args — the only IntegerRange-aware ternary fold today.
+        # `between?` returns Trinary truthiness over the bracket;
+        # `clamp` returns the intersected IntegerRange (or a
+        # collapsed Constant if the result pins a single point).
+        def try_fold_ternary_range(range, method_name, arg_sets)
+          return nil unless arg_sets.all?(Array)
+
+          min_arg = single_integer_arg(arg_sets[0])
+          max_arg = single_integer_arg(arg_sets[1])
+          return nil if min_arg.nil? || max_arg.nil?
+          return nil if min_arg > max_arg
+
+          case method_name
+          when :between? then range_between(range, min_arg, max_arg)
+          when :clamp then range_clamp(range, min_arg, max_arg)
+          end
+        end
+
+        def single_integer_arg(values)
+          return nil unless values.is_a?(Array) && values.size == 1
+
+          v = values.first
+          v.is_a?(Integer) ? v : nil
+        end
+
+        # `int<a,b>.between?(min, max)`:
+        # - Constant[true] when [a,b] ⊆ [min,max] (and finite).
+        # - Constant[false] when [a,b] ∩ [min,max] is empty.
+        # - bool union otherwise.
+        def range_between(range, min_arg, max_arg)
+          return Type::Combinator.constant_of(false) if range.upper < min_arg || range.lower > max_arg
+
+          return Type::Combinator.constant_of(true) if range.finite? && range.min >= min_arg && range.max <= max_arg
+
+          bool_union
+        end
+
+        # `int<a,b>.clamp(min, max)`:
+        # - new_lower = max(a, min), new_upper = min(b, max).
+        # - When new_lower > new_upper the bracket excluded the
+        #   range entirely; the call still returns one of the
+        #   bracket bounds at runtime, but Rigor is strictly less
+        #   precise here than Ruby — decline so the RBS tier
+        #   widens to plain Integer rather than the dispatcher
+        #   inventing a value.
+        def range_clamp(range, min_arg, max_arg)
+          new_lower = clamp_lower_bound(range.lower, min_arg)
+          new_upper = clamp_upper_bound(range.upper, max_arg)
+          return nil if new_lower.is_a?(Integer) && new_upper.is_a?(Integer) && new_lower > new_upper
+
+          build_integer_range(new_lower, new_upper)
+        end
+
+        def clamp_lower_bound(range_lower, bracket_min)
+          return bracket_min if range_lower == -Float::INFINITY
+
+          [range_lower, bracket_min].max
+        end
+
+        def clamp_upper_bound(range_upper, bracket_max)
+          return bracket_max if range_upper == Float::INFINITY
+
+          [range_upper, bracket_max].min
+        end
+
         def try_fold_ternary_set(receiver_values, method_name, arg_sets)
           total = receiver_values.size * arg_sets[0].size * arg_sets[1].size
           return nil if total > UNION_FOLD_INPUT_LIMIT
@@ -760,7 +1076,8 @@ module Rigor
           [DateTime, [Builtins::DATE_CATALOG,   "DateTime"]],
           [Date,     [Builtins::DATE_CATALOG,   "Date"]],
           [Rational, [Builtins::RATIONAL_CATALOG, "Rational"]],
-          [Complex,  [Builtins::COMPLEX_CATALOG,  "Complex"]]
+          [Complex,  [Builtins::COMPLEX_CATALOG,  "Complex"]],
+          [Pathname, [Builtins::PATHNAME_CATALOG, "Pathname"]]
         ].freeze
         private_constant :CATALOG_BY_CLASS
 
@@ -808,7 +1125,7 @@ module Rigor
         # round-trip through `Type::Combinator.constant_of`".
         def foldable_constant_value?(value)
           case value
-          when Integer, Float, String, Symbol, true, false, nil then true
+          when Integer, Float, Rational, Complex, String, Symbol, Regexp, Pathname, true, false, nil then true
           else false
           end
         end

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

@@ -30,18 +30,59 @@ module Rigor
       module KernelDispatch
         module_function
 
+        # `Kernel#Rational` / `Kernel#Complex` constructor folds.
+        # When every argument is a `Type::Constant` whose value is
+        # numeric, we can run the actual Ruby constructor and lift
+        # the result into a `Constant<Rational>` / `Constant<Complex>`.
+        # The factory accepts the same shapes as Ruby:
+        # `Rational(a)`, `Rational(a, b)`, `Complex(a)`, `Complex(a, b)`.
+        NUMERIC_CONSTRUCTORS = {
+          Rational: ->(*args) { Rational(*args) },
+          Complex: ->(*args) { Complex(*args) }
+        }.freeze
+        private_constant :NUMERIC_CONSTRUCTORS
+
         def try_dispatch(receiver:, method_name:, args:)
-          return nil unless method_name == :Array
-          return nil if args.length != 1
           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)
+
+          nil
+        end
+
+        def try_array(args)
+          return nil if args.length != 1
 
-          arg = args.first
-          element = element_type_of(arg)
+          element = element_type_of(args.first)
           return nil if element.nil?
 
           Type::Combinator.nominal_of("Array", type_args: [element])
         end
 
+        # `Rational(int)` / `Rational(num, den)` and `Complex(re)`
+        # / `Complex(re, im)` fold when every arg 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) }
+
+          values = args.map(&:value)
+          result = NUMERIC_CONSTRUCTORS[method_name].call(*values)
+          Type::Combinator.constant_of(result)
+        rescue StandardError
+          nil
+        end
+
+        def numeric_constant?(type)
+          type.is_a?(Type::Constant) &&
+            (type.value.is_a?(Integer) ||
+              type.value.is_a?(Float) ||
+              type.value.is_a?(Rational) ||
+              type.value.is_a?(Complex))
+        end
+
         # Computes the element type the argument contributes to the
         # `Array(arg)` result, mirroring Ruby's coercion contract:
         #

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

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require_relative "../../reflection"
 require_relative "../../type"
 require_relative "../../rbs_extended"
 require_relative "../rbs_type_translator"
@@ -218,15 +219,9 @@ module Rigor
           def lookup_method(environment, class_name, kind, method_name)
             case kind
             when :instance
-              environment.rbs_loader.instance_method(
-                class_name: class_name,
-                method_name: method_name
-              )
+              Rigor::Reflection.instance_method_definition(class_name, method_name, environment: environment)
             when :singleton
-              environment.rbs_loader.singleton_method(
-                class_name: class_name,
-                method_name: method_name
-              )
+              Rigor::Reflection.singleton_method_definition(class_name, method_name, environment: environment)
             end
           end
 
@@ -239,7 +234,7 @@ module Rigor
           def build_type_vars(environment, class_name, receiver_args)
             return {} if receiver_args.empty?
 
-            param_names = environment.rbs_loader.class_type_param_names(class_name)
+            param_names = Rigor::Reflection.class_type_param_names(class_name, environment: environment)
             return {} if param_names.empty?
             return {} if param_names.size != receiver_args.size