rigortype 0.1.3 → 0.1.5

data/lib/rigor/flow_contribution/merger.rb

@@ -55,7 +55,7 @@ module Rigor
     # In every conflict case the result keeps the higher-tier value
     # for that slot, records a {Conflict} with both provenances, and
     # continues processing the remaining slots / contributions.
-    module Merger # rubocop:disable Metrics/ModuleLength
+    module Merger
       AUTHORITY_TIERS = {
         builtin: 0,
         rbs_extended: 1,
@@ -112,7 +112,7 @@ module Rigor
           fold_role_conformance(state, contribution)
         end
 
-        def fold_return_type(state, contribution, tier) # rubocop:disable Metrics/AbcSize
+        def fold_return_type(state, contribution, tier)
           incoming = contribution.return_type
           return if incoming.nil?
 
@@ -202,7 +202,7 @@ module Rigor
           end
         end
 
-        def build_conflict(target:, edge:, kind:, reason:, provenances:, message:) # rubocop:disable Metrics/ParameterLists
+        def build_conflict(target:, edge:, kind:, reason:, provenances:, message:)
           Conflict.new(target: target, edge: edge, kind: kind, reason: reason,
                        provenances: provenances, message: message)
         end

data/lib/rigor/flow_contribution.rb

@@ -32,7 +32,7 @@ module Rigor
     # `descriptor` is the {Rigor::Cache::Descriptor} this
     # contribution attaches to (or `nil` when the contribution does
     # not need its own cache slice).
-    Provenance = Data.define(:source_family, :plugin_id, :node, :descriptor) do
+    class Provenance < Data.define(:source_family, :plugin_id, :node, :descriptor)
       def self.builtin
         new(source_family: :builtin, plugin_id: nil, node: nil, descriptor: nil)
       end
@@ -122,7 +122,7 @@ module Rigor
     # | role_conformance    | normal        | role                | (per-role target)       |
     #
     # @return [Array<Element>]
-    def to_element_list # rubocop:disable Metrics/AbcSize,Metrics/CyclomaticComplexity,Metrics/PerceivedComplexity
+    def to_element_list # rubocop:disable Metrics/AbcSize
       elements = []
       elements << element_for(:return, :normal, :return_type, return_type) unless return_type.nil?
       Array(truthy_facts).each { |fact| elements << element_for(fact_target(fact), :truthy, :truthy_fact, fact) }

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/block_parameter_binder.rb

@@ -45,7 +45,6 @@ module Rigor
     # scope MUST NOT observe them and the binder leaves them unbound.
     #
     # See docs/internal-spec/inference-engine.md for the binding contract.
-    # rubocop:disable Metrics/ClassLength
     class BlockParameterBinder
       # @param expected_param_types [Array<Rigor::Type>] positional block
       #   parameter types in order. Indices the binder cannot fill from
@@ -208,6 +207,5 @@ module Rigor
         @expected_param_types[index] || Type::Combinator.untyped
       end
     end
-    # rubocop:enable Metrics/ClassLength
   end
 end

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/coverage_scanner.rb

@@ -24,7 +24,7 @@ module Rigor
     # hot inference path: it allocates a tracer per visited node and discards
     # the inferred type values.
     class CoverageScanner
-      Result = Data.define(:visits, :unrecognized, :events) do
+      class Result < Data.define(:visits, :unrecognized, :events)
         # @return [Integer] sum of all visits across node classes.
         def visited_count
           visits.values.sum

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
@@ -111,7 +112,21 @@ module Rigor
         Prism::IndexOrWriteNode => :type_of_assignment_write,
         Prism::IndexAndWriteNode => :type_of_assignment_write,
         Prism::MultiWriteNode => :type_of_assignment_write,
+        # LHS-only target nodes (destructuring assignment, pattern matching,
+        # `for x in xs`, block parameter `|a, (b, c)|`). They have no value
+        # to extract — the type-of pass acknowledges the node class so the
+        # coverage scanner stops flagging it; binding the inner names back
+        # into the scope is the StatementEvaluator / MultiTargetBinder /
+        # BlockParameterBinder side's concern.
         Prism::LocalVariableTargetNode => :type_of_non_value,
+        Prism::MultiTargetNode => :type_of_non_value,
+        Prism::InstanceVariableTargetNode => :type_of_non_value,
+        Prism::ClassVariableTargetNode => :type_of_non_value,
+        Prism::GlobalVariableTargetNode => :type_of_non_value,
+        Prism::ConstantTargetNode => :type_of_non_value,
+        Prism::ConstantPathTargetNode => :type_of_non_value,
+        Prism::CallTargetNode => :type_of_non_value,
+        Prism::IndexTargetNode => :type_of_non_value,
         # Hashes and interpolation
         Prism::HashNode => :type_of_hash,
         Prism::KeywordHashNode => :type_of_hash,
@@ -931,7 +946,6 @@ module Rigor
       # for the CallNode itself (the inner type_of calls already record
       # their own fallbacks for unrecognised receivers/args, so the tracer
       # captures both the immediate dispatch miss and the deeper cause).
-      # rubocop:disable Metrics/CyclomaticComplexity
       def call_type_for(node)
         receiver = call_receiver_type_for(node)
         arg_types = call_arg_types(node)
@@ -1004,7 +1018,6 @@ module Rigor
 
         fallback_for(node, family: :prism)
       end
-      # rubocop:enable Metrics/CyclomaticComplexity
 
       # v0.0.2 #5 — re-types the body of a user-defined
       # instance method with the call site's argument types
@@ -1160,9 +1173,20 @@ module Rigor
       # when typing the body raises (defensive against malformed
       # subtrees); the dispatcher then runs in its no-block-aware
       # path.
+      #
+      # ADR-14 gap-#3 (d): a `Prism::BlockArgumentNode` carrying
+      # `&:symbol` (the Symbol#to_proc shorthand) is treated as
+      # a block. The block's return type is computed by
+      # dispatching `:symbol` on the expected block param type
+      # (per `Symbol#to_proc`'s `{ |x| x.symbol }` semantics).
+      # A precise inner dispatch produces the right return; any
+      # failure step falls back to `Dynamic[Top]` so the
+      # dispatcher still SEES a block — selecting the block-
+      # bearing overload of e.g. `Hash#transform_values` over
+      # the no-block overload that returns `Enumerator`.
       def block_return_type_for(call_node, receiver_type, arg_types)
-        block_node = call_node.block
-        return nil unless block_node.is_a?(Prism::BlockNode)
+        block_arg = call_node.block
+        return nil if block_arg.nil?
         return nil if receiver_type.nil?
 
         expected = MethodDispatcher.expected_block_param_types(
@@ -1171,13 +1195,59 @@ module Rigor
           arg_types: arg_types,
           environment: scope.environment
         )
-        bindings = BlockParameterBinder.new(expected_param_types: expected).bind(block_node)
-        block_scope = bindings.reduce(scope) { |acc, (name, type)| acc.with_local(name, type) }
-        type_block_body(block_node, block_scope)
+        # 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, 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)
+        end
+      end
+
+      # `&:symbol` desugars to a one-arg Proc that dispatches
+      # `symbol` against its argument. When the param type is
+      # known and the resulting inner dispatch is precise,
+      # this returns the precise carrier; otherwise it
+      # returns `Dynamic[Top]` (still non-nil) so the outer
+      # dispatcher selects the block-bearing overload.
+      # `&proc_local` / `&method(:foo)` and friends — anything
+      # not a bare SymbolNode — still resolve to
+      # `Dynamic[Top]` for the same block-presence signal.
+      def symbol_block_return_type(block_arg, expected_param_types)
+        expression = block_arg.expression
+        return dynamic_top unless expression.is_a?(Prism::SymbolNode)
+
+        param_type = expected_param_types&.first
+        return dynamic_top if param_type.nil?
+
+        result = MethodDispatcher.dispatch(
+          receiver_type: param_type,
+          method_name: expression.unescaped.to_sym,
+          arg_types: [],
+          block_type: nil,
+          environment: scope.environment,
+          call_node: block_arg,
+          scope: scope
+        )
+        result || dynamic_top
+      end
+
       def type_block_body(block_node, block_scope)
         body = block_node.body
         return Type::Combinator.constant_of(nil) if body.nil?
@@ -1213,7 +1283,6 @@ module Rigor
       PER_ELEMENT_RANGE_LIMIT = 8
       private_constant :PER_ELEMENT_RANGE_LIMIT
 
-      # rubocop:disable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
       def try_per_element_block_fold(call_node, receiver_type)
         return nil unless PER_ELEMENT_TUPLE_METHODS.include?(call_node.name)
         return nil if find_family_with_args?(call_node)
@@ -1231,7 +1300,6 @@ module Rigor
 
         assemble_per_element_result(call_node.name, per_position, element_types)
       end
-      # rubocop:enable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
 
       # Returns the per-position element types for a finite,
       # statically-known receiver shape — or nil when the
@@ -1254,7 +1322,6 @@ module Rigor
         end
       end
 
-      # rubocop:disable Metrics/CyclomaticComplexity
       def constant_range_elements(value)
         return nil unless value.is_a?(Range)
         return nil unless value.begin.is_a?(Integer) && value.end.is_a?(Integer)
@@ -1264,7 +1331,6 @@ module Rigor
 
         value.to_a.map { |v| Type::Combinator.constant_of(v) }
       end
-      # rubocop:enable Metrics/CyclomaticComplexity
 
       # `index(value)` and `find_index(value)` carry a positional
       # argument and search by `==` rather than running the block.

data/lib/rigor/inference/fallback.rb

@@ -20,7 +20,7 @@ module Rigor
     # - inner_type: the Rigor::Type returned to the caller (currently
     #   always Dynamic[Top]; later slices may carry richer fallback
     #   types).
-    Fallback = Data.define(:node_class, :location, :family, :inner_type) do
+    class Fallback < Data.define(:node_class, :location, :family, :inner_type)
       def initialize(node_class:, location:, family:, inner_type:)
         raise ArgumentError, "node_class must be a Class, got #{node_class.class}" unless node_class.is_a?(Class)
 

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/block_folding.rb

@@ -37,7 +37,7 @@ module Rigor
       # tuple — element-wise block re-evaluation against
       # `Constant<Array>` receivers (the `map` / `filter_map` /
       # `flat_map` precision tier) is reserved for a later slice.
-      module BlockFolding # rubocop:disable Metrics/ModuleLength
+      module BlockFolding
         module_function
 
         FILTER_KEEP_ON_TRUTHY = Set[:select, :filter, :take_while].freeze
@@ -69,7 +69,6 @@ module Rigor
         #   the call's block. `nil` means "no block at the call site"
         #   and disqualifies every rule here.
         # @return [Rigor::Type, nil]
-        # rubocop:disable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
         def try_fold(receiver:, method_name:, args:, block_type:)
           return nil if receiver.nil? || block_type.nil?
 
@@ -86,7 +85,6 @@ module Rigor
             fold_count(receiver, truthiness, args)
           end
         end
-        # rubocop:enable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
 
         def filter_method?(method_name)
           FILTER_KEEP_ON_TRUTHY.include?(method_name) ||
@@ -154,7 +152,7 @@ module Rigor
         end
 
         # @return [:always_true, :always_false, :bool, nil]
-        # rubocop:disable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+        # rubocop:disable Metrics/CyclomaticComplexity
         def predicate_decision(method_name, truthiness, emptiness)
           case method_name
           when :all?
@@ -177,7 +175,7 @@ module Rigor
             :bool
           end
         end
-        # rubocop:enable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+        # rubocop:enable Metrics/CyclomaticComplexity
 
         def bool_union
           Type::Combinator.union(

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

@@ -149,7 +149,6 @@ module Rigor
         #   and runs the format. Symbol keys are kept as
         #   Symbols (matching Ruby's `%{key}` resolution).
         # Anything else declines so the RBS tier widens.
-        # rubocop:disable Metrics/CyclomaticComplexity
         def try_fold_string_format(receiver, method_name, args)
           return nil unless method_name == :%
           return nil unless args.size == 1
@@ -166,7 +165,6 @@ module Rigor
         rescue StandardError
           nil
         end
-        # rubocop:enable Metrics/CyclomaticComplexity
 
         def format_argument_value(arg)
           case arg
@@ -275,7 +273,6 @@ module Rigor
           [result]
         end
 
-        # rubocop:disable Metrics/CyclomaticComplexity
         def try_fold_unary_set(receiver_values, method_name)
           range_lift = try_fold_range_constant_unary(receiver_values, method_name)
           return range_lift if range_lift
@@ -299,8 +296,6 @@ module Rigor
           end
           build_constant_type(results, source: receiver_values)
         end
-        # rubocop:enable Metrics/CyclomaticComplexity
-
         # v0.0.7 — `Constant<Range>#to_a` and the no-arg
         # `first` / `last` / `min` / `max` short-circuit through a
         # Range-specific arm that catalog dispatch cannot reach:
@@ -353,7 +348,6 @@ module Rigor
           Type::Combinator.constant_of(edge == :first ? values.first : values.last)
         end
 
-        # rubocop:disable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
         def try_fold_binary_set(receiver_values, method_name, arg_values)
           string_lift = try_fold_string_array_binary(receiver_values, method_name, arg_values)
           return string_lift if string_lift
@@ -369,8 +363,6 @@ module Rigor
           end
           build_constant_type(results, source: receiver_values + arg_values)
         end
-        # rubocop:enable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
-
         # v0.0.7 — `Constant<String>#chars` / `bytes` / `lines` /
         # `split` (no-arg) return a Ruby Array of foldable
         # scalars; `foldable_constant_value?` rejects Array
@@ -425,7 +417,6 @@ module Rigor
           nil
         end
 
-        # rubocop:disable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
         def try_fold_pathname_binary(receiver_values, method_name, arg_values)
           return nil unless PATHNAME_PURE_BINARY.include?(method_name)
           return nil unless receiver_values.size == 1 && arg_values.size == 1
@@ -442,7 +433,6 @@ module Rigor
         rescue StandardError
           nil
         end
-        # rubocop:enable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
 
         def try_fold_string_array_unary(receiver_values, method_name)
           return nil unless STRING_ARRAY_UNARY_METHODS.include?(method_name)
@@ -459,7 +449,6 @@ module Rigor
         # `Constant<String>#split(arg)` / `#scan(arg)` — lift the
         # Array result to a Tuple when both sides are statically
         # known and the cardinality fits.
-        # rubocop:disable Metrics/CyclomaticComplexity
         def try_fold_string_array_binary(receiver_values, method_name, arg_values)
           return nil unless STRING_ARRAY_BINARY_METHODS.include?(method_name)
           return nil unless receiver_values.size == 1 && arg_values.size == 1
@@ -473,7 +462,6 @@ module Rigor
         rescue StandardError
           nil
         end
-        # rubocop:enable Metrics/CyclomaticComplexity
 
         def lift_array_result(result)
           return nil unless result.is_a?(Array)
@@ -1040,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
@@ -1069,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