rigortype 0.2.7 → 0.2.8

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

@@ -1,12 +1,10 @@
 # frozen_string_literal: true
 
-# `Date` and `DateTime` live in CRuby's bundled `date` gem, which
-# is stdlib rather than core — so the constants are not visible
-# until `date` is required. The dispatcher's `CATALOG_BY_CLASS`
-# table references `Date` and `DateTime` at load time, so requiring
-# the gem here (alongside the loader file that exports the catalog)
-# keeps the wiring self-contained: a consumer that pulls in the
-# constant-folding rule book gets the Date constants for free.
+# `Date` and `DateTime` live in CRuby's bundled `date` gem, which is stdlib rather than core — so the
+# constants are not visible until `date` is required. The dispatcher's `CATALOG_BY_CLASS` table
+# references `Date` and `DateTime` at load time, so requiring the gem here (alongside the loader file
+# that exports the catalog) keeps the wiring self-contained: a consumer that pulls in the constant-folding
+# rule book gets the Date constants for free.
 require "date"
 
 require_relative "method_catalog"
@@ -14,78 +12,51 @@ require_relative "method_catalog"
 module Rigor
   module Inference
     module Builtins
-      # `Date` / `DateTime` catalog. Singleton — load once, consult
-      # during dispatch.
+      # `Date` / `DateTime` catalog. Singleton — load once, consult during dispatch.
       #
-      # `Date` and `DateTime` both come from CRuby's bundled `date`
-      # gem (`references/ruby/ext/date/date_core.c`). A single
-      # `Init_date_core` function registers them, so the catalog
-      # carries both classes — `Date` plus the `DateTime` subclass
-      # whose own Init block extends with `hour` / `min` /
-      # `strftime` / `iso8601` etc. The Ruby-side prelude
-      # (`lib/date.rb`) only contributes `Date#infinite?` and the
-      # nested `Date::Infinity` class; the bulk of the surface is
-      # in C.
+      # `Date` and `DateTime` both come from CRuby's bundled `date` gem (`references/ruby/ext/date/date_core.c`).
+      # A single `Init_date_core` function registers them, so the catalog carries both classes — `Date`
+      # plus the `DateTime` subclass whose own Init block extends with `hour` / `min` / `strftime` /
+      # `iso8601` etc. The Ruby-side prelude (`lib/date.rb`) only contributes `Date#infinite?` and the
+      # nested `Date::Infinity` class; the bulk of the surface is in C.
       #
-      # Date / DateTime receivers are not lifted to a `Constant`
-      # carrier today (there is no Date literal node — the closest
-      # is `Date.today` / `Date.parse(...)`, which produce
-      # `Nominal[Date]`). The catalog wiring therefore mostly
-      # governs:
+      # Date / DateTime receivers are not lifted to a `Constant` carrier today (there is no Date literal
+      # node — the closest is `Date.today` / `Date.parse(...)`, which produce `Nominal[Date]`). The
+      # catalog wiring therefore mostly governs:
       #
-      # 1. The Integer-typed reader surface (`#year`, `#month`,
-      #    `#day`, `#wday`, `#hour`, `#min`, `#sec`) — RBS-declared
-      #    `Integer` is preserved through dispatch.
-      # 2. The blocklist below, which keeps mutator-style methods
-      #    that the C-body classifier already flagged
-      #    (`mutates_self`) from being missed by a future
-      #    `Constant<Date>` carrier, plus a defensive
-      #    `:initialize_copy` entry for symmetry with the other
-      #    catalogs.
+      # 1. The Integer-typed reader surface (`#year`, `#month`, `#day`, `#wday`, `#hour`, `#min`, `#sec`) —
+      #    RBS-declared `Integer` is preserved through dispatch.
+      # 2. The blocklist below, which keeps mutator-style methods that the C-body classifier already
+      #    flagged (`mutates_self`) from being missed by a future `Constant<Date>` carrier, plus a
+      #    defensive `:initialize_copy` entry for symmetry with the other catalogs.
       #
-      # The non-bang `#next_day` / `#prev_day` / `#next_month` /
-      # `#prev_month` / `#next_year` / `#prev_year` / `#>>` / `#<<`
-      # selectors all RETURN brand-new `Date` objects rather than
-      # mutating the receiver — they intentionally stay
-      # catalog-eligible. The two real mutators
-      # (`#initialize_copy`, `#marshal_load`) are already classified
-      # `:mutates_self` by the C-body regex, so they fall out of
-      # `MethodCatalog#safe_for_folding?` without an explicit
-      # blocklist entry; the entries below are defense-in-depth
-      # against indirect mutators the regex might miss in a future
-      # CRuby bump.
+      # The non-bang `#next_day` / `#prev_day` / `#next_month` / `#prev_month` / `#next_year` /
+      # `#prev_year` / `#>>` / `#<<` selectors all RETURN brand-new `Date` objects rather than mutating the
+      # receiver — they intentionally stay catalog-eligible. The two real mutators (`#initialize_copy`,
+      # `#marshal_load`) are already classified `:mutates_self` by the C-body regex, so they fall out of
+      # `MethodCatalog#safe_for_folding?` without an explicit blocklist entry; the entries below are
+      # defense-in-depth against indirect mutators the regex might miss in a future CRuby bump.
       DATE_CATALOG = MethodCatalog.for_topic(
         "date",
         mutating_selectors: {
           "Date" => Set[
-            # `d_lite_initialize_copy` is already classed
-            # `:mutates_self` by the regex (it calls
-            # `rb_check_frozen` and rewrites the receiver's
-            # internal `dat` slots). Listed here for symmetry with
-            # String / Array / Range / Set / Time and to keep the
-            # blocklist self-documenting.
+            # `d_lite_initialize_copy` is already classed `:mutates_self` by the regex (it calls
+            # `rb_check_frozen` and rewrites the receiver's internal `dat` slots). Listed here for
+            # symmetry with String / Array / Range / Set / Time and to keep the blocklist
+            # self-documenting.
             :initialize_copy,
-            # `d_lite_fill` is a `#ifndef NDEBUG` debug method that
-            # warms the receiver's cached `simple` / `complex`
-            # fields via the `get_s_*` / `get_c_*` macros. The
-            # macros perform in-place writes on the receiver's
-            # internal `dat` struct but use no helper the C-body
-            # regex recognises, so the classifier mis-flags it
-            # `:leaf`. Blocked so a future `Constant<Date>` carrier
-            # never folds it.
+            # `d_lite_fill` is a `#ifndef NDEBUG` debug method that warms the receiver's cached `simple` /
+            # `complex` fields via the `get_s_*` / `get_c_*` macros. The macros perform in-place writes on
+            # the receiver's internal `dat` struct but use no helper the C-body regex recognises, so the
+            # classifier mis-flags it `:leaf`. Blocked so a future `Constant<Date>` carrier never folds it.
             :fill
           ],
           "DateTime" => Set[
-            # `DateTime` inherits the bulk of its surface from
-            # `Date`. The dedicated DateTime-side methods are all
-            # readers (`hour`, `min`, …) plus formatting
-            # converters (`strftime`, `iso8601`, …); none mutate
-            # the receiver. The single defensive entry mirrors the
-            # Date side so that the inherited
-            # `Date#initialize_copy` (registered against
-            # `cDateTime` through subclassing) cannot fold through
-            # the catalog if a future `Constant<DateTime>` carrier
-            # ever lands.
+            # `DateTime` inherits the bulk of its surface from `Date`. The dedicated DateTime-side methods
+            # are all readers (`hour`, `min`, …) plus formatting converters (`strftime`, `iso8601`, …);
+            # none mutate the receiver. The single defensive entry mirrors the Date side so that the
+            # inherited `Date#initialize_copy` (registered against `cDateTime` through subclassing) cannot
+            # fold through the catalog if a future `Constant<DateTime>` carrier ever lands.
             :initialize_copy
           ]
         }

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

@@ -5,55 +5,41 @@ require_relative "method_catalog"
 module Rigor
   module Inference
     module Builtins
-      # `Encoding` catalog. Singleton — load once, consult during
-      # dispatch.
+      # `Encoding` catalog. Singleton — load once, consult during dispatch.
       #
-      # Encoding instances are deep-frozen value objects: once
-      # registered, their `name` / `dummy?` / `ascii_compatible?`
-      # slots never change and the C bodies for the per-instance
-      # methods are pure. The C-body classifier therefore lands
-      # every instance method as `:leaf` correctly.
+      # Encoding instances are deep-frozen value objects: once registered, their `name` / `dummy?` /
+      # `ascii_compatible?` slots never change and the C bodies for the per-instance methods are pure.
+      # The C-body classifier therefore lands every instance method as `:leaf` correctly.
       #
-      # The blocklist focuses on the *singleton* surface where the
-      # hidden state is the process-wide encoding registry. Every
-      # method classified `:leaf` on the singleton actually reads
-      # (or, for the setters, writes) a global, so a hypothetical
-      # `Constant<Encoding>`-class receiver MUST NOT fold them
-      # against the analyzer process's registry — what UTF-8's
-      # alias list is in the analyzer is not necessarily what it
-      # is in the analysed program.
+      # The blocklist focuses on the *singleton* surface where the hidden state is the process-wide
+      # encoding registry. Every method classified `:leaf` on the singleton actually reads (or, for the
+      # setters, writes) a global, so a hypothetical `Constant<Encoding>`-class receiver MUST NOT fold
+      # them against the analyzer process's registry — what UTF-8's alias list is in the analyzer is not
+      # necessarily what it is in the analysed program.
       ENCODING_CATALOG = MethodCatalog.for_topic(
         "encoding",
         mutating_selectors: {
           "Encoding" => Set[
-            # Defence-in-depth: mirrors range_catalog.rb /
-            # complex_catalog.rb. Encoding does not currently
-            # expose a public `initialize_copy` (Encoding objects
-            # are deep-frozen and #dup is a no-op), but the
-            # convention keeps the door closed against future
-            # CRuby changes that would leak a copy-mutator.
+            # Defence-in-depth: mirrors range_catalog.rb / complex_catalog.rb. Encoding does not currently
+            # expose a public `initialize_copy` (Encoding objects are deep-frozen and #dup is a no-op),
+            # but the convention keeps the door closed against future CRuby changes that would leak a
+            # copy-mutator.
             :initialize_copy,
             :hash,
             :eql?,
-            # `Encoding.find(name)` walks the global encoding
-            # registry. Pure with respect to its argument but
-            # the registry itself can drift (load-order, locale,
-            # process-wide `default_external=` calls), so a
-            # constant-fold would lock in the analyzer's view.
+            # `Encoding.find(name)` walks the global encoding registry. Pure with respect to its argument
+            # but the registry itself can drift (load-order, locale, process-wide `default_external=`
+            # calls), so a constant-fold would lock in the analyzer's view.
             :find,
-            # `Encoding.list` / `Encoding.aliases` /
-            # `Encoding.name_list` enumerate the same global
-            # registry. Same reasoning as `find` — the values
-            # are not guaranteed to match the analysed program's
-            # registry.
+            # `Encoding.list` / `Encoding.aliases` / `Encoding.name_list` enumerate the same global
+            # registry. Same reasoning as `find` — the values are not guaranteed to match the analysed
+            # program's registry.
             :list,
             :aliases,
             :name_list,
-            # Global-default mutators. `MethodCatalog#blocked?`
-            # only auto-blocks `!`-suffixed selectors, so we MUST
-            # list these explicitly: each writes the process-wide
-            # default-encoding slot read by `default_external` /
-            # `default_internal`.
+            # Global-default mutators. `MethodCatalog#blocked?` only auto-blocks `!`-suffixed selectors,
+            # so we MUST list these explicitly: each writes the process-wide default-encoding slot read by
+            # `default_external` / `default_internal`.
             :default_external=,
             :default_internal=
           ]

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

@@ -7,12 +7,10 @@ module Rigor
     module Builtins
       # `Enumerable` module catalog. Singleton — load once.
       #
-      # `Enumerable` is a Ruby module, not a class, so the
-      # catalog is NOT routed through
-      # `MethodDispatcher::ConstantFolding::CATALOG_BY_CLASS`
-      # (which dispatches on the receiver's concrete class).
-      # The data is wired into `MODULE_CATALOGS` in
-      # `MethodDispatcher::ConstantFolding` (ancestor-chain lookup).
+      # `Enumerable` is a Ruby module, not a class, so the catalog is NOT routed through
+      # `MethodDispatcher::ConstantFolding::CATALOG_BY_CLASS` (which dispatches on the receiver's concrete
+      # class). The data is wired into `MODULE_CATALOGS` in `MethodDispatcher::ConstantFolding`
+      # (ancestor-chain lookup).
       ENUMERABLE_CATALOG = MethodCatalog.for_topic(
         "enumerable",
         mutating_selectors: {

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

@@ -5,80 +5,61 @@ require_relative "method_catalog"
 module Rigor
   module Inference
     module Builtins
-      # `Exception` catalog. Singleton — load once, consult during
-      # dispatch.
+      # `Exception` catalog. Singleton — load once, consult during dispatch.
       #
-      # Exception is the base of every Ruby error class (RuntimeError,
-      # StandardError, KeyError, …). The Init_Exception block in
-      # `references/ruby/error.c` registers the entire hierarchy in
-      # one pass, so the YAML carries 27 classes — but only the base
-      # `Exception` row is wired into `CATALOG_BY_CLASS` for v0.0.5.
-      # A `RuntimeError` receiver hits the Exception arm via
-      # `is_a?(Exception)` and the catalog answers with the base-class
-      # entries; subclass-specific methods (`KeyError#receiver`,
-      # `NameError#name`, …) intentionally miss the lookup until a
-      # later slice routes per-subclass class_names.
+      # Exception is the base of every Ruby error class (RuntimeError, StandardError, KeyError, …). The
+      # Init_Exception block in `references/ruby/error.c` registers the entire hierarchy in one pass, so
+      # the YAML carries 27 classes — but only the base `Exception` row is wired into `CATALOG_BY_CLASS`
+      # for v0.0.5. A `RuntimeError` receiver hits the Exception arm via `is_a?(Exception)` and the
+      # catalog answers with the base-class entries; subclass-specific methods (`KeyError#receiver`,
+      # `NameError#name`, …) intentionally miss the lookup until a later slice routes per-subclass
+      # class_names.
       #
-      # The catalog tier here is *defence in depth* — every base
-      # method that could plausibly fold has been weighed against the
-      # robustness principle (strict on returns) and either left
-      # `:dispatch` / `:mutates_self` (in which case the catalog
-      # already declines) or blocklisted because the static classifier
-      # missed an indirect side effect. The remaining `:leaf` method
-      # that DOES fold is `#cause`, a pure accessor.
+      # The catalog tier here is *defence in depth* — every base method that could plausibly fold has
+      # been weighed against the robustness principle (strict on returns) and either left `:dispatch` /
+      # `:mutates_self` (in which case the catalog already declines) or blocklisted because the static
+      # classifier missed an indirect side effect. The remaining `:leaf` method that DOES fold is
+      # `#cause`, a pure accessor.
       EXCEPTION_CATALOG = MethodCatalog.for_topic(
         "exception",
         mutating_selectors: {
           "Exception" => Set[
-            # `exc_initialize` writes `mesg` / `backtrace` ivars on
-            # self via `rb_ivar_set` — the C-body classifier missed
-            # the indirect mutator because the helpers are not in
-            # its regex. Blocklisted so a hypothetical future
-            # `Constant<Exception>` carrier cannot fold an aliasing
+            # `exc_initialize` writes `mesg` / `backtrace` ivars on self via `rb_ivar_set` — the C-body
+            # classifier missed the indirect mutator because the helpers are not in its regex.
+            # Blocklisted so a hypothetical future `Constant<Exception>` carrier cannot fold an aliasing
             # constructor through the catalog.
             :initialize,
-            # `exc_exception` either returns self (no-arg) or calls
-            # `rb_obj_clone` + `exc_initialize_internal` on the
-            # clone — the clone branch mutates fresh state through
-            # the same indirect helpers as `:initialize`. Conservative
-            # blocklist; the cost is one folded no-arg call.
+            # `exc_exception` either returns self (no-arg) or calls `rb_obj_clone` +
+            # `exc_initialize_internal` on the clone — the clone branch mutates fresh state through the
+            # same indirect helpers as `:initialize`. Conservative blocklist; the cost is one folded
+            # no-arg call.
             :exception,
-            # `exc_detailed_message` formats with platform / locale
-            # data (highlight markers depend on `$stderr.tty?` via
-            # the keyword arg default and `rb_io_tty_p`). Folding
-            # would freeze a value that depends on the calling
-            # process's stderr state.
+            # `exc_detailed_message` formats with platform / locale data (highlight markers depend on
+            # `$stderr.tty?` via the keyword arg default and `rb_io_tty_p`). Folding would freeze a value
+            # that depends on the calling process's stderr state.
             :detailed_message,
-            # `exc_backtrace` reads the captured frame list, which
-            # depends on where the exception was raised — context
-            # the static fold tier cannot reproduce.
+            # `exc_backtrace` reads the captured frame list, which depends on where the exception was
+            # raised — context the static fold tier cannot reproduce.
             :backtrace,
-            # Same rationale as `:backtrace`; `Thread::Backtrace::Location`
-            # objects are runtime artefacts.
+            # Same rationale as `:backtrace`; `Thread::Backtrace::Location` objects are runtime artefacts.
             :backtrace_locations,
-            # `exc_set_backtrace` mutates the @backtrace ivar via
-            # `rb_ivar_set` — another indirect mutator the classifier
-            # missed.
+            # `exc_set_backtrace` mutates the @backtrace ivar via `rb_ivar_set` — another indirect
+            # mutator the classifier missed.
             :set_backtrace,
-            # `initialize_copy` is blocklisted by convention so a
-            # hypothetical future `Constant<Exception>` carrier
-            # cannot fold an aliasing copy through the catalog.
+            # `initialize_copy` is blocklisted by convention so a hypothetical future
+            # `Constant<Exception>` carrier cannot fold an aliasing copy through the catalog.
             :initialize_copy,
-            # Defensive entries for the universal mutation surface.
-            # Object-identity hashing on a constant carrier is fine,
-            # but `eql?` on Exception delegates to `==` (dispatch);
-            # blocking both keeps the constant-fold tier honest.
+            # Defensive entries for the universal mutation surface. Object-identity hashing on a constant
+            # carrier is fine, but `eql?` on Exception delegates to `==` (dispatch); blocking both keeps
+            # the constant-fold tier honest.
             :hash,
             :eql?
           ],
-          # `Exception.to_tty?` (singleton) calls
-          # `rb_io_tty_p($stderr)`; its return depends on the
-          # process's stderr state at runtime, never on compile-time
-          # arguments. The catalog tier today only consults
-          # `mutating_selectors` for instance-receiver dispatches via
-          # `CATALOG_BY_CLASS`, so this row is documentation-grade —
-          # it records the soundness rationale for any future slice
-          # that wires the singleton path through the catalog.
+          # `Exception.to_tty?` (singleton) calls `rb_io_tty_p($stderr)`; its return depends on the
+          # process's stderr state at runtime, never on compile-time arguments. The catalog tier today
+          # only consults `mutating_selectors` for instance-receiver dispatches via `CATALOG_BY_CLASS`, so
+          # this row is documentation-grade — it records the soundness rationale for any future slice that
+          # wires the singleton path through the catalog.
           "Exception.singleton" => Set[
             :to_tty?
           ]

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

@@ -7,27 +7,22 @@ module Rigor
     module Builtins
       # `Hash` catalog. Singleton — load once, consult during dispatch.
       #
-      # Hash mirrors Array's mutation pattern: nearly every iteration
-      # method yields through `rb_hash_foreach` plus a per-pair static
-      # callback (`each_value_i`, `keep_if_i`, …), and the C-body
-      # classifier does not follow into the callback so it lands as
-      # `:leaf` despite being block-dependent. The blocklist below
-      # captures every false-positive `:leaf` we have spotted in the
-      # generated YAML — bias toward conservatism so a missed fold is
-      # acceptable but a folded mutator/yielder is not.
+      # Hash mirrors Array's mutation pattern: nearly every iteration method yields through
+      # `rb_hash_foreach` plus a per-pair static callback (`each_value_i`, `keep_if_i`, …), and the C-body
+      # classifier does not follow into the callback so it lands as `:leaf` despite being block-dependent.
+      # The blocklist below captures every false-positive `:leaf` we have spotted in the generated YAML —
+      # bias toward conservatism so a missed fold is acceptable but a folded mutator/yielder is not.
       HASH_CATALOG = MethodCatalog.for_topic(
         "hash",
         mutating_selectors: {
           "Hash" => Set[
-            # Block-dependent iteration — yields via `rb_hash_foreach`
-            # plus a per-pair callback that the regex classifier does
-            # not follow:
+            # Block-dependent iteration — yields via `rb_hash_foreach` plus a per-pair callback that the
+            # regex classifier does not follow:
             :each, :each_pair, :each_key, :each_value,
             :select, :filter, :reject,
             :transform_values,
-            # Block-dependent merge — `rb_hash_merge` delegates into
-            # `rb_hash_update`, which yields per conflict when a block
-            # is given:
+            # Block-dependent merge — `rb_hash_merge` delegates into `rb_hash_update`, which yields per
+            # conflict when a block is given:
             :merge
           ]
         }

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

@@ -5,57 +5,44 @@ require "yaml"
 module Rigor
   module Inference
     module Builtins
-      # Generic loader for offline-generated catalogs under
-      # `data/builtins/ruby_core/<topic>.yml`. One instance per topic
-      # (numeric, string, array, …); each owns the path to its own
-      # YAML and the per-class blocklist of selectors the static
-      # classifier marked `:leaf` but that actually mutate the
-      # receiver (false positives the C-body heuristic does not
-      # catch).
+      # Generic loader for offline-generated catalogs under `data/builtins/ruby_core/<topic>.yml`. One
+      # instance per topic (numeric, string, array, …); each owns the path to its own YAML and the
+      # per-class blocklist of selectors the static classifier marked `:leaf` but that actually mutate the
+      # receiver (false positives the C-body heuristic does not catch).
       #
-      # `safe_for_folding?(class_name, selector, kind:)` returns true
-      # when:
+      # `safe_for_folding?(class_name, selector, kind:)` returns true when:
       # 1. The catalog has an entry for `(class_name, selector, kind)`,
-      # 2. The entry's `purity` is one of `leaf` / `trivial` /
-      #    `leaf_when_numeric`,
+      # 2. The entry's `purity` is one of `leaf` / `trivial` / `leaf_when_numeric`,
       # 3. The selector is NOT in the per-class mutation blocklist.
       #
-      # Missing catalog files (e.g. in a bare gem install where data
-      # was opted out) degrade to `false` so the dispatcher falls
-      # back to its hand-rolled allow lists.
+      # Missing catalog files (e.g. in a bare gem install where data was opted out) degrade to `false` so
+      # the dispatcher falls back to its hand-rolled allow lists.
       class MethodCatalog
         FOLDABLE_PURITIES = Set["leaf", "trivial", "leaf_when_numeric"].freeze
         EMPTY_CATALOG = { "classes" => {} }.freeze
 
-        # Selectors that are classified `:leaf` by the C-body analysis
-        # (they read no global mutable state in the C sense) but whose
-        # result is NOT reproducible across Ruby processes, so they must
-        # never be folded into a `Constant`:
+        # Selectors that are classified `:leaf` by the C-body analysis (they read no global mutable state
+        # in the C sense) but whose result is NOT reproducible across Ruby processes, so they must never
+        # be folded into a `Constant`:
         #
-        # - `hash` — every core `#hash` (`String`/`Symbol`/`Integer`/
-        #   `Float`/…) is salted with a per-process SipHash seed, so
-        #   `"x".hash` differs in every process. Folding bakes one
-        #   process's value into the type and the on-disk cache.
+        # - `hash` — every core `#hash` (`String`/`Symbol`/`Integer`/`Float`/…) is salted with a
+        #   per-process SipHash seed, so `"x".hash` differs in every process. Folding bakes one process's
+        #   value into the type and the on-disk cache.
         # - `object_id` / `__id__` — identity-allocated per process.
         #
-        # This is a UNIVERSAL block (across every catalogued class)
-        # because `hash` / `object_id` are `Object`-level and present on
-        # every receiver; a per-class blocklist would silently miss a
-        # class. The deterministic siblings (`inspect`, `to_s`) are
-        # unaffected.
+        # This is a UNIVERSAL block (across every catalogued class) because `hash` / `object_id` are
+        # `Object`-level and present on every receiver; a per-class blocklist would silently miss a class.
+        # The deterministic siblings (`inspect`, `to_s`) are unaffected.
         NON_REPRODUCIBLE_SELECTORS = Set[:hash, :object_id, :__id__].freeze
 
-        # Shared root for the offline-generated catalogues. Resolving it
-        # here keeps the repo-relative `../../../../` hop in one place
-        # instead of copying it into every per-topic loader.
+        # Shared root for the offline-generated catalogues. Resolving it here keeps the repo-relative
+        # `../../../../` hop in one place instead of copying it into every per-topic loader.
         DATA_ROOT = File.expand_path("../../../../data/builtins/ruby_core", __dir__)
         private_constant :DATA_ROOT
 
-        # Build a catalog for a named topic, resolving its YAML path
-        # under {DATA_ROOT}. Equivalent to `new(path: …)` for the common
-        # case where the file is `<topic>.yml`; prefer this over passing
-        # an explicit `File.expand_path` so the data-root hop stays
-        # centralised.
+        # Build a catalog for a named topic, resolving its YAML path under {DATA_ROOT}. Equivalent to
+        # `new(path: …)` for the common case where the file is `<topic>.yml`; prefer this over passing an
+        # explicit `File.expand_path` so the data-root hop stays centralised.
         def self.for_topic(topic, mutating_selectors: {})
           new(path: File.join(DATA_ROOT, "#{topic}.yml"), mutating_selectors: mutating_selectors)
         end
@@ -63,14 +50,10 @@ module Rigor
         def initialize(path:, mutating_selectors: {})
           @path = path
           @mutating_selectors = mutating_selectors.transform_values(&:freeze).freeze
-          # 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
+          # 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
@@ -117,11 +100,9 @@ module Rigor
         end
 
         def blocked?(class_name, selector)
-          # Bang-suffixed selectors are mutating by Ruby convention
-          # (`upcase!`, `concat`, etc. are listed explicitly below;
-          # this catches the rest). We bias toward false negatives:
-          # losing a fold opportunity is acceptable; folding a
-          # mutator is not.
+          # Bang-suffixed selectors are mutating by Ruby convention (`upcase!`, `concat`, etc. are listed
+          # explicitly below; this catches the rest). We bias toward false negatives: losing a fold
+          # opportunity is acceptable; folding a mutator is not.
           selector_str = selector.to_s
           return true if selector_str.end_with?("!")
 

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

@@ -5,26 +5,21 @@ require_relative "method_catalog"
 module Rigor
   module Inference
     module Builtins
-      # `Numeric` family catalog (Integer, Float, Rational, Complex,
-      # Numeric). Singleton — load once, consult during dispatch.
+      # `Numeric` family catalog (Integer, Float, Rational, Complex, Numeric). Singleton — load once,
+      # consult during dispatch.
       #
-      # The catalog is produced offline by `tool/extract_builtin_catalog.rb`
-      # from the CRuby reference checkout under `references/ruby` plus the
-      # RBS core signatures under `references/rbs`. The loader is the
-      # runtime bridge: callers ask "is `Integer#+` safe to invoke during
-      # constant folding?" and the answer comes straight from the offline
-      # classification (`leaf` / `trivial` / `leaf_when_numeric` are
-      # foldable; everything else is not).
+      # The catalog is produced offline by `tool/extract_builtin_catalog.rb` from the CRuby reference
+      # checkout under `references/ruby` plus the RBS core signatures under `references/rbs`. The loader
+      # is the runtime bridge: callers ask "is `Integer#+` safe to invoke during constant folding?" and
+      # the answer comes straight from the offline classification (`leaf` / `trivial` / `leaf_when_numeric`
+      # are foldable; everything else is not).
       #
-      # No mutation blocklist is needed. The numeric classes expose no
-      # foldable bang or indirect-mutator method that the static C
-      # classifier mis-attributes (every `:leaf` numeric method is a pure
-      # value computation), so the generic `MethodCatalog` loader — shared
-      # with the eighteen other per-class catalogs — covers it directly.
-      # This previously hand-rolled its own `safe_for_folding?` /
-      # `method_entry` / `load_catalog` copy of `MethodCatalog`; folding
-      # it onto the shared loader also picks up alias resolution (e.g.
-      # `Integer#magnitude` → `abs`, `Integer#inspect` → `to_s`), which the
+      # No mutation blocklist is needed. The numeric classes expose no foldable bang or indirect-mutator
+      # method that the static C classifier mis-attributes (every `:leaf` numeric method is a pure value
+      # computation), so the generic `MethodCatalog` loader — shared with the eighteen other per-class
+      # catalogs — covers it directly. This previously hand-rolled its own `safe_for_folding?` /
+      # `method_entry` / `load_catalog` copy of `MethodCatalog`; folding it onto the shared loader also
+      # picks up alias resolution (e.g. `Integer#magnitude` → `abs`, `Integer#inspect` → `to_s`), which the
       # old bespoke loader silently dropped.
       NUMERIC_CATALOG = MethodCatalog.for_topic("numeric")
     end

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

@@ -5,24 +5,19 @@ require_relative "method_catalog"
 module Rigor
   module Inference
     module Builtins
-      # `Pathname` catalog. Singleton — load once, consult during
-      # dispatch.
+      # `Pathname` catalog. Singleton — load once, consult during dispatch.
       #
-      # TODO(blocklist curation): read
-      # `data/builtins/ruby_core/pathname.yml` and add per-method
-      # blocklist entries for any `:leaf` classifications that are
-      # actually mutators or otherwise unsafe to fold. Each entry
-      # SHOULD carry a one-line comment naming the indirect mutator
-      # helper that triggered the false positive (see
-      # `string_catalog.rb`, `array_catalog.rb`, `time_catalog.rb`
-      # for the canonical shape).
+      # TODO(blocklist curation): read `data/builtins/ruby_core/pathname.yml` and add per-method blocklist
+      # entries for any `:leaf` classifications that are actually mutators or otherwise unsafe to fold.
+      # Each entry SHOULD carry a one-line comment naming the indirect mutator helper that triggered the
+      # false positive (see `string_catalog.rb`, `array_catalog.rb`, `time_catalog.rb` for the canonical
+      # shape).
       PATHNAME_CATALOG = MethodCatalog.for_topic(
         "pathname",
         mutating_selectors: {
           "Pathname" => Set[
-          # initialize_copy is blocklisted by convention so a
-          # hypothetical future `Constant<Pathname>` carrier
-          # cannot fold an aliasing copy through the catalog.
+          # initialize_copy is blocklisted by convention so a hypothetical future `Constant<Pathname>`
+          # carrier cannot fold an aliasing copy through the catalog.
           :initialize_copy
           ]
         }