rigortype 0.1.4 → 0.1.6

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

@@ -76,6 +76,21 @@ module Rigor
           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,
@@ -92,7 +107,9 @@ module Rigor
         # 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).
-        BACKWARD_METHOD_NAMES = %i[call []].freeze
+        # `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)

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

@@ -3,6 +3,7 @@
 require_relative "../../type"
 require_relative "../acceptance"
 require_relative "../rbs_type_translator"
+require_relative "receiver_affinity"
 
 module Rigor
   module Inference
@@ -26,7 +27,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
@@ -44,6 +45,33 @@ module Rigor
       module OverloadSelector
         module_function
 
+        # Canonical RBS-core aliases shipped by `core/builtin.rbs`
+        # whose body is `<Nominal> | _DuckType`. Matching an
+        # overload against an Integer literal should pick the
+        # `(int) -> Array[Elem]` body over the `(string) -> String`
+        # body because Integer satisfies `int`'s strict arm and
+        # not `string`'s. The translator collapses both aliases
+        # to `Dynamic[Top]` (interfaces are not structurally
+        # matched yet), so a dedicated pass 1.5 between strict
+        # and gradual consults this map to pick the alias whose
+        # strict arm matches.
+        #
+        # Symbol keys are the alias names as they appear under
+        # `RBS::Types::Alias#name.to_s` (the `name` is a
+        # `TypeName` whose `to_s` includes the `::` prefix).
+        # Values are an Array of class names whose Nominal[..]
+        # form is the alias's strict-arm matcher.
+        ALIAS_STRICT_NOMINALS = {
+          "::int" => ["Integer"],
+          "::string" => ["String"],
+          "::interned" => %w[Symbol String],
+          "::io" => ["IO"],
+          "::encoding" => %w[Encoding String],
+          "::path" => ["String"],
+          "::boolean" => %w[TrueClass FalseClass]
+        }.freeze
+        private_constant :ALIAS_STRICT_NOMINALS
+
         # @param method_definition [RBS::Definition::Method]
         # @param arg_types [Array<Rigor::Type>] caller-provided types in
         #   positional order. Empty when there are no arguments.
@@ -77,36 +105,19 @@ module Rigor
           # compatibility.
           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 /
-          # Interface / Intersection. The pass is skipped
-          # entirely when any arg is `Dynamic[Top]` (literally
-          # `untyped`), because gradual acceptance against an
-          # untyped arg accepts every param indiscriminately and
-          # would let pass 1 lock in an arbitrary strict overload
-          # (e.g. `Regexp#=~(nil) -> nil` over the
-          # `(::interned?) -> Integer?` overload). Pass 2 falls
-          # back to the original gradual matcher so overloads
-          # that legitimately rely on duck-typed params still
-          # resolve when nothing stricter applies.
-          match = find_matching_overload(
-            overloads,
-            arg_types: arg_types,
-            self_type: self_type,
-            instance_type: instance_type,
-            type_vars: type_vars,
-            block_required: block_required,
-            param_overrides: param_overrides,
-            strict: true
-          ) || find_matching_overload(
-            overloads,
-            arg_types: arg_types,
-            self_type: self_type,
-            instance_type: instance_type,
-            type_vars: type_vars,
-            block_required: block_required,
-            param_overrides: param_overrides,
-            strict: false
+          # Pre-sort: demote overloads whose param class is a
+          # disjoint sibling of the receiver class (e.g.
+          # `Integer#+(BigDecimal) -> BigDecimal` from the
+          # `bigdecimal` RBS reopen). Honors the coerce
+          # convention so `5 + ?` for unknown `?` resolves to
+          # the receiver-class-preserving arm rather than an
+          # arbitrary sibling-class arm that only wins by
+          # overload-list position.
+          overloads = ReceiverAffinity.reorder(overloads, self_type: self_type, environment: environment)
+
+          match = run_selection_passes(
+            overloads, arg_types: arg_types, self_type: self_type, instance_type: instance_type,
+                       type_vars: type_vars, block_required: block_required, param_overrides: param_overrides
           )
           return match if match
           return overloads.find { |mt| overload_has_block?(mt) } if block_required
@@ -121,6 +132,30 @@ module Rigor
         class << self
           private
 
+          # Three-pass overload search:
+          # - Pass 1 (strict): skipped when any arg is
+          #   `Dynamic[Top]`, because gradual acceptance against
+          #   an untyped arg accepts every param indiscriminately
+          #   and would let pass 1 lock in an arbitrary strict
+          #   overload (e.g. `Regexp#=~(nil) -> nil` over the
+          #   `(::interned?) -> Integer?` overload).
+          # - Pass 1.5 (alias-resolved): consults each `RBS::Types::Alias`'s
+          #   strict arm so e.g. `Array#*(int)` wins over the
+          #   `Array#*(string) -> String` overload for Integer args.
+          # - Pass 2 (gradual): the original gradual matcher so
+          #   overloads that legitimately rely on duck-typed
+          #   params still resolve when nothing stricter applies.
+          def run_selection_passes(overloads, arg_types:, self_type:, instance_type:, type_vars:, block_required:,
+                                   param_overrides:)
+            shared = {
+              arg_types: arg_types, self_type: self_type, instance_type: instance_type,
+              type_vars: type_vars, block_required: block_required, param_overrides: param_overrides
+            }
+            find_matching_overload(overloads, **shared, strict: true) ||
+              find_matching_overload_via_aliases(overloads, arg_types: arg_types, block_required: block_required) ||
+              find_matching_overload(overloads, **shared, strict: false)
+          end
+
           # rubocop:disable Metrics/ParameterLists
           def find_matching_overload(overloads, arg_types:, self_type:, instance_type:, type_vars:, block_required:,
                                      param_overrides:, strict:)
@@ -150,6 +185,66 @@ module Rigor
             type.is_a?(Type::Dynamic) && type.static_facet.is_a?(Type::Top)
           end
 
+          # Pass 1.5: for arity-compatible overloads whose every
+          # positional param is either a strict nominal OR a
+          # well-known core alias (`int` / `string` / `interned`
+          # / etc.), check the arg against the alias's STRICT
+          # arm. An Integer literal arg matches `int` here but
+          # not `string`, so `Array#*(int)` wins over the
+          # `Array#*(string) -> String` overload — even though
+          # both translate to `Dynamic[Top]` at the param level.
+          # Only fires when EVERY positional param has a known
+          # alias-or-strict shape; otherwise gradual matching
+          # takes over.
+          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)
+
+              fun = method_type.type
+              next false unless arity_compatible?(fun, arg_types.size)
+
+              params = positional_params_for(fun, arg_types.size)
+              next false unless params.size == arg_types.size
+
+              params.zip(arg_types).all? { |param, arg| alias_param_accepts?(param.type, arg) }
+            end
+          end
+
+          # Checks the param's RBS type against an arg using
+          # alias-strict-arm matching. Optional / Union wrappers
+          # are flattened; alias resolution is one level deep
+          # (the canonical core aliases all have non-alias
+          # strict arms).
+          def alias_param_accepts?(rbs_type, arg)
+            nominal_names = strict_nominal_names_for(rbs_type)
+            return false if nominal_names.nil? || nominal_names.empty?
+
+            nominal_names.any? do |class_name|
+              result = Type::Combinator.nominal_of(class_name).accepts(arg, mode: :gradual)
+              result.yes? || result.maybe?
+            end
+          end
+
+          # Returns the candidate class names a param's RBS type
+          # accepts under alias-resolved strict matching, or nil
+          # when the shape cannot be reduced to a closed set of
+          # nominals (e.g. an Interface or an unrecognised alias).
+          def strict_nominal_names_for(rbs_type)
+            case rbs_type
+            when RBS::Types::ClassInstance
+              [rbs_type.name.to_s.delete_prefix("::")]
+            when RBS::Types::Alias
+              ALIAS_STRICT_NOMINALS[rbs_type.name.to_s]
+            when RBS::Types::Optional
+              strict_nominal_names_for(rbs_type.type)
+            when RBS::Types::Union
+              parts = rbs_type.types.map { |t| strict_nominal_names_for(t) }
+              return nil if parts.any?(&:nil?)
+
+              parts.flatten
+            end
+          end
+
           # Returns true when every positional param the call
           # site engages translates to a non-`Dynamic[Top]`
           # carrier. Alias / Interface / Intersection RBS types

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

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+require_relative "../../type"
+
+module Rigor
+  module Inference
+    module MethodDispatcher
+      # Stable-sort an overload list so that "receiver-affinity"
+      # arms come first. An overload is receiver-affinity-matching
+      # when every positional param's class equals `self_type`'s
+      # class name OR is one of its proper RBS ancestors. The
+      # canonical case the helper exists for: when `bigdecimal`'s
+      # stdlib RBS reopens `Integer#+` at the FRONT of the
+      # overload list with `(BigDecimal) -> BigDecimal`, that
+      # disjoint-sibling arm would win every dispatch for
+      # `Integer#+(?)` by overload-list position alone, returning
+      # a spurious `BigDecimal` for plain integer arithmetic.
+      # Demoting the arm honours the coerce convention: when the
+      # arg type is unknown or itself an Integer, the
+      # receiver-preserving `(Integer) -> Integer` arm should win.
+      #
+      # No-op when (a) the environment can't answer
+      # `class_ordering` (nil env), or (b) the receiver isn't a
+      # nominal / singleton carrying a class name. The partition
+      # is stable, so within each bucket the RBS-declared order
+      # is preserved.
+      module ReceiverAffinity
+        module_function
+
+        def reorder(overloads, self_type:, environment:)
+          return overloads if environment.nil?
+
+          self_class_name = self_type_class_name(self_type)
+          return overloads if self_class_name.nil?
+
+          affinity, other = overloads.partition do |mt|
+            overload_param_classes_in_ancestry?(mt, self_class_name, environment)
+          end
+          affinity + other
+        end
+
+        class << self
+          private
+
+          def self_type_class_name(self_type)
+            case self_type
+            when Type::Nominal, Type::Singleton then self_type.class_name
+            end
+          end
+
+          def overload_param_classes_in_ancestry?(method_type, self_class_name, environment)
+            fun = method_type.type
+            params = fun.required_positionals + fun.optional_positionals + fun.trailing_positionals
+            return false if params.empty?
+
+            params.all? { |param| param_class_in_ancestry?(param.type, self_class_name, environment) }
+          end
+
+          # Walks Optional and Union one level so `(Numeric?)` and
+          # `(Integer | Float)` still classify when every branch
+          # sits in the ancestry. Non-`ClassInstance` shapes
+          # (Alias / Interface / Intersection / type variables)
+          # don't carry a clean class identity and therefore
+          # disqualify the overload from the affinity bucket.
+          def param_class_in_ancestry?(rbs_type, self_class_name, environment)
+            case rbs_type
+            when RBS::Types::ClassInstance
+              class_in_ancestry?(rbs_type.name.to_s.delete_prefix("::"), self_class_name, environment)
+            when RBS::Types::Optional
+              param_class_in_ancestry?(rbs_type.type, self_class_name, environment)
+            when RBS::Types::Union
+              rbs_type.types.all? { |t| param_class_in_ancestry?(t, self_class_name, environment) }
+            else
+              false
+            end
+          end
+
+          def class_in_ancestry?(param_class_name, self_class_name, environment)
+            return true if param_class_name == self_class_name
+
+            environment.class_ordering(self_class_name, param_class_name) == :subclass
+          end
+        end
+      end
+    end
+  end
+end

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)