rigortype 0.1.3 → 0.1.5

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

@@ -27,12 +27,11 @@ module Rigor
       # - `a.downto(b) { |i| … }` yields the same domain `[b, a]`,
       #   just iterated in reverse. Lower bound from the
       #   argument, upper bound from the receiver.
-      module IteratorDispatch # rubocop:disable Metrics/ModuleLength
+      module IteratorDispatch
         module_function
 
         # @return [Array<Rigor::Type>, nil] block-param types, or
         #   nil to fall through to the next tier.
-        # rubocop:disable Metrics/CyclomaticComplexity
         def block_param_types(receiver:, method_name:, args:)
           case method_name
           when :times then times_block_params(receiver)
@@ -45,7 +44,6 @@ module Rigor
           when :each_slice, :each_cons then slice_block_params(receiver)
           end
         end
-        # rubocop:enable Metrics/CyclomaticComplexity
 
         def times_block_params(receiver)
           return nil unless integer_rooted?(receiver)

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

@@ -36,10 +36,10 @@ module Rigor
         # 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
+        NUMERIC_CONSTRUCTORS = Ractor.make_shareable({
+                                                       Rational: Ractor.make_shareable(->(*args) { Rational(*args) }),
+                                                       Complex: Ractor.make_shareable(->(*args) { Complex(*args) })
+                                                     })
         private_constant :NUMERIC_CONSTRUCTORS
 
         # `Kernel#Integer(s)` predicate-aware refinement set

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

@@ -74,7 +74,7 @@ module Rigor
         private_constant :CONCAT_METHODS, :FORMAT_METHODS,
                          :LITERAL_PRESERVING_METHODS, :WIDTH_PADDING_METHODS
 
-        def try_dispatch(receiver:, method_name:, args:, **) # rubocop:disable Metrics/CyclomaticComplexity,Metrics/PerceivedComplexity
+        def try_dispatch(receiver:, method_name:, args:, **)
           return fold_array_join(receiver, args) if method_name == :join
           return fold_format(args) if FORMAT_METHODS.include?(method_name)
 

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

@@ -0,0 +1,135 @@
+# frozen_string_literal: true
+
+require_relative "../../type"
+
+module Rigor
+  module Inference
+    module MethodDispatcher
+      # `Method` (and friends) precision tier.
+      #
+      # Two folds make a `Method` carrier round-trip with its
+      # binding visible:
+      #
+      # 1. **Forward** — `<receiver>.method(:sym)` (or
+      #    `.method("sym")`) lifts to {Type::BoundMethod}
+      #    carrying the receiver type AND the resolved Symbol.
+      #    Calling with a non-literal symbol-shaped argument
+      #    declines so the RBS tier still answers
+      #    `Nominal[Method]`.
+      # 2. **Backward** — `Type::BoundMethod#call(...)` /
+      #    `#()` (Prism lowers `.()` into a CallNode whose
+      #    `name` is `:call`) / `#[](...)` substitutes the
+      #    bound `(receiver_type, method_name)` and recurses
+      #    back into `MethodDispatcher.dispatch`. The
+      #    re-entrant call lets the substituted dispatch
+      #    consume every tier the original call site would
+      #    have — constant folding, shape dispatch, RBS,
+      #    plugin contributions, etc. The original block_type
+      #    / environment / call_node / scope are threaded
+      #    through unchanged so capture-sensitive tiers (the
+      #    block fold) keep working.
+      #
+      # Lives ABOVE the standard precision-tier chain so the
+      # RBS tier never sees a `BoundMethod` receiver — `Method`
+      # erasure means RBS would otherwise return
+      # `Method#call: (*untyped) -> untyped`, which is exactly
+      # the precision loss the carrier exists to avoid.
+      module MethodFolding
+        module_function
+
+        # Forward fold. Returns a {Type::BoundMethod} when the
+        # call shape is `<receiver>.method(:name)` /
+        # `.method("name")` with a precisely-known Symbol /
+        # String argument. Declines on every other shape so
+        # the RBS tier still answers `Method` for non-folding
+        # cases.
+        #
+        # @param receiver [Rigor::Type] caller's receiver
+        # @param method_name [Symbol] the method being
+        #   dispatched on `receiver` — only `:method` triggers
+        #   the fold.
+        # @param args [Array<Rigor::Type>] caller's argument
+        #   types in order. Only the single-argument case
+        #   matches; other arities decline.
+        def try_forward(receiver:, method_name:, args:)
+          return nil unless method_name == :method
+          return nil if args.size != 1
+
+          bound_name = symbol_name_of(args.first)
+          return nil if bound_name.nil?
+
+          Type::Combinator.bound_method_of(receiver, bound_name)
+        end
+
+        # Backward fold. Recurses into `MethodDispatcher.dispatch`
+        # with the bound `(receiver_type, method_name)`. The
+        # `block_type` / `environment` / `call_node` / `scope`
+        # are forwarded so every downstream tier (constant
+        # folding, shape dispatch, plugin contributions, …)
+        # keeps the original call site's context. Returns
+        # `Dynamic[top]` rather than `nil` when the recursive
+        # dispatch declines so the call site still ends in a
+        # well-defined type (the gradual-safety net mirrors
+        # the engine's "BoundMethod erases to `Method`,
+        # `Method#call: (*untyped) -> untyped`" RBS fallback).
+        def try_backward(receiver:, method_name:, args:, block_type:, environment:, call_node:, scope:)
+          return nil unless receiver.is_a?(Type::BoundMethod)
+          return nil unless backward_method?(method_name)
+
+          # `Method#curry` is treated as identity on the carrier
+          # — `<bound>.curry` keeps the same
+          # `(receiver_type, method_name)` so a subsequent
+          # `<curried>.call` still routes through the recursive
+          # dispatch below. This is correct for the dominant
+          # no-arg form (`.curry.call`); partially-applied
+          # forms (`.curry(n).call(a)`) lose precision and fall
+          # through to RBS via the trailing
+          # `Type::Combinator.untyped`. A faithful
+          # `Type::CurriedBoundMethod(receiver_type,
+          # method_name, accumulated_args)` carrier is reserved
+          # for a future slice when concrete user demand
+          # surfaces.
+          return receiver if method_name == :curry
+
+          MethodDispatcher.dispatch(
+            receiver_type: receiver.receiver_type,
+            method_name: receiver.method_name,
+            arg_types: args,
+            block_type: block_type,
+            environment: environment,
+            call_node: call_node,
+            scope: scope
+          ) || Type::Combinator.untyped
+        end
+        # `Method#call` / `Method#()` and `Method#[]` are the
+        # invocation entry points on the `Method` API; the
+        # alias `===` is also `call` semantically but is more
+        # commonly used as a case-equality predicate, so we
+        # do NOT fold through it (the case/when narrowing path
+        # already special-cases `===` for branch typing).
+        # `Method#curry` rides through as identity (see the
+        # comment in `try_backward`).
+        BACKWARD_METHOD_NAMES = %i[call [] curry].freeze
+        private_constant :BACKWARD_METHOD_NAMES
+
+        def backward_method?(method_name)
+          BACKWARD_METHOD_NAMES.include?(method_name)
+        end
+
+        # `Object#method` accepts both Symbol and String at
+        # runtime (the latter coerced via `to_sym`). The
+        # `Constant<String>` form is rare in production code
+        # but cheap to support and matches Ruby's documented
+        # contract.
+        def symbol_name_of(arg)
+          return nil unless arg.is_a?(Type::Constant)
+
+          case arg.value
+          when Symbol then arg.value
+          when String then arg.value.to_sym
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -26,7 +26,7 @@ module Rigor
       #    `Array#[](Range) -> Array[Elem]?` overload for a Range
       #    argument. (Surfaced during v0.1.1 self-analysis; see the
       #    "Interface-strictness on overload selection" item in
-      #    `docs/MILESTONES.md`.)
+      #    `docs/ROADMAP.md`.)
       # 3. **Pass 2 — gradual fall-back.** If no fully strict overload
       #    matches, accept the first arity-and-gradual-accept match
       #    (the v0.1.1 behaviour). Alias / Interface / Intersection
@@ -41,7 +41,7 @@ module Rigor
       # (instance vs singleton). Both kinds share the same arity and
       # acceptance shape; the difference is only in which `Definition`
       # the caller fetched.
-      module OverloadSelector # rubocop:disable Metrics/ModuleLength
+      module OverloadSelector
         module_function
 
         # @param method_definition [RBS::Definition::Method]
@@ -64,8 +64,8 @@ module Rigor
         #   back to the first declaration.
         # @return [RBS::MethodType, nil] the chosen overload, or nil
         #   when the definition has no method types at all.
-        # rubocop:disable Metrics/ParameterLists
-        def select(method_definition, arg_types:, self_type:, instance_type:, type_vars: {}, block_required: false)
+        def select(method_definition, arg_types:, self_type:, instance_type:, type_vars: {}, block_required: false,
+                   environment: nil)
           overloads = method_definition.method_types
           return nil if overloads.empty?
 
@@ -75,7 +75,7 @@ module Rigor
           # `accepts_param?` so overload selection sees the
           # tighter type when filtering candidates by argument
           # compatibility.
-          param_overrides = RbsExtended.param_type_override_map(method_definition)
+          param_overrides = RbsExtended.param_type_override_map(method_definition, environment: environment)
 
           # Pass 1: prefer overloads whose param types stay strict —
           # no translator-induced `Dynamic[Top]` from Alias /
@@ -113,7 +113,6 @@ module Rigor
 
           overloads.first
         end
-        # rubocop:enable Metrics/ParameterLists
 
         def overload_has_block?(method_type)
           method_type.respond_to?(:block) && method_type.block
@@ -122,7 +121,7 @@ module Rigor
         class << self
           private
 
-          # rubocop:disable Metrics/ParameterLists, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+          # rubocop:disable Metrics/ParameterLists
           def find_matching_overload(overloads, arg_types:, self_type:, instance_type:, type_vars:, block_required:,
                                      param_overrides:, strict:)
             return nil if strict && arg_types.any? { |t| untyped_arg?(t) }
@@ -141,7 +140,7 @@ module Rigor
               )
             end
           end
-          # rubocop:enable Metrics/ParameterLists, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+          # rubocop:enable Metrics/ParameterLists
 
           # Treats the literal `untyped` carrier (`Dynamic[Top]`)
           # as too imprecise to drive a strict-pass match. Other
@@ -194,7 +193,6 @@ module Rigor
             end
           end
 
-          # rubocop:disable Metrics/ParameterLists
           def matches?(method_type, arg_types, self_type:, instance_type:, type_vars:, param_overrides:)
             return false if method_type.respond_to?(:type_params) && rejects_keyword_required?(method_type)
 
@@ -213,7 +211,6 @@ module Rigor
               )
             end
           end
-          # rubocop:enable Metrics/ParameterLists
 
           # Slice 4 phase 2c does not pass keyword arguments through the
           # call site (caller passes only positional `arg_types`). An
@@ -258,7 +255,6 @@ module Rigor
             head
           end
 
-          # rubocop:disable Metrics/ParameterLists
           def accepts_param?(param, arg, self_type:, instance_type:, type_vars:, param_overrides:)
             param_type = param_overrides[param.name] || RbsTypeTranslator.translate(
               param.type,
@@ -269,7 +265,6 @@ module Rigor
             result = param_type.accepts(arg, mode: :gradual)
             result.yes? || result.maybe?
           end
-          # rubocop:enable Metrics/ParameterLists
         end
       end
     end

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

@@ -162,7 +162,8 @@ module Rigor
               kind: kind,
               args: args,
               type_vars: type_vars,
-              block_type: block_type
+              block_type: block_type,
+              environment: environment
             )
           rescue StandardError
             # Defensive: if RBS' definition builder raises on a broken
@@ -194,6 +195,18 @@ module Rigor
               ["Array", :instance, tuple_type_args(receiver)]
             when Type::HashShape
               ["Hash", :instance, hash_shape_type_args(receiver)]
+            when Type::BoundMethod
+              # `BoundMethod` is a precision-bearing alias for
+              # `Nominal[Method]`: it carries the
+              # `(receiver, method_name)` binding that
+              # `MethodFolding.try_backward` consumes at
+              # `.call` / `.()` / `[]`, but every other call
+              # site (`.owner` / `.name` / `.arity` / …) must
+              # still resolve through Method's RBS contract.
+              # Routing here keeps reflective Method methods
+              # working without forcing the carrier to
+              # collapse to a plain Nominal at construction.
+              ["Method", :instance, []]
             when Type::Dynamic
               receiver_descriptor(receiver.static_facet)
             end
@@ -241,15 +254,15 @@ module Rigor
             param_names.zip(receiver_args).to_h
           end
 
-          # rubocop:disable Metrics/ParameterLists
-          def translate_return_type(method_definition, class_name:, kind:, args:, type_vars:, block_type:)
+          def translate_return_type(method_definition, class_name:, kind:, args:, type_vars:, block_type:,
+                                    environment: nil)
             # Slice 4b-3 (ADR-7 § "Slice 4-A/4-B") — read the
             # return-type override through the merger so future
             # plugin / `:rbs_extended` bundles that also assert a
             # `return_type` slot at this call site compose with
             # the RBS::Extended directive instead of silently
             # racing it.
-            override = merged_return_type(method_definition)
+            override = merged_return_type(method_definition, environment: environment)
             return override if override
 
             instance_type = Type::Combinator.nominal_of(class_name)
@@ -265,7 +278,8 @@ module Rigor
               self_type: self_type,
               instance_type: instance_type,
               type_vars: type_vars,
-              block_required: !block_type.nil?
+              block_required: !block_type.nil?,
+              environment: environment
             )
             return nil unless method_type
 
@@ -278,7 +292,6 @@ module Rigor
               type_vars: full_type_vars
             )
           end
-          # rubocop:enable Metrics/ParameterLists
 
           # ADR-7 § "Slice 4-A/4-B" — folds the
           # `RBS::Extended` `return:` directive (and any
@@ -287,8 +300,8 @@ module Rigor
           # before consuming. Returns the merged return type
           # or nil when no contribution overrides the
           # RBS-declared return.
-          def merged_return_type(method_definition)
-            contribution = RbsExtended.read_flow_contribution(method_definition)
+          def merged_return_type(method_definition, environment: nil)
+            contribution = RbsExtended.read_flow_contribution(method_definition, environment: environment)
             return nil if contribution.nil?
 
             Rigor::FlowContribution::Merger.merge([contribution]).return_type
@@ -377,13 +390,15 @@ module Rigor
               class_name: class_name,
               kind: kind,
               args: args,
-              type_vars: type_vars
+              type_vars: type_vars,
+              environment: environment
             )
           rescue StandardError
             []
           end
 
-          def extract_block_param_types(method_definition, class_name:, kind:, args:, type_vars:)
+          def extract_block_param_types(method_definition, class_name:, kind:, args:, type_vars:,
+                                        environment: nil)
             instance_type = Type::Combinator.nominal_of(class_name)
             self_type =
               case kind
@@ -397,7 +412,8 @@ module Rigor
               self_type: self_type,
               instance_type: instance_type,
               type_vars: type_vars,
-              block_required: true
+              block_required: true,
+              environment: environment
             )
             return [] unless method_type
 

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

@@ -155,13 +155,13 @@ module Rigor
         # tier ahead of RBS sees the more precise carrier so
         # downstream narrowing (`if size > 0; …`) actually has a
         # range to intersect with.
-        SIZE_RETURNING_NOMINALS = {
-          "Array" => %i[size length count],
-          "String" => %i[length size bytesize],
-          "Hash" => %i[size length count],
-          "Set" => %i[size length count],
-          "Range" => %i[size length count]
-        }.freeze
+        SIZE_RETURNING_NOMINALS = Ractor.make_shareable({
+                                                          "Array" => %i[size length count],
+                                                          "String" => %i[length size bytesize],
+                                                          "Hash" => %i[size length count],
+                                                          "Set" => %i[size length count],
+                                                          "Range" => %i[size length count]
+                                                        })
         private_constant :SIZE_RETURNING_NOMINALS
 
         # When the difference removes the empty value of the
@@ -323,39 +323,45 @@ module Rigor
           # `dispatch_nominal_size` so size-returning calls on
           # a `Refined[String, *]` still tighten to
           # `non_negative_int`.
-          REFINED_STRING_PROJECTIONS = {
-            %i[lowercase downcase] => :refined_self,
-            %i[lowercase upcase] => :uppercase_string,
-            %i[uppercase upcase] => :refined_self,
-            %i[uppercase downcase] => :lowercase_string,
-            %i[numeric downcase] => :refined_self,
-            %i[numeric upcase] => :refined_self,
-            # Digit-only strings are case-invariant; the prefix
-            # letters in `0o…` / `0x…` are accepted by the
-            # predicate in either case so the predicate-subset
-            # is preserved across `#downcase` / `#upcase` even
-            # though the value-set element changes.
-            %i[decimal_int downcase] => :refined_self,
-            %i[decimal_int upcase] => :refined_self,
-            %i[octal_int downcase] => :refined_self,
-            %i[octal_int upcase] => :refined_self,
-            %i[hex_int downcase] => :refined_self,
-            %i[hex_int upcase] => :refined_self,
-            # v0.1.1 Track 1 slice 2 — `to_i` / `to_int` on a
-            # known digit-only string. `decimal-int-string`
-            # (`/\A\d+\z/`) and `numeric-string` (Rigor's
-            # numeric-string predicate, ASCII digits) are
-            # predicates over digit-only strings, so the parse
-            # is total over the carrier domain and the result
-            # is always `>= 0`. `non-negative-int` is the
-            # tightest carrier that captures both the lower
-            # bound and the integer-ness without inventing a
-            # narrower carrier.
-            %i[decimal_int to_i] => :non_negative_int,
-            %i[decimal_int to_int] => :non_negative_int,
-            %i[numeric to_i] => :non_negative_int,
-            %i[numeric to_int] => :non_negative_int
-          }.freeze
+          # ADR-15 Phase 4b.x — `Ractor.make_shareable` (not `.freeze`)
+          # because the keys are two-element Symbol arrays whose
+          # inner arrays are unfrozen under shallow `.freeze`.
+          # Surfaced on Discourse via `Ractor::IsolationError` when
+          # the dispatch loop's `REFINED_STRING_PROJECTIONS[[id, sym]]`
+          # lookup ran from a worker Ractor.
+          REFINED_STRING_PROJECTIONS = Ractor.make_shareable({
+                                                               %i[lowercase downcase] => :refined_self,
+                                                               %i[lowercase upcase] => :uppercase_string,
+                                                               %i[uppercase upcase] => :refined_self,
+                                                               %i[uppercase downcase] => :lowercase_string,
+                                                               %i[numeric downcase] => :refined_self,
+                                                               %i[numeric upcase] => :refined_self,
+                                                               # Digit-only strings are case-invariant; the prefix
+                                                               # letters in `0o…` / `0x…` are accepted by the
+                                                               # predicate in either case so the predicate-subset
+                                                               # is preserved across `#downcase` / `#upcase` even
+                                                               # though the value-set element changes.
+                                                               %i[decimal_int downcase] => :refined_self,
+                                                               %i[decimal_int upcase] => :refined_self,
+                                                               %i[octal_int downcase] => :refined_self,
+                                                               %i[octal_int upcase] => :refined_self,
+                                                               %i[hex_int downcase] => :refined_self,
+                                                               %i[hex_int upcase] => :refined_self,
+                                                               # v0.1.1 Track 1 slice 2 — `to_i` / `to_int` on a
+                                                               # known digit-only string. `decimal-int-string`
+                                                               # (`/\A\d+\z/`) and `numeric-string` (Rigor's
+                                                               # numeric-string predicate, ASCII digits) are
+                                                               # predicates over digit-only strings, so the parse
+                                                               # is total over the carrier domain and the result
+                                                               # is always `>= 0`. `non-negative-int` is the
+                                                               # tightest carrier that captures both the lower
+                                                               # bound and the integer-ness without inventing a
+                                                               # narrower carrier.
+                                                               %i[decimal_int to_i] => :non_negative_int,
+                                                               %i[decimal_int to_int] => :non_negative_int,
+                                                               %i[numeric to_i] => :non_negative_int,
+                                                               %i[numeric to_int] => :non_negative_int
+                                                             })
           private_constant :REFINED_STRING_PROJECTIONS
 
           def dispatch_refined(refined, method_name, args)
@@ -626,7 +632,6 @@ module Rigor
           # (so it can serve as a Hash key). Produces a closed
           # `HashShape` whose entries mirror the per-position
           # pairs. Empty Tuples fold to the empty HashShape.
-          # rubocop:disable Metrics/CyclomaticComplexity
           def tuple_to_h(tuple, _method_name, args)
             return nil unless args.empty?
             return Type::Combinator.hash_shape_of({}) if tuple.elements.empty?
@@ -637,7 +642,6 @@ module Rigor
 
             Type::Combinator.hash_shape_of(pairs.to_h)
           end
-          # rubocop:enable Metrics/CyclomaticComplexity
 
           def tuple_to_h_pair(element)
             return nil unless element.is_a?(Type::Tuple)
@@ -865,7 +869,6 @@ module Rigor
           # `HashShape` accepts as keys). Duplicate values would
           # alias under inversion, so Rigor declines on
           # collisions rather than silently dropping entries.
-          # rubocop:disable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
           def hash_invert(shape, _method_name, args)
             return nil unless args.empty?
             return nil unless shape.closed?
@@ -880,7 +883,6 @@ module Rigor
             end
             Type::Combinator.hash_shape_of(inverted)
           end
-          # rubocop:enable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
 
           # `shape.first` — returns the first `[k, v]` pair as a
           # 2-Tuple, or `Constant[nil]` when the shape is empty.