rigortype 0.1.4 → 0.1.6

data/lib/rigor/inference/hkt_reducer.rb

@@ -0,0 +1,256 @@
+# frozen_string_literal: true
+
+require_relative "hkt_body"
+
+module Rigor
+  module Inference
+    # ADR-20 Slice 2a — reducer that walks a `Definition`'s
+    # `body_tree` against a concrete `Type::App` and returns a
+    # fully-typed `Rigor::Type`.
+    #
+    # Reduction is the operational interpretation of ADR-20
+    # § D4 ("Evaluation rules"):
+    #
+    # 1. **Resolve `F`.** Look up the registered body via
+    #    `registry.definition(uri)`.
+    # 2. **Substitute arguments.** Walk the body tree, replacing
+    #    `{HktBody::Param}` nodes with the matching positional
+    #    arg from the application.
+    # 3. **Build types.** `{HktBody::TypeLeaf}` returns its
+    #    wrapped type as-is; `{HktBody::Union}` and
+    #    `{HktBody::NominalApp}` route their reduced children
+    #    through `Type::Combinator.union` / `.nominal_of` so
+    #    normalization applies.
+    # 4. **Recurse on `{HktBody::AppRef}` nodes.** Reduce the
+    #    args first; if the resulting `(uri, args)` matches an
+    #    App already on the current reduction stack, return the
+    #    in-progress `Type::App` carrier as-is (lazy
+    #    self-reference handling — the standard "tying the
+    #    knot" trick for recursive type aliases like
+    #    `json::value`). Otherwise build a fresh
+    #    `Type::App` and recursively reduce it against the
+    #    same registry, sharing the fuel budget.
+    # 5. **Fuel budget.** Each visited node consumes one unit.
+    #    On exhaustion, reduction unwinds to `app.bound`.
+    #
+    # The reducer is **pure** with respect to its inputs (the
+    # registry + the App) but uses a per-call mutable state
+    # bag for fuel + cycle tracking. Concurrent reductions
+    # MUST allocate fresh reducers (or fresh `_reduce` calls)
+    # — the per-call state is not shared.
+    class HktReducer
+      DEFAULT_FUEL = 64
+
+      class FuelExhausted < StandardError; end
+
+      def initialize(registry)
+        raise ArgumentError, "registry must be an HktRegistry" unless registry.is_a?(HktRegistry)
+
+        @registry = registry
+      end
+
+      # Reduce `app` against the registry.
+      #
+      # @param app [Rigor::Type::App]
+      # @param fuel [Integer] reduction-step budget (default 64
+      #   per ADR-20 WD3). Each visited body node costs one
+      #   unit. On exhaustion the reduction returns `app.bound`.
+      # @return [Rigor::Type] the reduced type, or `app.bound`
+      #   when reduction is impossible (URI not defined, arity
+      #   mismatch, body_tree absent, fuel exhausted).
+      def reduce(app, fuel: DEFAULT_FUEL)
+        raise ArgumentError, "expected a Rigor::Type::App, got #{app.class}" unless app.is_a?(Type::App)
+
+        definition = @registry.definition(app.uri)
+        return app.bound if definition.nil? || definition.body_tree.nil?
+        return app.bound if definition.params.size != app.args.size
+
+        state = State.new(fuel: fuel)
+        begin
+          state.with_in_progress(app.uri, app.args, app) do
+            walk(definition.body_tree, bindings: bindings_for(definition, app.args), state: state) || app.bound
+          end
+        rescue FuelExhausted
+          app.bound
+        end
+      end
+
+      private
+
+      def bindings_for(definition, args)
+        definition.params.zip(args).to_h
+      end
+
+      def walk(node, bindings:, state:)
+        state.consume_fuel!
+
+        case node
+        when HktBody::TypeLeaf
+          node.type
+        when HktBody::Param
+          bindings.fetch(node.name) do
+            raise ArgumentError, "unknown param #{node.name.inspect}; declared: #{bindings.keys}"
+          end
+        when HktBody::Union
+          reduced = node.arms.map { |arm| walk(arm, bindings: bindings, state: state) }
+          Type::Combinator.union(*reduced)
+        when HktBody::NominalApp
+          reduced_args = node.args.map { |arg| walk(arg, bindings: bindings, state: state) }
+          Type::Combinator.nominal_of(node.class_name, type_args: reduced_args)
+        when HktBody::AppRef
+          reduced_args = node.args.map { |arg| walk(arg, bindings: bindings, state: state) }
+          reduce_app_ref(node.uri, reduced_args, state: state)
+        when HktBody::Conditional
+          walk_conditional(node, bindings: bindings, state: state)
+        else
+          raise ArgumentError, "unknown body node: #{node.class}"
+        end
+      end
+
+      # ADR-20 § D3 conditional reduction. Resolves the test
+      # against the current bindings and picks a branch:
+      #
+      # - test = `yes` → return the reduced `then_branch`.
+      # - test = `no`  → return the reduced `else_branch`.
+      # - test = `maybe` → widen to the union of both
+      #   reduced branches (per ADR-20 WD7).
+      def walk_conditional(node, bindings:, state:)
+        verdict = evaluate_test(node.test, bindings: bindings, state: state)
+        case verdict
+        when :yes
+          walk(node.then_branch, bindings: bindings, state: state)
+        when :no
+          walk(node.else_branch, bindings: bindings, state: state)
+        else
+          # `:maybe` — widen to the union of both branches.
+          then_t = walk(node.then_branch, bindings: bindings, state: state)
+          else_t = walk(node.else_branch, bindings: bindings, state: state)
+          Type::Combinator.union(then_t, else_t)
+        end
+      end
+
+      def evaluate_test(test, bindings:, state:)
+        case test
+        when HktBody::TestSubtype
+          left = walk(test.left, bindings: bindings, state: state)
+          right = walk(test.right, bindings: bindings, state: state)
+          subtype_verdict(left, right)
+        when HktBody::TestEquality
+          left = walk(test.left, bindings: bindings, state: state)
+          right = walk(test.right, bindings: bindings, state: state)
+          equality_verdict(left, right)
+        when HktBody::TestMembership
+          left = walk(test.left, bindings: bindings, state: state)
+          options = test.options.map { |o| walk(o, bindings: bindings, state: state) }
+          membership_verdict(left, options)
+        else
+          raise ArgumentError, "unknown test node: #{test.class}"
+        end
+      end
+
+      # `left <: right`. Slice 7a verdict policy: structural
+      # equality is `:yes`; clearly-disjoint nominal /
+      # constant pairs are `:no`; everything else is `:maybe`
+      # (widens to the union per ADR-20 WD7 — robustness
+      # principle keeps us conservative on undecided tests).
+      def subtype_verdict(left, right)
+        return :yes if left == right
+
+        # Both Nominals with different class names AND
+        # neither carries Dynamic — `:no` (statically
+        # disjoint). For any other shape pair, `:maybe`.
+        return :no if disjoint_nominals?(left, right)
+        return :no if disjoint_constants?(left, right)
+
+        :maybe
+      end
+
+      # Structural equality verdict — same shape as
+      # subtype_verdict but symmetric.
+      def equality_verdict(left, right)
+        return :yes if left == right
+        return :no if disjoint_nominals?(left, right)
+        return :no if disjoint_constants?(left, right)
+
+        :maybe
+      end
+
+      def membership_verdict(left, options)
+        verdicts = options.map { |o| equality_verdict(left, o) }
+        return :yes if verdicts.include?(:yes)
+        return :no if verdicts.all? { |v| v == :no }
+
+        :maybe
+      end
+
+      def disjoint_nominals?(left, right)
+        return false unless left.is_a?(Type::Nominal) && right.is_a?(Type::Nominal)
+
+        left.class_name != right.class_name
+      end
+
+      def disjoint_constants?(left, right)
+        return false unless left.is_a?(Type::Constant) && right.is_a?(Type::Constant)
+
+        left.value != right.value
+      end
+
+      def reduce_app_ref(uri, reduced_args, state:)
+        # Cycle detection — when the same `(uri, args)` is
+        # already on the reduction stack, return the
+        # in-progress App carrier as-is so recursive type
+        # aliases (`Array[App[json::value, K]]` inside the
+        # `json::value` body) terminate.
+        existing = state.in_progress_for(uri, reduced_args)
+        return existing if existing
+
+        registration = @registry.registration(uri)
+        bound = registration&.bound || Type::Combinator.untyped
+        new_app = Type::App.new(uri, reduced_args, bound: bound)
+
+        definition = @registry.definition(uri)
+        return new_app if definition.nil? || definition.body_tree.nil?
+        return new_app if definition.params.size != reduced_args.size
+
+        state.with_in_progress(uri, reduced_args, new_app) do
+          walk(definition.body_tree, bindings: bindings_for(definition, reduced_args), state: state) || new_app
+        end
+      end
+
+      # Per-call mutable bag carrying the remaining fuel
+      # budget and the active reduction stack (for cycle
+      # detection). Not shared across `reduce` calls.
+      class State
+        def initialize(fuel:)
+          @fuel = fuel
+          @in_progress = {}
+        end
+
+        def consume_fuel!
+          raise FuelExhausted if @fuel <= 0
+
+          @fuel -= 1
+        end
+
+        def in_progress_for(uri, args)
+          @in_progress[[uri, args]]
+        end
+
+        def with_in_progress(uri, args, app)
+          key = [uri, args]
+          previous = @in_progress[key]
+          @in_progress[key] = app
+          begin
+            yield
+          ensure
+            if previous.nil?
+              @in_progress.delete(key)
+            else
+              @in_progress[key] = previous
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rigor/inference/hkt_registry.rb

@@ -0,0 +1,223 @@
+# frozen_string_literal: true
+
+require_relative "hkt_body"
+
+module Rigor
+  module Inference
+    # ADR-20 § "Decision D1 / D2" — registry of Lightweight HKT
+    # tag registrations + type-function bodies parsed off the
+    # `%a{rigor:v1:hkt_register: ...}` /
+    # `%a{rigor:v1:hkt_define: ...}` annotations in shipped
+    # `.rbs` files.
+    #
+    # Slice 1 keeps the registry **opaque**: it stores the
+    # registration metadata (arity, variance, bound) and the
+    # un-evaluated definition body (a raw String — Slice 2
+    # introduces the conditional / indexed-access evaluator that
+    # parses the body and reduces `Type::App` instances against
+    # it). The carrier never needs to read from the registry
+    # because Slice 1's `Type::App` carries its `bound` directly;
+    # the registry exists at this slice solely so the parser
+    # round-trip and downstream slices have a stable target API.
+    #
+    # The registry is immutable after construction. Callers that
+    # need to extend it (e.g. plugin registrations layered on top
+    # of stdlib registrations) MUST build a new registry via
+    # `merge` rather than mutating an existing one. This keeps the
+    # registry shareable across Ractor boundaries per ADR-15.
+    class HktRegistry
+      # Frozen value object recording one tag registration.
+      #
+      # - `uri`: namespaced Symbol per ADR-20 WD1 (must include
+      #   `"::"`).
+      # - `arity`: positive Integer — the number of formal
+      #   parameters the registered constructor takes.
+      # - `variance`: ordered Array of Symbols, one per
+      #   parameter, each `:out` (covariant), `:in`
+      #   (contravariant), or `:inv` (invariant; default).
+      # - `bound`: a `Rigor::Type` to erase to when an `App`
+      #   referring to this URI cannot be reduced. Defaults to
+      #   `Dynamic[Top]` (the parser fills in the default when
+      #   the annotation omits `bound:`).
+      Registration = Data.define(:uri, :arity, :variance, :bound) do
+        def initialize(uri:, arity:, variance:, bound:)
+          raise ArgumentError, "uri must be a Symbol, got #{uri.class}" unless uri.is_a?(Symbol)
+          raise ArgumentError, "uri must be namespaced as `:a::b`, got #{uri.inspect}" unless uri.to_s.include?("::")
+          unless arity.is_a?(Integer) && arity.positive?
+            raise ArgumentError,
+                  "arity must be a positive Integer, got #{arity.inspect}"
+          end
+          raise ArgumentError, "variance must be an Array, got #{variance.class}" unless variance.is_a?(Array)
+          raise ArgumentError, "variance must have #{arity} entries, got #{variance.size}" unless variance.size == arity
+
+          variance.each do |v|
+            unless %i[out in inv].include?(v)
+              raise ArgumentError, "variance entries must be :out, :in, or :inv, got #{v.inspect}"
+            end
+          end
+          raise ArgumentError, "bound must not be nil" if bound.nil?
+
+          super(uri: uri, arity: arity, variance: variance.dup.freeze, bound: bound)
+        end
+      end
+
+      # Frozen value object recording one type-function
+      # definition.
+      #
+      # `body` is the raw String payload from the `%a{...}`
+      # annotation (Slice 1's parser populates it). It stays
+      # opaque until Slice 2b's body-string parser lands.
+      #
+      # `body_tree` is the optional evaluable form: a
+      # `Rigor::Inference::HktBody::*` node tree the Slice 2a
+      # reducer walks against the application's concrete
+      # arguments. Plugin and Rigor-bundled overlay authors
+      # construct it programmatically through
+      # {with_body_tree}; the Slice 2b string parser will set
+      # it from `body` once it ships. The reducer treats a
+      # `nil` `body_tree` as "definition not yet evaluable"
+      # and returns the registered bound.
+      Definition = Data.define(:uri, :params, :body, :body_tree, :source_path, :source_line) do
+        def initialize(uri:, params:, body:, body_tree: nil, source_path: nil, source_line: nil)
+          raise ArgumentError, "uri must be a Symbol, got #{uri.class}" unless uri.is_a?(Symbol)
+          raise ArgumentError, "params must be an Array, got #{params.class}" unless params.is_a?(Array)
+
+          params.each do |p|
+            raise ArgumentError, "params entries must be Symbols, got #{p.inspect}" unless p.is_a?(Symbol)
+          end
+          raise ArgumentError, "body must be a String, got #{body.class}" unless body.is_a?(String)
+
+          super(
+            uri: uri,
+            params: params.dup.freeze,
+            body: body,
+            body_tree: body_tree,
+            source_path: source_path,
+            source_line: source_line
+          )
+        end
+      end
+
+      # Convenience constructor for callers that have a body
+      # tree but no raw String — typically Rigor-bundled HKT
+      # overlays that build the body programmatically. The
+      # raw `body` slot is filled with an empty placeholder
+      # so existing consumers keep their type contract.
+      def self.definition_with_body_tree(uri:, params:, body_tree:, source_path: nil, source_line: nil)
+        Definition.new(
+          uri: uri,
+          params: params,
+          body: "",
+          body_tree: body_tree,
+          source_path: source_path,
+          source_line: source_line
+        )
+      end
+
+      attr_reader :registrations, :definitions
+
+      # @param registrations [Array<Registration>]
+      # @param definitions [Array<Definition>]
+      def initialize(registrations: [], definitions: [])
+        @registrations = registrations.to_h { |r| [r.uri, r] }.freeze
+        @definitions = definitions.to_h { |d| [d.uri, d] }.freeze
+        freeze
+      end
+
+      def registered?(uri)
+        @registrations.key?(uri)
+      end
+
+      def defined?(uri)
+        @definitions.key?(uri)
+      end
+
+      def registration(uri)
+        @registrations[uri]
+      end
+
+      def definition(uri)
+        @definitions[uri]
+      end
+
+      # @return [HktRegistry] a new registry whose entries are
+      #   the union of this registry's and `other`'s. On URI
+      #   collisions `other`'s entries win (last-write-wins; OQ3
+      #   tentative).
+      def merge(other)
+        raise ArgumentError, "merge target must be an HktRegistry, got #{other.class}" unless other.is_a?(HktRegistry)
+
+        self.class.new(
+          registrations: @registrations.merge(other.registrations).values,
+          definitions: @definitions.merge(other.definitions).values
+        )
+      end
+
+      def empty?
+        @registrations.empty? && @definitions.empty?
+      end
+
+      # ADR-20 Slice 2a — reduce an `App` against this
+      # registry. Convenience wrapper around `HktReducer.new(self).reduce`.
+      # Each call allocates a fresh reducer; concurrent
+      # reductions are safe.
+      def reduce(app, fuel: HktReducer::DEFAULT_FUEL)
+        HktReducer.new(self).reduce(app, fuel: fuel)
+      end
+
+      # ADR-20 slice 2e — scan a Rigor RbsLoader for
+      # `rigor:v1:hkt_register` / `rigor:v1:hkt_define`
+      # annotations attached to class- or module-level
+      # declarations in the loaded RBS env, parse them via
+      # {Rigor::RbsExtended::HktDirectives}, and return a new
+      # registry that is the union of `base` and every parsed
+      # entry. Last-write-wins on URI collisions per
+      # {#merge}'s contract. Fail-soft on per-annotation parse
+      # errors (the reporter records an `:info` entry; the
+      # other annotations still apply).
+      #
+      # @param rbs_loader [Rigor::Environment::RbsLoader]
+      # @param base [HktRegistry] starting registry (typically
+      #   the bundled `Rigor::Builtins::HktBuiltins.registry`).
+      # @param name_scope [Rigor::Environment::NameScope, nil]
+      #   threaded through to the bound resolver for class-name
+      #   lookups; safe to omit during scanning since hkt
+      #   bounds are typically `untyped` or stdlib classes.
+      # @param reporter [#record, nil] same fail-soft reporter
+      #   contract the other RBS-extended parsers use.
+      def self.scan_rbs_loader(rbs_loader, base: EMPTY, name_scope: nil, reporter: nil)
+        return base if rbs_loader.nil?
+
+        # Required lazily here to avoid a hard circular
+        # require between hkt_registry / hkt_directives;
+        # HktDirectives requires HktRegistry to construct its
+        # value objects.
+        require_relative "../rbs_extended/hkt_directives"
+
+        registrations = []
+        definitions = []
+
+        rbs_loader.each_class_decl_annotation do |annotation_string, source_location|
+          reg = Rigor::RbsExtended::HktDirectives.parse_register(
+            annotation_string, name_scope: name_scope, reporter: reporter, source_location: source_location
+          )
+          registrations << reg if reg
+
+          defn = Rigor::RbsExtended::HktDirectives.parse_define(
+            annotation_string, reporter: reporter, source_location: source_location
+          )
+          definitions << defn if defn
+        end
+
+        return base if registrations.empty? && definitions.empty?
+
+        overlay = new(registrations: registrations, definitions: definitions)
+        base.merge(overlay)
+      end
+
+      EMPTY = new.freeze
+    end
+  end
+end
+
+require_relative "hkt_reducer"

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