rigortype 0.0.5 → 0.0.6

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

@@ -0,0 +1,322 @@
+# frozen_string_literal: true
+
+require_relative "../../type"
+
+module Rigor
+  module Inference
+    module MethodDispatcher
+      # Block-shaped fold dispatch (v0.0.6 phase 1).
+      #
+      # Sits ahead of `RbsDispatch.try_dispatch` and folds a small
+      # set of block-taking Enumerable methods when the inferred
+      # block return type is a Ruby-truthy or Ruby-falsey
+      # `Type::Constant`. The block-parameter typing for the same
+      # methods continues to be answered by `IteratorDispatch`
+      # (this module concerns the *return* of the call, not the
+      # block-param binding).
+      #
+      # The methods covered fall in two families:
+      #
+      # - **Filter-shaped** (`select` / `filter` / `reject` /
+      #   `take_while` / `drop_while`): the block's truthiness
+      #   selects the all-or-nothing endpoints — either the
+      #   receiver's full shape (when every element is kept) or
+      #   the empty-tuple carrier (when every element is dropped).
+      # - **Predicate-shaped** (`all?` / `any?` / `none?`): the
+      #   block's truthiness combined with the receiver's
+      #   emptiness collapses the call to a `Constant[bool]` in
+      #   the cases where Ruby's actual semantics make it
+      #   unconditional. Non-empty + truthy `any?` is `true`;
+      #   non-empty + falsey `all?` is `false`; the empty-receiver
+      #   "vacuous" answers (`[].all? { false } == true`,
+      #   `[].any? { true } == false`, `[].none? { true } == true`)
+      #   are likewise honoured.
+      #
+      # The dispatcher returns `nil` for any case that cannot be
+      # decided from the (receiver-shape, method, block-truthiness)
+      # tuple — element-wise block re-evaluation against
+      # `Constant<Array>` receivers (the `map` / `filter_map` /
+      # `flat_map` precision tier) is reserved for a later slice.
+      module BlockFolding # rubocop:disable Metrics/ModuleLength
+        module_function
+
+        FILTER_KEEP_ON_TRUTHY = Set[:select, :filter, :take_while].freeze
+        FILTER_KEEP_ON_FALSEY = Set[:reject, :drop_while].freeze
+
+        PREDICATE_METHODS = Set[:all?, :any?, :none?].freeze
+
+        # Methods whose answer is `nil` when the block always
+        # returns Ruby-falsey — `find` / `detect` short-circuit
+        # to nil when nothing matches, `find_index` / `index`
+        # likewise. These methods only fold on the falsey side
+        # for now; the truthy-block side requires per-position
+        # analysis (the index of the first kept element, or the
+        # element itself, depend on the receiver's shape and on
+        # which positions actually evaluate to truthy).
+        FALSEY_BLOCK_NIL_METHODS = Set[:find, :detect, :find_index, :index].freeze
+
+        # Block-taking `count` returns the number of elements
+        # for which the block is truthy. With a Constant-falsey
+        # block the answer is unconditionally `Constant[0]`;
+        # with a Constant-truthy block on a finitely-sized
+        # receiver it is `Constant[size]`.
+        COUNT_METHOD = :count
+
+        # @param receiver    [Rigor::Type, nil]
+        # @param method_name [Symbol]
+        # @param args        [Array<Rigor::Type>]
+        # @param block_type  [Rigor::Type, nil] inferred return type of
+        #   the call's block. `nil` means "no block at the call site"
+        #   and disqualifies every rule here.
+        # @return [Rigor::Type, nil]
+        # rubocop:disable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+        def try_fold(receiver:, method_name:, args:, block_type:)
+          return nil if receiver.nil? || block_type.nil?
+
+          truthiness = constant_truthiness(block_type)
+          return nil if truthiness.nil?
+
+          if PREDICATE_METHODS.include?(method_name)
+            fold_predicate(receiver, method_name, truthiness)
+          elsif filter_method?(method_name)
+            fold_filter(receiver, method_name, truthiness)
+          elsif FALSEY_BLOCK_NIL_METHODS.include?(method_name)
+            fold_falsey_nil_short_circuit(method_name, truthiness, args)
+          elsif method_name == COUNT_METHOD
+            fold_count(receiver, truthiness, args)
+          end
+        end
+        # rubocop:enable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+
+        def filter_method?(method_name)
+          FILTER_KEEP_ON_TRUTHY.include?(method_name) ||
+            FILTER_KEEP_ON_FALSEY.include?(method_name)
+        end
+
+        # Maps the block return type to `:truthy`, `:falsey`, or
+        # `nil` (inconclusive). Only `Type::Constant` answers
+        # decisively — `Union[true, false]`, `Nominal[…]`, or
+        # `Dynamic[T]` keep the dispatcher silent so the RBS
+        # tier still owns the call.
+        def constant_truthiness(block_type)
+          return nil unless block_type.is_a?(Type::Constant)
+
+          block_type.value ? :truthy : :falsey
+        end
+
+        # Filter-shaped methods collapse to either the receiver
+        # (every element kept) or the empty tuple (every element
+        # dropped). Tuple-shaped receivers widen to
+        # `Array[union of elements]` on the all-kept side because
+        # we cannot prove WHICH positional subset survives —
+        # Tuple's per-position semantics do not carry over to a
+        # filtered Array.
+        def fold_filter(receiver, method_name, truthiness)
+          return nil unless filter_receiver_known?(receiver)
+
+          keep_all = filter_keeps_all?(method_name, truthiness)
+          keep_all ? receiver_as_kept_array(receiver) : Type::Combinator.tuple_of
+        end
+
+        def filter_keeps_all?(method_name, truthiness)
+          (FILTER_KEEP_ON_TRUTHY.include?(method_name) && truthiness == :truthy) ||
+            (FILTER_KEEP_ON_FALSEY.include?(method_name) && truthiness == :falsey)
+        end
+
+        def receiver_as_kept_array(receiver)
+          case receiver
+          when Type::Tuple then tuple_to_array(receiver)
+          else receiver
+          end
+        end
+
+        def tuple_to_array(tuple)
+          return Type::Combinator.tuple_of if tuple.elements.empty?
+          return Type::Combinator.nominal_of("Array", type_args: [tuple.elements.first]) if tuple.elements.size == 1
+
+          element = Type::Combinator.union(*tuple.elements)
+          Type::Combinator.nominal_of("Array", type_args: [element])
+        end
+
+        # Predicate folds. The decision table mirrors Ruby's
+        # actual semantics on `Enumerable#all?` / `#any?` /
+        # `#none?` — see the table at the top of the module.
+        def fold_predicate(receiver, method_name, truthiness)
+          emptiness = receiver_emptiness(receiver)
+          decision = predicate_decision(method_name, truthiness, emptiness)
+          return nil if decision.nil?
+
+          case decision
+          when :always_true  then Type::Combinator.constant_of(true)
+          when :always_false then Type::Combinator.constant_of(false)
+          when :bool         then bool_union
+          end
+        end
+
+        # @return [:always_true, :always_false, :bool, nil]
+        # rubocop:disable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+        def predicate_decision(method_name, truthiness, emptiness)
+          case method_name
+          when :all?
+            return :always_true if truthiness == :truthy
+            return :always_true if emptiness == :empty
+            return :always_false if emptiness == :non_empty
+
+            :bool
+          when :any?
+            return :always_false if truthiness == :falsey
+            return :always_true if emptiness == :non_empty
+            return :always_false if emptiness == :empty
+
+            :bool
+          when :none?
+            return :always_true if truthiness == :falsey
+            return :always_false if emptiness == :non_empty
+            return :always_true if emptiness == :empty
+
+            :bool
+          end
+        end
+        # rubocop:enable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+
+        def bool_union
+          Type::Combinator.union(
+            Type::Combinator.constant_of(true),
+            Type::Combinator.constant_of(false)
+          )
+        end
+
+        # @return [:empty, :non_empty, :unknown]
+        def receiver_emptiness(receiver)
+          case receiver
+          when Type::Tuple
+            receiver.elements.empty? ? :empty : :non_empty
+          when Type::HashShape
+            receiver.pairs.empty? ? :empty : :non_empty
+          when Type::Constant
+            constant_emptiness(receiver.value)
+          when Type::Difference
+            difference_emptiness(receiver)
+          else
+            :unknown
+          end
+        end
+
+        def constant_emptiness(value)
+          # Only `Range` constants reach these folds: `Type::Constant`
+          # rejects Array / Hash literals (they become `Tuple` /
+          # `HashShape` carriers), and the remaining scalar
+          # constants (Integer / Float / Symbol / String / …)
+          # are not Enumerable receivers for the filter or
+          # predicate methods folded here.
+          return range_emptiness(value) if value.is_a?(Range)
+
+          :unknown
+        end
+
+        def range_emptiness(range)
+          beg = range.begin
+          en  = range.end
+          return :unknown unless beg.is_a?(Numeric) && en.is_a?(Numeric)
+
+          if range.exclude_end?
+            beg < en ? :non_empty : :empty
+          else
+            beg <= en ? :non_empty : :empty
+          end
+        end
+
+        # `non-empty-array[T]` is encoded as
+        # `Difference[Array[T], Tuple[]]` — the imported built-in
+        # carrier for non-emptiness. Recognising it here lets
+        # `arr.any? { true }` fold to `Constant[true]` for
+        # callers who threaded the non-emptiness through their
+        # type signature.
+        def difference_emptiness(diff)
+          base = diff.base
+          removed = diff.removed
+          return :unknown unless removed.is_a?(Type::Tuple) && removed.elements.empty?
+          return :non_empty if array_or_hash_nominal?(base)
+
+          :unknown
+        end
+
+        def array_or_hash_nominal?(type)
+          type.is_a?(Type::Nominal) && %w[Array Hash Set].include?(type.class_name)
+        end
+
+        # Filter folds need at least a recognised collection
+        # carrier; `Top` / `Dynamic` / arbitrary nominals decline
+        # so the RBS tier answers (its `Array#select { … } -> Array[T]`
+        # projection is correct, just less precise on the empty
+        # endpoint).
+        def filter_receiver_known?(receiver)
+          case receiver
+          when Type::Tuple, Type::HashShape, Type::Constant, Type::Difference then true
+          when Type::Nominal then %w[Array Hash Set Range].include?(receiver.class_name)
+          else false
+          end
+        end
+
+        # `find` / `detect` / `find_index` / `index` (block form)
+        # short-circuit to nil when the block is provably falsey.
+        # `index` and `find_index` also accept a non-block argument
+        # form (`arr.index(value)`); we decline whenever the call
+        # carries a positional argument so the RBS tier still
+        # answers the value-search variant correctly.
+        def fold_falsey_nil_short_circuit(_method_name, truthiness, args)
+          return nil unless args.empty?
+          return nil unless truthiness == :falsey
+
+          Type::Combinator.constant_of(nil)
+        end
+
+        # `count` with a block returns the count of elements
+        # for which the block is truthy. The non-block forms
+        # (`count` / `count(value)`) carry positional arguments
+        # and are handled by the RBS tier; this fold only fires
+        # when the block is the sole source of selection.
+        def fold_count(receiver, truthiness, args)
+          return nil unless args.empty?
+          return Type::Combinator.constant_of(0) if truthiness == :falsey
+
+          fold_count_truthy(receiver)
+        end
+
+        def fold_count_truthy(receiver)
+          size = finite_size(receiver)
+          return nil if size.nil?
+
+          Type::Combinator.constant_of(size)
+        end
+
+        # Returns the receiver's known finite element count, or
+        # nil when the carrier does not pin a size. Tuple and
+        # HashShape are pinned by construction; `Constant<…>`
+        # exposes the literal's `.size`. Other shapes (Array[T],
+        # Range[T], Nominal) decline so the RBS tier widens.
+        def finite_size(receiver)
+          case receiver
+          when Type::Tuple then receiver.elements.size
+          when Type::HashShape then receiver.pairs.size
+          when Type::Constant then constant_size(receiver.value)
+          end
+        end
+
+        def constant_size(value)
+          # Mirrors `constant_emptiness` — only `Range` produces
+          # a meaningful finite size for the methods folded here.
+          range_size(value) if value.is_a?(Range)
+        end
+
+        def range_size(range)
+          beg = range.begin
+          en  = range.end
+          return nil unless beg.is_a?(Integer) && en.is_a?(Integer)
+
+          range.exclude_end? ? [en - beg, 0].max : [en - beg + 1, 0].max
+        end
+      end
+    end
+  end
+end

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
@@ -233,18 +234,87 @@ module Rigor
         # 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 +830,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
 

data/lib/rigor/inference/method_dispatcher.rb

@@ -5,6 +5,7 @@ require_relative "method_dispatcher/constant_folding"
 require_relative "method_dispatcher/shape_dispatch"
 require_relative "method_dispatcher/rbs_dispatch"
 require_relative "method_dispatcher/iterator_dispatch"
+require_relative "method_dispatcher/block_folding"
 require_relative "method_dispatcher/file_folding"
 require_relative "method_dispatcher/kernel_dispatch"
 
@@ -59,7 +60,7 @@ module Rigor
       def dispatch(receiver_type:, method_name:, arg_types:, block_type: nil, environment: nil)
         return nil if receiver_type.nil?
 
-        precise = dispatch_precise_tiers(receiver_type, method_name, arg_types)
+        precise = dispatch_precise_tiers(receiver_type, method_name, arg_types, block_type)
         return precise if precise
 
         rbs_result = RbsDispatch.try_dispatch(
@@ -83,19 +84,28 @@ module Rigor
       end
 
       # Runs the precision tiers (constant fold, shape dispatch,
-      # file-path fold) in order and returns the first non-nil
-      # answer. Each tier owns its own receiver/argument shape
-      # checks; a tier that does not recognise the receiver returns
-      # nil so the next tier can try. The RBS tier sits below this
-      # chain and is invoked by the outer `dispatch` method.
-      def dispatch_precise_tiers(receiver_type, method_name, arg_types)
+      # file-path fold, block fold) in order and returns the first
+      # non-nil answer. Each tier owns its own receiver/argument
+      # shape checks; a tier that does not recognise the receiver
+      # returns nil so the next tier can try. The RBS tier sits
+      # below this chain and is invoked by the outer `dispatch`
+      # method.
+      #
+      # `BlockFolding` runs last among the precision tiers because
+      # its rules apply only to block-taking calls, so the cheaper
+      # arity-based fold tiers above it filter out the common
+      # cases first. When `block_type` is nil the tier is a no-op.
+      def dispatch_precise_tiers(receiver_type, method_name, arg_types, block_type = nil)
         meta_result = try_meta_introspection(receiver_type, method_name)
         return meta_result if meta_result
 
         ConstantFolding.try_fold(receiver: receiver_type, method_name: method_name, args: arg_types) ||
           ShapeDispatch.try_dispatch(receiver: receiver_type, method_name: method_name, args: arg_types) ||
           FileFolding.try_dispatch(receiver: receiver_type, method_name: method_name, args: arg_types) ||
-          KernelDispatch.try_dispatch(receiver: receiver_type, method_name: method_name, args: arg_types)
+          KernelDispatch.try_dispatch(receiver: receiver_type, method_name: method_name, args: arg_types) ||
+          BlockFolding.try_fold(
+            receiver: receiver_type, method_name: method_name, args: arg_types, block_type: block_type
+          )
       end
 
       def try_user_class_fallback(receiver_type, method_name, arg_types, environment, block_type)

data/lib/rigor/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Rigor
-  VERSION = "0.0.5"
+  VERSION = "0.0.6"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rigortype
 version: !ruby/object:Gem::Version
-  version: 0.0.5
+  version: 0.0.6
 platform: ruby
 authors:
 - Rigor contributors
@@ -169,6 +169,7 @@ files:
 - data/builtins/ruby_core/hash.yml
 - data/builtins/ruby_core/io.yml
 - data/builtins/ruby_core/numeric.yml
+- data/builtins/ruby_core/pathname.yml
 - data/builtins/ruby_core/range.yml
 - data/builtins/ruby_core/rational.yml
 - data/builtins/ruby_core/set.yml
@@ -205,6 +206,7 @@ files:
 - lib/rigor/inference/builtins/hash_catalog.rb
 - lib/rigor/inference/builtins/method_catalog.rb
 - lib/rigor/inference/builtins/numeric_catalog.rb
+- lib/rigor/inference/builtins/pathname_catalog.rb
 - lib/rigor/inference/builtins/range_catalog.rb
 - lib/rigor/inference/builtins/rational_catalog.rb
 - lib/rigor/inference/builtins/set_catalog.rb
@@ -216,6 +218,7 @@ files:
 - lib/rigor/inference/fallback.rb
 - lib/rigor/inference/fallback_tracer.rb
 - lib/rigor/inference/method_dispatcher.rb
+- lib/rigor/inference/method_dispatcher/block_folding.rb
 - lib/rigor/inference/method_dispatcher/constant_folding.rb
 - lib/rigor/inference/method_dispatcher/file_folding.rb
 - lib/rigor/inference/method_dispatcher/iterator_dispatch.rb