rigortype 0.0.4 → 0.0.6

data/data/builtins/ruby_core/rational.yml

@@ -0,0 +1,365 @@
+# DO NOT EDIT — generated by tool/extract_builtin_catalog.rb
+---
+schema_version: 1
+generated_from:
+  ruby_init_c: references/ruby/rational.c
+  ruby_prelude:
+  rbs:
+  - references/rbs/core/rational.rbs
+purity_levels:
+  leaf: Prelude :leaf marker (VM-enforced) or C body uses no dispatch/yield/mutation.
+  trivial: Prelude method body is a literal return (self/true/false/nil/Integer).
+  leaf_when_numeric: C body falls through to rb_num_coerce_* only when an operand
+    is non-numeric; safe to fold when every argument is a concrete numeric.
+  inline_block: Prelude method carries :inline_block or :use_block; block-dependent.
+  block_dependent: C body yields or checks rb_block_given_p.
+  mutates_self: C body checks rb_check_frozen — typically a prelude to mutation.
+  dispatch: C body calls user-redefinable methods (rb_funcall*, rb_equal, rb_Float,
+    num_funcall*, etc).
+  unknown: C body not located in indexed C files.
+classes:
+  Rational:
+    parent: Numeric
+    defined_at: references/ruby/rational.c:2758
+    includes: []
+    constants: {}
+    aliases: {}
+    instance_methods:
+      numerator:
+        source: c
+        cfunc: nurat_numerator
+        arity: 0
+        defined_at: references/ruby/rational.c:2767
+        c_body_at: references/ruby/rational.c:586
+        c_effects: []
+        purity: leaf
+        rbs:
+        - "() -> Integer"
+        rbs_at: references/rbs/core/rational.rbs:342
+      denominator:
+        source: c
+        cfunc: nurat_denominator
+        arity: 0
+        defined_at: references/ruby/rational.c:2768
+        c_body_at: references/ruby/rational.c:604
+        c_effects: []
+        purity: leaf
+        rbs:
+        - "() -> Integer"
+        rbs_at: references/rbs/core/rational.rbs:250
+      "-@":
+        source: c
+        cfunc: rb_rational_uminus
+        arity: 0
+        defined_at: references/ruby/rational.c:2770
+        c_body_at: references/ruby/rational.c:621
+        c_effects: []
+        purity: leaf
+        rbs:
+        - "() -> Rational"
+        rbs_at: references/rbs/core/rational.rbs:138
+      "+":
+        source: c
+        cfunc: rb_rational_plus
+        arity: 1
+        defined_at: references/ruby/rational.c:2771
+        c_body_at: references/ruby/rational.c:745
+        c_effects:
+        - coerce_fallback
+        purity: leaf_when_numeric
+        rbs:
+        - "(Float) -> Float"
+        - "(Complex) -> Complex"
+        - "(Numeric) -> Rational"
+        rbs_at: references/rbs/core/rational.rbs:109
+      "-":
+        source: c
+        cfunc: rb_rational_minus
+        arity: 1
+        defined_at: references/ruby/rational.c:2772
+        c_body_at: references/ruby/rational.c:786
+        c_effects:
+        - coerce_fallback
+        purity: leaf_when_numeric
+        rbs:
+        - "(Float) -> Float"
+        - "(Complex) -> Complex"
+        - "(Numeric) -> Rational"
+        rbs_at: references/rbs/core/rational.rbs:125
+      "*":
+        source: c
+        cfunc: rb_rational_mul
+        arity: 1
+        defined_at: references/ruby/rational.c:2773
+        c_body_at: references/ruby/rational.c:884
+        c_effects:
+        - coerce_fallback
+        purity: leaf_when_numeric
+        rbs:
+        - "(Integer) -> Rational"
+        - "(Rational) -> Rational"
+        - "[T < Numeric] (T) -> T"
+        rbs_at: references/rbs/core/rational.rbs:67
+      "/":
+        source: c
+        cfunc: rb_rational_div
+        arity: 1
+        defined_at: references/ruby/rational.c:2774
+        c_body_at: references/ruby/rational.c:925
+        c_effects:
+        - coerce_fallback
+        - raises
+        purity: leaf_when_numeric
+        rbs:
+        - "(Float) -> Float"
+        - "(Complex) -> Complex"
+        - "(Numeric) -> Rational"
+        rbs_at: references/rbs/core/rational.rbs:152
+      quo:
+        source: c
+        cfunc: rb_rational_div
+        arity: 1
+        defined_at: references/ruby/rational.c:2775
+        c_body_at: references/ruby/rational.c:925
+        c_effects:
+        - coerce_fallback
+        - raises
+        purity: leaf_when_numeric
+        rbs:
+        - "(Float) -> Float"
+        - "(Complex) -> Complex"
+        - "(Numeric) -> Rational"
+        rbs_at: references/rbs/core/rational.rbs:363
+      fdiv:
+        source: c
+        cfunc: nurat_fdiv
+        arity: 1
+        defined_at: references/ruby/rational.c:2776
+        c_body_at: references/ruby/rational.c:973
+        c_effects:
+        - dispatch
+        purity: dispatch
+        rbs:
+        - "(Numeric) -> Float"
+        rbs_at: references/rbs/core/rational.rbs:265
+      "**":
+        source: c
+        cfunc: nurat_expt
+        arity: 1
+        defined_at: references/ruby/rational.c:2777
+        c_body_at: references/ruby/rational.c:1002
+        c_effects:
+        - coerce_fallback
+        - raises
+        purity: leaf_when_numeric
+        rbs:
+        - "(Complex) -> Complex"
+        - "(Numeric) -> Numeric"
+        rbs_at: references/rbs/core/rational.rbs:84
+      "<=>":
+        source: c
+        cfunc: rb_rational_cmp
+        arity: 1
+        defined_at: references/ruby/rational.c:2779
+        c_body_at: references/ruby/rational.c:1106
+        c_effects:
+        - coerce_fallback
+        purity: leaf_when_numeric
+        rbs:
+        - "(Integer | Rational) -> Integer"
+        - "(untyped) -> Integer?"
+        rbs_at: references/rbs/core/rational.rbs:182
+      "==":
+        source: c
+        cfunc: nurat_eqeq_p
+        arity: 1
+        defined_at: references/ruby/rational.c:2780
+        c_body_at: references/ruby/rational.c:1159
+        c_effects:
+        - dispatch
+        purity: dispatch
+        rbs:
+        - "(untyped) -> bool"
+        rbs_at: references/rbs/core/rational.rbs:197
+      coerce:
+        source: c
+        cfunc: nurat_coerce
+        arity: 1
+        defined_at: references/ruby/rational.c:2781
+        c_body_at: references/ruby/rational.c:1201
+        c_effects:
+        - raises
+        purity: leaf
+        rbs:
+        - "(Numeric) -> [ Numeric, Numeric ]"
+        rbs_at: references/rbs/core/rational.rbs:237
+      positive?:
+        source: c
+        cfunc: nurat_positive_p
+        arity: 0
+        defined_at: references/ruby/rational.c:2783
+        c_body_at: references/ruby/rational.c:1238
+        c_effects: []
+        purity: leaf
+        rbs:
+        - "() -> bool"
+        rbs_at: references/rbs/core/rational.rbs:352
+      negative?:
+        source: c
+        cfunc: nurat_negative_p
+        arity: 0
+        defined_at: references/ruby/rational.c:2784
+        c_body_at: references/ruby/rational.c:1251
+        c_effects: []
+        purity: leaf
+        rbs:
+        - "() -> bool"
+        rbs_at: references/rbs/core/rational.rbs:329
+      abs:
+        source: c
+        cfunc: rb_rational_abs
+        arity: 0
+        defined_at: references/ruby/rational.c:2785
+        c_body_at: references/ruby/rational.c:1270
+        c_effects: []
+        purity: leaf
+        rbs:
+        - "() -> Rational"
+        rbs_at: references/rbs/core/rational.rbs:209
+      magnitude:
+        source: c
+        cfunc: rb_rational_abs
+        arity: 0
+        defined_at: references/ruby/rational.c:2786
+        c_body_at: references/ruby/rational.c:1270
+        c_effects: []
+        purity: leaf
+      floor:
+        source: c
+        cfunc: nurat_floor_n
+        arity: -1
+        defined_at: references/ruby/rational.c:2788
+        c_body_at: references/ruby/rational.c:1466
+        c_effects: []
+        purity: leaf
+        rbs:
+        - "() -> Integer"
+        - "(Integer digits) -> (Integer | Rational)"
+        rbs_at: references/rbs/core/rational.rbs:290
+      ceil:
+        source: c
+        cfunc: nurat_ceil_n
+        arity: -1
+        defined_at: references/ruby/rational.c:2789
+        c_body_at: references/ruby/rational.c:1496
+        c_effects: []
+        purity: leaf
+        rbs:
+        - "() -> Integer"
+        - "(Integer digits) -> (Integer | Rational)"
+        rbs_at: references/rbs/core/rational.rbs:234
+      truncate:
+        source: c
+        cfunc: nurat_truncate_n
+        arity: -1
+        defined_at: references/ruby/rational.c:2790
+        c_body_at: references/ruby/rational.c:1526
+        c_effects: []
+        purity: leaf
+        rbs:
+        - "() -> Integer"
+        - "(Integer ndigits) -> (Integer | Rational)"
+        rbs_at: references/rbs/core/rational.rbs:500
+      round:
+        source: c
+        cfunc: nurat_round_n
+        arity: -1
+        defined_at: references/ruby/rational.c:2791
+        c_body_at: references/ruby/rational.c:1569
+        c_effects: []
+        purity: leaf
+        rbs:
+        - "(?half: :up | :down | :even) -> Integer"
+        - "(Integer digits, ?half: :up | :down | :even) -> (Integer | Rational)"
+        rbs_at: references/rbs/core/rational.rbs:422
+      to_i:
+        source: c
+        cfunc: nurat_truncate
+        arity: 0
+        defined_at: references/ruby/rational.c:2793
+        c_body_at: references/ruby/rational.c:1309
+        c_effects: []
+        purity: leaf
+        rbs:
+        - "() -> Integer"
+        rbs_at: references/rbs/core/rational.rbs:452
+      to_f:
+        source: c
+        cfunc: nurat_to_f
+        arity: 0
+        defined_at: references/ruby/rational.c:2794
+        c_body_at: references/ruby/rational.c:1607
+        c_effects: []
+        purity: leaf
+        rbs:
+        - "() -> Float"
+        rbs_at: references/rbs/core/rational.rbs:436
+      to_r:
+        source: c
+        cfunc: nurat_to_r
+        arity: 0
+        defined_at: references/ruby/rational.c:2795
+        c_body_at: references/ruby/rational.c:1622
+        c_effects: []
+        purity: leaf
+        rbs:
+        - "() -> Rational"
+        rbs_at: references/rbs/core/rational.rbs:463
+      rationalize:
+        source: c
+        cfunc: nurat_rationalize
+        arity: -1
+        defined_at: references/ruby/rational.c:2796
+        c_body_at: references/ruby/rational.c:1756
+        c_effects: []
+        purity: leaf
+        rbs:
+        - "(?Numeric eps) -> Rational"
+        rbs_at: references/rbs/core/rational.rbs:380
+      hash:
+        source: c
+        cfunc: nurat_hash
+        arity: 0
+        defined_at: references/ruby/rational.c:2798
+        c_body_at: references/ruby/rational.c:1803
+        c_effects: []
+        purity: leaf
+        rbs:
+        - "() -> Integer"
+        rbs_at: references/rbs/core/rational.rbs:298
+      to_s:
+        source: c
+        cfunc: nurat_to_s
+        arity: 0
+        defined_at: references/ruby/rational.c:2800
+        c_body_at: references/ruby/rational.c:1833
+        c_effects: []
+        purity: leaf
+        rbs:
+        - "() -> String"
+        rbs_at: references/rbs/core/rational.rbs:475
+      inspect:
+        source: c
+        cfunc: nurat_inspect
+        arity: 0
+        defined_at: references/ruby/rational.c:2801
+        c_body_at: references/ruby/rational.c:1849
+        c_effects: []
+        purity: leaf
+        rbs:
+        - "() -> String"
+        rbs_at: references/rbs/core/rational.rbs:310
+    singleton_methods: {}
+    undefined:
+    - allocate
+    - new

data/data/builtins/ruby_core/string.yml

@@ -1556,6 +1556,15 @@ classes:
         - "(untyped object) -> String?"
         rbs_at: references/rbs/core/string.rbs:980
     undefined: []
+  UnicodeNormalize:
+    parent: Module
+    defined_at: references/ruby/string.c:12943
+    includes: []
+    constants: {}
+    aliases: {}
+    instance_methods: {}
+    singleton_methods: {}
+    undefined: []
   Symbol:
     parent: Object
     defined_at: references/ruby/string.c:12956

data/data/builtins/ruby_core/time.yml

@@ -125,8 +125,9 @@ classes:
         arity: 0
         defined_at: references/ruby/time.c:5997
         c_body_at: references/ruby/time.c:4196
-        c_effects: []
-        purity: leaf
+        c_effects:
+        - mutate
+        purity: mutates_self
         rbs:
         - "() -> Time"
         rbs_at: references/rbs/core/time.rbs:1037
@@ -136,8 +137,9 @@ classes:
         arity: 0
         defined_at: references/ruby/time.c:5998
         c_body_at: references/ruby/time.c:4196
-        c_effects: []
-        purity: leaf
+        c_effects:
+        - mutate
+        purity: mutates_self
         rbs:
         - "() -> Time"
         rbs_at: references/rbs/core/time.rbs:1573

data/lib/rigor/cli.rb

@@ -28,7 +28,7 @@ module Rigor
       new(argv.dup, out: out, err: err).run
     end
 
-    def initialize(argv, out:, err:)
+    def initialize(argv = ARGV.dup, out: $stdout, err: $stderr)
       @argv = argv
       @out = out
       @err = err

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

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require_relative "method_catalog"
+
+module Rigor
+  module Inference
+    module Builtins
+      # `Comparable` module catalog. Singleton — load once.
+      #
+      # `Comparable` 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 consumed by future include-aware lookup —
+      # see `docs/CURRENT_WORK.md` for the planned slice.
+      COMPARABLE_CATALOG = MethodCatalog.new(
+        path: File.expand_path(
+          "../../../../data/builtins/ruby_core/comparable.yml",
+          __dir__
+        ),
+        mutating_selectors: {
+          "Comparable" => Set[]
+        }
+      )
+    end
+  end
+end

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

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+require_relative "method_catalog"
+
+module Rigor
+  module Inference
+    module Builtins
+      # `Complex` catalog. Singleton — load once, consult during
+      # dispatch.
+      #
+      # `Complex` is a fully-immutable value type in Ruby: once a
+      # complex number is constructed (via `Complex(real, imag)` or
+      # `Complex.rect` / `Complex.polar`) its `real` and `imag` slots
+      # are never rewritten. Every public instance method either
+      # returns `self` unchanged or builds a fresh `Complex` /
+      # `Numeric`. The C-body classifier already correctly flags the
+      # four `:dispatch` methods (`<=>`, `to_s`, `inspect`,
+      # `rationalize`) so there are no false-positive `:leaf`
+      # entries to override. The blocklist therefore carries only
+      # the conventional `:initialize_copy` defence-in-depth entry
+      # so a hypothetical future `Constant<Complex>` carrier cannot
+      # fold an aliasing copy through the catalog (mirrors
+      # `range_catalog.rb`, `time_catalog.rb`, `date_catalog.rb`).
+      COMPLEX_CATALOG = MethodCatalog.new(
+        path: File.expand_path(
+          "../../../../data/builtins/ruby_core/complex.yml",
+          __dir__
+        ),
+        mutating_selectors: {
+          "Complex" => Set[
+            # Defence in depth: `Complex` does not currently expose
+            # a public `initialize_copy`, but blocking it keeps the
+            # convention identical to every other catalog so future
+            # CRuby additions cannot leak a copy-mutator through.
+            :initialize_copy
+          ]
+        }
+      )
+    end
+  end
+end

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

@@ -0,0 +1,98 @@
+# 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.
+require "date"
+
+require_relative "method_catalog"
+
+module Rigor
+  module Inference
+    module Builtins
+      # `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 / 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.
+      #
+      # 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.new(
+        path: File.expand_path(
+          "../../../../data/builtins/ruby_core/date.yml",
+          __dir__
+        ),
+        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.
+            :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.
+            :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.
+            :initialize_copy
+          ]
+        }
+      )
+    end
+  end
+end

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

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require_relative "method_catalog"
+
+module Rigor
+  module Inference
+    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 consumed by future include-aware lookup —
+      # see `docs/CURRENT_WORK.md` for the planned slice.
+      ENUMERABLE_CATALOG = MethodCatalog.new(
+        path: File.expand_path(
+          "../../../../data/builtins/ruby_core/enumerable.yml",
+          __dir__
+        ),
+        mutating_selectors: {
+          "Enumerable" => Set[]
+        }
+      )
+    end
+  end
+end

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

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require_relative "method_catalog"
+
+module Rigor
+  module Inference
+    module Builtins
+      # `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).
+      PATHNAME_CATALOG = MethodCatalog.new(
+        path: File.expand_path(
+          "../../../../data/builtins/ruby_core/pathname.yml",
+          __dir__
+        ),
+        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
+          ]
+        }
+      )
+    end
+  end
+end

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

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require_relative "method_catalog"
+
+module Rigor
+  module Inference
+    module Builtins
+      # `Rational` catalog. Singleton — load once, consult during
+      # dispatch.
+      #
+      # Rational is fully immutable: numerator / denominator slots
+      # are written once during `nurat_s_new_internal` and the C
+      # body never reaches for `rb_check_frozen`. Every catalog
+      # entry classifies cleanly (`:leaf`, `:leaf_when_numeric`,
+      # or `:dispatch` for the two methods that delegate into
+      # user-redefinable `==` / `Float()` — `nurat_eqeq_p` and
+      # `nurat_fdiv`). Bang-suffixed mutators do not exist on
+      # Rational.
+      #
+      # The blocklist therefore stays minimal. `initialize_copy`
+      # is added defensively (mirrors Range / Set) so a
+      # hypothetical future `Constant<Rational>` carrier cannot
+      # fold an aliasing copy through the catalog and surface a
+      # shared mutable handle.
+      RATIONAL_CATALOG = MethodCatalog.new(
+        path: File.expand_path(
+          "../../../../data/builtins/ruby_core/rational.yml",
+          __dir__
+        ),
+        mutating_selectors: {
+          "Rational" => Set[
+            :initialize_copy
+          ]
+        }
+      )
+    end
+  end
+end