rigortype 0.1.4 → 0.1.5

data/lib/rigor/environment.rb

@@ -2,6 +2,12 @@
 
 require_relative "environment/class_registry"
 require_relative "environment/rbs_loader"
+require_relative "environment/reflection"
+require_relative "environment/bundle_sig_discovery"
+require_relative "environment/lockfile_resolver"
+require_relative "environment/rbs_collection_discovery"
+require_relative "environment/rbs_coverage_report"
+require_relative "inference/synthetic_method_index"
 require_relative "type_node/name_scope"
 require_relative "type_node/resolver_chain"
 
@@ -40,11 +46,19 @@ module Rigor
       pathname optparse json yaml fileutils tempfile tmpdir
       stringio forwardable digest securerandom
       uri logger date
+      pp delegate observable abbrev find tsort singleton
+      shellwords benchmark base64 did_you_mean
+      monitor mutex_m timeout
+      open3 erb etc ipaddr bigdecimal bigdecimal-math
+      prettyprint random-formatter time open-uri resolv
+      csv pstore objspace io-console cgi cgi-escape
+      strscan
       prism rbs
     ].freeze
 
     attr_reader :class_registry, :rbs_loader, :plugin_registry, :dependency_source_index,
-                :rbs_extended_reporter, :boundary_cross_reporter, :name_scope
+                :rbs_extended_reporter, :boundary_cross_reporter, :name_scope,
+                :synthetic_method_index
 
     # @param class_registry [Rigor::Environment::ClassRegistry]
     # @param rbs_loader [Rigor::Environment::RbsLoader, nil] when nil the
@@ -67,13 +81,15 @@ module Rigor
     #   participates and the dispatcher tier is a no-op.
     def initialize(class_registry: ClassRegistry.default, rbs_loader: nil,
                    plugin_registry: nil, dependency_source_index: nil,
-                   rbs_extended_reporter: nil, boundary_cross_reporter: nil)
+                   rbs_extended_reporter: nil, boundary_cross_reporter: nil,
+                   synthetic_method_index: nil)
       @class_registry = class_registry
       @rbs_loader = rbs_loader
       @plugin_registry = plugin_registry
       @dependency_source_index = dependency_source_index
       @rbs_extended_reporter = rbs_extended_reporter
       @boundary_cross_reporter = boundary_cross_reporter
+      @synthetic_method_index = synthetic_method_index || Inference::SyntheticMethodIndex::EMPTY
       @name_scope = build_name_scope
       freeze
     end
@@ -104,14 +120,57 @@ module Rigor
       #   reflection artefacts) consult the cache. Pass `nil` (the
       #   default) to skip caching for this environment.
       # @return [Rigor::Environment]
-      def for_project(root: Dir.pwd, libraries: [], signature_paths: nil, cache_store: nil, # rubocop:disable Metrics/ParameterLists
+      # rubocop:disable Metrics/MethodLength, Metrics/ParameterLists
+      def for_project(root: Dir.pwd, libraries: [], signature_paths: nil, cache_store: nil,
                       plugin_registry: nil, dependency_source_index: nil,
-                      rbs_extended_reporter: nil, boundary_cross_reporter: nil)
+                      rbs_extended_reporter: nil, boundary_cross_reporter: nil,
+                      bundler_bundle_path: nil, bundler_auto_detect: false,
+                      bundler_lockfile: nil,
+                      rbs_collection_lockfile: nil, rbs_collection_auto_detect: false,
+                      synthetic_method_index: nil)
         resolved_paths = signature_paths || default_signature_paths(root)
+        # O4 MVP — append per-gem `sig/` directories discovered
+        # under the target project's bundler install root. Empty
+        # array when neither an explicit path nor auto-detection
+        # finds a bundle. Order: user `signature_paths:` win first
+        # (semantic precedence inside `RbsLoader.build_env_for`);
+        # gem-shipped sigs append last so user overrides stay
+        # authoritative.
+        #
+        # O4 Layer 3 — when a Gemfile.lock is available (explicit
+        # `bundler_lockfile:` or auto-detected next to the project
+        # root), use the locked gem set to filter the discovered
+        # `sig/` directories. Stale gems in the bundle install
+        # tree (out-of-band installs, version drift after a
+        # `bundle update`) are silently dropped so only gems the
+        # project actually declares contribute RBS.
+        locked = LockfileResolver.locked_gems(
+          lockfile_path: bundler_lockfile,
+          project_root: root,
+          auto_detect: bundler_auto_detect
+        )
+        gem_sig_paths = BundleSigDiscovery.discover(
+          bundle_path: bundler_bundle_path,
+          project_root: root,
+          auto_detect: bundler_auto_detect,
+          locked_gems: locked.empty? ? nil : locked
+        ).map(&:to_s)
+        # O4 Layer 3 slice 2 — when `rbs collection install`
+        # has been run for the target project, parse the
+        # resulting `rbs_collection.lock.yaml` and feed each
+        # gem's `<collection_path>/<name>/<version>/` directory
+        # into `signature_paths:`. Stdlib-typed entries are
+        # skipped (already covered by `DEFAULT_LIBRARIES`).
+        collection_paths = RbsCollectionDiscovery.discover(
+          lockfile_path: rbs_collection_lockfile,
+          project_root: root,
+          auto_detect: rbs_collection_auto_detect
+        ).map(&:to_s)
+        loader_signature_paths = resolved_paths + gem_sig_paths + collection_paths
         merged_libraries = (DEFAULT_LIBRARIES + libraries.map(&:to_s)).uniq
         loader = RbsLoader.new(
           libraries: merged_libraries,
-          signature_paths: resolved_paths,
+          signature_paths: loader_signature_paths,
           cache_store: cache_store
         )
         new(
@@ -119,9 +178,11 @@ module Rigor
           plugin_registry: plugin_registry,
           dependency_source_index: dependency_source_index,
           rbs_extended_reporter: rbs_extended_reporter,
-          boundary_cross_reporter: boundary_cross_reporter
+          boundary_cross_reporter: boundary_cross_reporter,
+          synthetic_method_index: synthetic_method_index
         )
       end
+      # rubocop:enable Metrics/MethodLength, Metrics/ParameterLists
 
       private
 
@@ -185,6 +246,17 @@ module Rigor
       class_known_in_rbs?(name)
     end
 
+    # ADR-15 Phase 2b — returns the loader's read-only,
+    # `Ractor.shareable?` query surface as a frozen
+    # {Environment::Reflection}. Built lazily on first
+    # access; subsequent calls return the same instance.
+    # Returns `nil` when the environment carries no RBS
+    # loader (test-only `Environment.new` without
+    # `rbs_loader:`).
+    def reflection
+      @rbs_loader&.reflection
+    end
+
     # Compares two class/module names using analyzer-owned class data.
     # Returns `:equal`, `:subclass`, `:superclass`, `:disjoint`, or
     # `:unknown`. The static registry handles built-ins cheaply; the RBS

data/lib/rigor/inference/acceptance.rb

@@ -327,10 +327,44 @@ module Rigor
           )
           return class_result if class_result.no?
 
-          args_result = accepts_nominal_args(self_type, other_type, mode)
+          # Parametrized-ancestor projection. When `actual <:= target`
+          # holds at the class level but the type-arg arities differ,
+          # the actual's parametrization has to be projected into the
+          # target's view before the element-wise covariance check.
+          # The canonical case is `Hash[K, V] <:= Enumerable[[K, V]]`:
+          # Hash carries two type_args, Enumerable carries one, and
+          # the inherited parametrization at the Enumerable boundary
+          # is `Tuple[K, V]`. RBS encodes this as
+          # `include Enumerable[[K, V]]` in `Hash`'s definition.
+          projected_other = project_to_target_arity(self_type, other_type) || other_type
+          args_result = accepts_nominal_args(self_type, projected_other, mode)
           combine_results(class_result, args_result, mode)
         end
 
+        # Returns `other_type` rewritten so its type_args have the
+        # same arity as `self_type.type_args`, or `nil` if no
+        # projection is known. Today only the Hash → Enumerable
+        # projection is hand-rolled; a general RBS-driven
+        # implementation that consults `definition.ancestors[i].args`
+        # for arbitrary subclass / module-include relations is the
+        # principled follow-up.
+        def project_to_target_arity(self_type, other_type)
+          return nil if self_type.type_args.size == other_type.type_args.size
+          return nil if self_type.type_args.empty? || other_type.type_args.empty?
+
+          if self_type.class_name == "Enumerable" &&
+             other_type.class_name == "Hash" &&
+             self_type.type_args.size == 1 &&
+             other_type.type_args.size == 2
+            return Type::Combinator.nominal_of(
+              "Hash",
+              type_args: [Type::Combinator.tuple_of(*other_type.type_args)]
+            )
+          end
+
+          nil
+        end
+
         def project_tuple_to_nominal(tuple)
           if tuple.elements.empty?
             Type::Combinator.nominal_of(Array)

data/lib/rigor/inference/builtins/method_catalog.rb

@@ -30,7 +30,16 @@ module Rigor
         def initialize(path:, mutating_selectors: {})
           @path = path
           @mutating_selectors = mutating_selectors.transform_values(&:freeze).freeze
-          @catalog = nil
+          # ADR-15 Phase 4b.x — eager-load so the instance is
+          # safe to `Ractor.make_shareable`. Lazy init via
+          # `@catalog ||= load_catalog` would write to a
+          # potentially-frozen instance the first time a
+          # worker Ractor consults the catalog, raising
+          # `FrozenError`. The YAML parse is a once-per-process
+          # cost and the catalogs are constructed at module
+          # load time anyway, so eager init is free in
+          # practice.
+          @catalog = load_catalog
         end
 
         def safe_for_folding?(class_name, selector, kind: :instance)
@@ -52,7 +61,7 @@ module Rigor
         end
 
         def reset!
-          @catalog = nil
+          @catalog = load_catalog
         end
 
         private
@@ -72,9 +81,7 @@ module Rigor
           per_class.include?(selector.to_sym) || per_class.include?(selector_str.to_sym)
         end
 
-        def catalog
-          @catalog ||= load_catalog
-        end
+        attr_reader :catalog
 
         def load_catalog
           return EMPTY_CATALOG unless File.exist?(@path)

data/lib/rigor/inference/builtins/numeric_catalog.rb

@@ -68,15 +68,21 @@ module Rigor
           # Used by tests to drop the cached catalog so a different
           # path or content can be exercised. Production code MUST
           # NOT call this during normal operation.
+          #
+          # ADR-15 Phase 4b.x — reset re-loads eagerly so the
+          # singleton-class `@catalog` ivar stays populated, and
+          # the loaded Hash is deep-shared via `Ractor.make_shareable`
+          # so a worker Ractor reading the ivar via `catalog.dig(...)`
+          # does not trip `Ractor::IsolationError`. Plain `.freeze`
+          # is insufficient: YAML parses to a nested Hash/Array/String
+          # graph and only the outer Hash would be frozen.
           def reset!
-            @catalog = nil
+            @catalog = Ractor.make_shareable(load_catalog)
           end
 
           private
 
-          def catalog
-            @catalog ||= load_catalog
-          end
+          attr_reader :catalog
 
           def load_catalog
             return EMPTY_CATALOG unless File.exist?(CATALOG_PATH)
@@ -87,6 +93,11 @@ module Rigor
             EMPTY_CATALOG
           end
         end
+
+        # ADR-15 Phase 4b.x — eager-load on the main Ractor at
+        # module-load time so worker Ractors only READ the
+        # populated singleton-class `@catalog` ivar.
+        reset!
       end
     end
   end

data/lib/rigor/inference/expression_typer.rb

@@ -6,6 +6,7 @@ require_relative "../type"
 require_relative "../ast"
 require_relative "block_parameter_binder"
 require_relative "fallback"
+require_relative "macro_block_self_type"
 require_relative "method_dispatcher"
 
 module Rigor
@@ -1194,16 +1195,25 @@ module Rigor
           arg_types: arg_types,
           environment: scope.environment
         )
-        block_return_for(block_arg, expected)
+        # ADR-16 Tier A: when a registered plugin's `block_as_methods`
+        # entry matches `(receiver_type, call_node.name)`, narrow the
+        # block body's `self_type` to the receiver class's instance
+        # type. The narrowing is `nil` for unmatched calls, leaving
+        # the existing scope contract unchanged.
+        narrowed_self = MacroBlockSelfType.narrow_self_type_for(
+          scope: scope, call_node: call_node, receiver_type: receiver_type
+        )
+        block_return_for(block_arg, expected, narrowed_self_type: narrowed_self)
       rescue StandardError
         nil
       end
 
-      def block_return_for(block_arg, expected)
+      def block_return_for(block_arg, expected, narrowed_self_type: nil)
         case block_arg
         when Prism::BlockNode
           bindings = BlockParameterBinder.new(expected_param_types: expected).bind(block_arg)
           block_scope = bindings.reduce(scope) { |acc, (name, type)| acc.with_local(name, type) }
+          block_scope = block_scope.with_self_type(narrowed_self_type) if narrowed_self_type
           type_block_body(block_arg, block_scope)
         when Prism::BlockArgumentNode
           symbol_block_return_type(block_arg, expected)

data/lib/rigor/inference/macro_block_self_type.rb

@@ -0,0 +1,96 @@
+# frozen_string_literal: true
+
+require_relative "../type"
+
+module Rigor
+  module Inference
+    # ADR-16 Tier A — engine hook. Consults every registered
+    # plugin manifest's `block_as_methods` entries to decide
+    # whether a block call site qualifies for `Scope#self_type`
+    # narrowing.
+    #
+    # The match contract for a class-level DSL like Sinatra's
+    # `class MyApp < Sinatra::Base; get '/foo' do ... end; end`:
+    #
+    # - the call's lexical receiver type is `Singleton[X]`
+    #   (the implicit-self in a class body, or an explicit
+    #   `MyApp.get(...)` call);
+    # - the underlying class `X` equals or inherits from the
+    #   entry's `receiver_constraint`;
+    # - the call's method name is in the entry's `verbs`.
+    #
+    # On a match the helper returns the **instance** type of
+    # the receiver class (`Nominal[X]`) — the narrowed
+    # `self_type` for the block body, matching Sinatra's
+    # runtime semantics where `Sinatra::Base#generate_method`
+    # turns the block into an instance method of the user's
+    # app class.
+    #
+    # Slice 1b ships the floor only (per ADR-16 § WD13):
+    # bare-identifier method lookups inside the block resolve
+    # through the inference engine's normal `self_type`-driven
+    # path, so methods declared on `Sinatra::Base` (RBS or
+    # otherwise) become visible. Precision additions —
+    # parameter-typed block params, declared per-verb argument
+    # contracts — are ceiling concerns for later slices.
+    module MacroBlockSelfType
+      module_function
+
+      # @param scope         [Rigor::Scope]
+      # @param call_node     [Prism::CallNode]
+      # @param receiver_type [Rigor::Type, nil]
+      # @return [Rigor::Type, nil] the narrowed self-type, or
+      #   `nil` when no registered entry matches the call shape.
+      def narrow_self_type_for(scope:, call_node:, receiver_type:)
+        return nil if receiver_type.nil?
+
+        environment = scope&.environment
+        registry = environment&.plugin_registry
+        return nil if registry.nil? || registry.empty?
+
+        receiver_class_name = singleton_receiver_class_name(receiver_type)
+        return nil if receiver_class_name.nil?
+
+        verb = call_node.name
+        registry.plugins.each do |plugin|
+          plugin.manifest.block_as_methods.each do |entry| # rigor:disable undefined-method
+            return instance_type_for(receiver_class_name, environment) if matches?(entry, verb, receiver_class_name,
+                                                                                   environment)
+          end
+        end
+        nil
+      end
+
+      # Tier A's match contract is intentionally narrow:
+      # class-level DSL calls (receiver is `Singleton[X]`) only.
+      # Instance-receiver calls and DSL forms whose block body
+      # binds a different `self` (Concern's `included do`,
+      # `instance_eval { ... }`) are handled by later slices
+      # (Concern walker, Tier D, etc.) — not Tier A.
+      def singleton_receiver_class_name(receiver_type)
+        return nil unless receiver_type.is_a?(Type::Singleton)
+
+        receiver_type.class_name
+      end
+
+      def matches?(entry, verb, receiver_class_name, environment)
+        return false unless entry.verbs.include?(verb)
+
+        receiver_class_inherits_from?(receiver_class_name, entry.receiver_constraint, environment)
+      end
+
+      def receiver_class_inherits_from?(class_name, constraint, environment)
+        return true if class_name == constraint
+
+        ordering = environment.class_ordering(class_name, constraint)
+        %i[equal subclass].include?(ordering)
+      rescue StandardError
+        false
+      end
+
+      def instance_type_for(class_name, environment)
+        environment.nominal_for_name(class_name) || Type::Nominal.new(class_name)
+      end
+    end
+  end
+end

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

@@ -1028,10 +1028,10 @@ module Rigor
         # class's ancestor chain at lookup time; the catalog
         # corresponds to the module-mode YAML at
         # `data/builtins/ruby_core/<topic>.yml`.
-        MODULE_CATALOGS = [
-          [Comparable, Builtins::COMPARABLE_CATALOG, "Comparable"],
-          [Enumerable, Builtins::ENUMERABLE_CATALOG, "Enumerable"]
-        ].freeze
+        MODULE_CATALOGS = Ractor.make_shareable([
+                                                  [Comparable, Builtins::COMPARABLE_CATALOG, "Comparable"],
+                                                  [Enumerable, Builtins::ENUMERABLE_CATALOG, "Enumerable"]
+                                                ])
         private_constant :MODULE_CATALOGS
 
         # Returns the `(catalog, class_name)` pairs for every
@@ -1057,31 +1057,31 @@ module Rigor
         # Otherwise a `DateTime` receiver would match the `Date`
         # arm first and the catalog would consult the Date entry
         # in `DATE_CATALOG` for the wrong class.
-        CATALOG_BY_CLASS = [
-          [Integer,  [Builtins::NumericCatalog, "Integer"]],
-          [Float,    [Builtins::NumericCatalog, "Float"]],
-          [String,   [Builtins::STRING_CATALOG, "String"]],
-          [Symbol,   [Builtins::STRING_CATALOG, "Symbol"]],
-          [Array,    [Builtins::ARRAY_CATALOG,  "Array"]],
-          [Hash,     [Builtins::HASH_CATALOG,   "Hash"]],
-          [Range,    [Builtins::RANGE_CATALOG,  "Range"]],
-          [::Set,    [Builtins::SET_CATALOG,    "Set"]],
-          [Time,     [Builtins::TIME_CATALOG,   "Time"]],
-          [DateTime, [Builtins::DATE_CATALOG,   "DateTime"]],
-          [Date,     [Builtins::DATE_CATALOG,   "Date"]],
-          [Rational, [Builtins::RATIONAL_CATALOG, "Rational"]],
-          [Complex,  [Builtins::COMPLEX_CATALOG,  "Complex"]],
-          [Pathname, [Builtins::PATHNAME_CATALOG, "Pathname"]],
-          [Random, [Builtins::RANDOM_CATALOG, "Random"]],
-          [Struct, [Builtins::STRUCT_CATALOG, "Struct"]],
-          [Encoding, [Builtins::ENCODING_CATALOG, "Encoding"]],
-          [Regexp, [Builtins::REGEXP_CATALOG, "Regexp"]],
-          [MatchData, [Builtins::REGEXP_CATALOG, "MatchData"]],
-          [Proc, [Builtins::PROC_CATALOG, "Proc"]],
-          [Method, [Builtins::PROC_CATALOG, "Method"]],
-          [UnboundMethod, [Builtins::PROC_CATALOG, "UnboundMethod"]],
-          [Exception, [Builtins::EXCEPTION_CATALOG, "Exception"]]
-        ].freeze
+        CATALOG_BY_CLASS = Ractor.make_shareable([
+                                                   [Integer, [Builtins::NumericCatalog, "Integer"]],
+                                                   [Float,    [Builtins::NumericCatalog, "Float"]],
+                                                   [String,   [Builtins::STRING_CATALOG, "String"]],
+                                                   [Symbol,   [Builtins::STRING_CATALOG, "Symbol"]],
+                                                   [Array,    [Builtins::ARRAY_CATALOG,  "Array"]],
+                                                   [Hash,     [Builtins::HASH_CATALOG,   "Hash"]],
+                                                   [Range,    [Builtins::RANGE_CATALOG,  "Range"]],
+                                                   [::Set,    [Builtins::SET_CATALOG,    "Set"]],
+                                                   [Time,     [Builtins::TIME_CATALOG,   "Time"]],
+                                                   [DateTime, [Builtins::DATE_CATALOG,   "DateTime"]],
+                                                   [Date,     [Builtins::DATE_CATALOG,   "Date"]],
+                                                   [Rational, [Builtins::RATIONAL_CATALOG, "Rational"]],
+                                                   [Complex,  [Builtins::COMPLEX_CATALOG,  "Complex"]],
+                                                   [Pathname, [Builtins::PATHNAME_CATALOG, "Pathname"]],
+                                                   [Random, [Builtins::RANDOM_CATALOG, "Random"]],
+                                                   [Struct, [Builtins::STRUCT_CATALOG, "Struct"]],
+                                                   [Encoding, [Builtins::ENCODING_CATALOG, "Encoding"]],
+                                                   [Regexp, [Builtins::REGEXP_CATALOG, "Regexp"]],
+                                                   [MatchData, [Builtins::REGEXP_CATALOG, "MatchData"]],
+                                                   [Proc, [Builtins::PROC_CATALOG, "Proc"]],
+                                                   [Method, [Builtins::PROC_CATALOG, "Method"]],
+                                                   [UnboundMethod, [Builtins::PROC_CATALOG, "UnboundMethod"]],
+                                                   [Exception, [Builtins::EXCEPTION_CATALOG, "Exception"]]
+                                                 ])
         private_constant :CATALOG_BY_CLASS
 
         # Returns `[catalog, class_name]` for receivers we have a

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/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

@@ -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

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)