rigortype 0.1.8 → 0.1.10

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