rigortype 0.4.1 → 0.4.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c26e2df607ebe3e1ef3b0c34a329aea4b1b0c80ec311cf6d9a83c4a58a358dfa
-  data.tar.gz: 2c4097594c8abe73819197a867cbb9a7b7dc3de86d8a2f22a2a83b1f948fa63a
+  metadata.gz: a812e377e347e70448e42c33e6f4fe79152d40851b999609e9e5fdd98dc5a5a0
+  data.tar.gz: 285b195c8058fa30063c5ad40ac6718cd59a3f1d79bb79ccac32184093dba5b0
 SHA512:
-  metadata.gz: d790e8fdb333983f82d85fb13036661ef87ca82d273b86955e1c7fa3191a65d027a04ea92fb4877edeb24f3df6bdae4dc03780791a79b15510ea5c7b494f23b6
-  data.tar.gz: b1258c842c5e656aea59b32eb91310cdda72a9dade402c87d2523bae3e4fa927f6607b0e2acd4250d24bfcba77e27df778aaf02c50c57300b6c27099c312c098
+  metadata.gz: 148890acd58affcbc6eb81afe948d882cf254930ff7ad83635592a065bf038de149865891767318721bdc103e7def6e4c71686b8d40a8ff9b55034c446cf8d32
+  data.tar.gz: e6d458ec387e004c83b8751e5381eda53ec5979433580263ea1586cbb574245875f50a94fce86540badae485d08d20ff73c7e3aea4d80d33c4226af3a4b7f584

data/README.md

@@ -232,7 +232,7 @@ rigor docs --list                 # list every bundled page
 
 ## Status
 
-Current release: **`v0.4.1`** (2026-10-08) — on the
+Current release: **`v0.4.2`** (2026-10-11) — on the
 `0.4.x` line, continuing the evaluation era opened by `v0.2.0`, the first
 publicly-announced (general / evaluation) release. The line publishes
 an enumerated [compatibility surface](docs/compatibility.md) as a

data/data/builtins/ruby_core/io.yml

@@ -1606,3 +1606,4 @@ classes:
         purity: leaf
     singleton_methods: {}
     undefined: []
+    rdoc_only: true

data/data/builtins/ruby_core/proc.yml

@@ -42,6 +42,7 @@ classes:
         rbs:
         - "(?) -> untyped"
         rbs_at: references/rbs/core/proc.rbs:624
+        rdoc_only: true
       "[]":
         source: c
         cfunc: proc_call
@@ -50,6 +51,7 @@ classes:
         c_body_at: references/ruby/proc.c:1104
         c_effects: []
         purity: leaf
+        rdoc_only: true
       "===":
         source: c
         cfunc: proc_call
@@ -58,6 +60,7 @@ classes:
         c_body_at: references/ruby/proc.c:1104
         c_effects: []
         purity: leaf
+        rdoc_only: true
       yield:
         source: c
         cfunc: proc_call
@@ -66,6 +69,7 @@ classes:
         c_body_at: references/ruby/proc.c:1104
         c_effects: []
         purity: leaf
+        rdoc_only: true
       to_proc:
         source: c
         cfunc: proc_to_proc

data/data/builtins/ruby_core/random.yml

@@ -63,6 +63,7 @@ classes:
         rbs:
         - "(?Integer seed) -> void"
         rbs_at: references/rbs/core/random.rbs:36
+        rdoc_only: true
       rand:
         source: c
         cfunc: random_rand
@@ -71,6 +72,7 @@ classes:
         c_body_at: references/ruby/random.c:1574
         c_effects: []
         purity: leaf
+        rdoc_only: true
       bytes:
         source: c
         cfunc: random_bytes
@@ -80,6 +82,7 @@ classes:
         c_effects:
         - dispatch
         purity: dispatch
+        rdoc_only: true
       seed:
         source: c
         cfunc: random_get_seed
@@ -91,6 +94,7 @@ classes:
         rbs:
         - "() -> Integer"
         rbs_at: references/rbs/core/random.rbs:172
+        rdoc_only: true
     singleton_methods:
       srand:
         source: c

data/data/builtins/ruby_core/struct.yml

@@ -303,6 +303,7 @@ classes:
         rbs:
         - "() -> bool?"
         rbs_at: references/rbs/core/struct.rbs:267
+        rdoc_only: true
       members:
         source: c
         cfunc: rb_struct_s_members_m
@@ -314,6 +315,7 @@ classes:
         rbs:
         - "() -> Array[Symbol]"
         rbs_at: references/rbs/core/struct.rbs:250
+        rdoc_only: true
     undefined: []
   Data:
     parent: Object
@@ -441,5 +443,6 @@ classes:
         c_body_at: references/ruby/struct.c:207
         c_effects: []
         purity: leaf
+        rdoc_only: true
     undefined:
     - new

data/data/core_overlay/env.rbs

@@ -0,0 +1,34 @@
+# Rigor core overlay — supplemental core signatures.
+#
+# --- ENV.fetch_values (Ruby 4.1) ---
+#
+# Issue #1691. Ruby 4.1 adds `ENV.fetch_values` (`hash.c`, call-seq
+# `ENV.fetch_values(*names) -> array of values` and
+# `ENV.fetch_values(*names) {|name| ... } -> array of values`), mirroring
+# `Hash#fetch_values`. No rbs release through 4.2 declares it on
+# `RBS::Unnamed::ENVClass`, the class rbs gives the `ENV` object, so correct
+# 4.1 code reported `call.undefined-method`. The name and value types follow
+# that class's own `fetch`.
+#
+# TEMPORARY: delete this file once the rbs release Rigor bundles declares
+# the method upstream.
+#
+# Declared unconditionally, not gated on `target_ruby` (ADR-121 § Rejected
+# alternatives; false positives outrank), and on a module the class
+# includes so that a later direct declaration overrides it instead of
+# raising `DuplicatedMethodDefinitionError` for the whole class (see
+# `process.rbs`).
+module RigorCoreOverlay
+  module Ruby41EnvFetchValues
+    def fetch_values: (*String names) -> Array[String]
+                    | [X] (*String names) { (String name) -> X } -> Array[String | X]
+  end
+end
+
+module RBS
+  module Unnamed
+    class ENVClass
+      include RigorCoreOverlay::Ruby41EnvFetchValues
+    end
+  end
+end

data/data/core_overlay/gc.rbs

@@ -0,0 +1,50 @@
+# Rigor core overlay — supplemental core signatures.
+#
+# --- GC.start / GC#garbage_collect `global:` and GC.stat `scope:` (Ruby 4.1) ---
+#
+# Issue #1718. Ruby 4.1's `gc.rb` adds a `global:` keyword to the collection
+# entry points and a `scope:` keyword to `GC.stat`:
+#
+#   def self.start full_mark: true, immediate_mark: true, immediate_sweep: true, global: true
+#   def garbage_collect full_mark: true, immediate_mark: true, immediate_sweep: true, global: true
+#   def self.stat hash_or_key = nil, scope: :ractor
+#
+# `scope:` is `:ractor`, `:local` or `:global` and raises `ArgumentError`
+# otherwise; it is declared `Symbol` so that a scope held in a variable is
+# not reported. No rbs release through 4.2 declares either keyword. Rigor
+# does not check keyword names today, so these entries make the signatures
+# correct for when it does.
+# `ObjectSpace.garbage_collect` takes `global:` too (`object_space.rbs`).
+#
+# TEMPORARY: delete this file once the rbs release Rigor bundles declares
+# the keywords upstream.
+#
+# `GC.stat` with `scope:` has one arm per form, each answering what the
+# upstream arm of that form does. The overload selector matches a call's
+# keyword hash against an overload's keywords (#1727), so
+# `GC.stat(:count, scope: :global)` takes the `Integer` arm and
+# `GC.stat({}, scope: :global)` the `Hash` one.
+#
+# Declared unconditionally, not gated on `target_ruby` (ADR-121 § Rejected
+# alternatives; false positives outrank). Each entry is an `| ...`
+# continuation of the upstream declaration, which every supported rbs
+# release carries; a later release that declares the keyword only repeats
+# an overload. `global:` is optional in its arm: the upstream arms take no
+# positional argument and answer the same type, so the arm changes no
+# selected return, and an arm with a REQUIRED keyword would switch
+# `call.wrong-arity` off for the whole method (`compute_arity_envelope`
+# declines any method with one), losing `GC.start(1)`. `GC.stat`'s `scope:`
+# arm does require its keyword, so that a call without it still selects
+# the upstream `(Symbol) -> Integer` / `(?Hash) -> Hash` arms; the cost is
+# that `GC.stat` is not arity-checked.
+module GC
+  def self.start: (?immediate_sweep: boolish, ?immediate_mark: boolish, ?full_mark: boolish, ?global: boolish) -> nil
+                | ...
+
+  def self.stat: (Symbol key, scope: Symbol) -> Integer
+               | (?Hash[Symbol, untyped]? hash, scope: Symbol) -> Hash[Symbol, untyped]
+               | ...
+
+  def garbage_collect: (?immediate_sweep: boolish, ?immediate_mark: boolish, ?full_mark: boolish, ?global: boolish) -> nil
+                     | ...
+end

data/data/core_overlay/hash.rbs

@@ -0,0 +1,45 @@
+# Rigor core overlay — supplemental core signatures.
+#
+# --- Hash.ruby2_keywords_hash? / Hash.ruby2_keywords_hash ---
+#
+# CRuby's `hash.c` defines both as singleton methods of `Hash`, present since
+# Ruby 2.7:
+#
+#   rb_define_singleton_method(rb_cHash, "ruby2_keywords_hash?", rb_hash_s_ruby2_keywords_hash_p, 1);
+#   rb_define_singleton_method(rb_cHash, "ruby2_keywords_hash", rb_hash_s_ruby2_keywords_hash, 1);
+#
+# `ruby2_keywords_hash?` answers whether the argument is a hash flagged by
+# `ruby2_keywords`; `ruby2_keywords_hash` returns a copy of its argument with
+# that flag set. Upstream `ruby/rbs` declares neither through 4.2, so
+#
+#   Hash.ruby2_keywords_hash?({})
+#
+# reported `call.undefined-method` on correct code. Ruby 4.1 deprecates both
+# (Feature #22205) and removes them in 4.5; `call.deprecated-ruby2-keywords`
+# reports the deprecation under an explicit `target_ruby` of 4.1 or later.
+#
+# The return of `ruby2_keywords_hash` is the argument's own Hash type: the
+# copy has the same keys and values, and the flag does not show in the type.
+#
+# Declared on a module `Hash` extends, not with `def self.…`, for the reason
+# `process.rbs` gives: a project `sig/` or a later rbs release may declare
+# either method directly, and a second direct `def` is a
+# `DuplicatedMethodDefinitionError` that takes `Hash`'s whole singleton surface
+# down to `Dynamic[top]`. A direct `def` overrides a method `Hash` gets through
+# `extend`, so the overlay stands down instead of colliding.
+#
+# Unconditional, not gated on `target_ruby` or the rbs line: both methods exist
+# on every supported Ruby (2.7 through 4.4), and gating would report
+# `call.undefined-method` on a correct project still on the default
+# `target_ruby`. The deprecation for 4.1+ is a separate rule and does not read
+# this declaration.
+module RigorCoreOverlay
+  module HashRuby2Keywords
+    def ruby2_keywords_hash?: (Hash[untyped, untyped] hash) -> bool
+    def ruby2_keywords_hash: [K, V] (Hash[K, V] hash) -> Hash[K, V]
+  end
+end
+
+class Hash[unchecked out K, unchecked out V]
+  extend RigorCoreOverlay::HashRuby2Keywords
+end

data/data/core_overlay/integer.rbs

@@ -0,0 +1,31 @@
+# Rigor core overlay — supplemental core signatures.
+#
+# --- Integer#bit_count (Ruby 4.1) ---
+#
+# Issue #1691. Ruby 4.1 adds `Integer#bit_count`, the population count of
+# the receiver's binary representation (`numeric.c`, call-seq
+# `bit_count -> integer`). No rbs release through 4.2 declares it, so
+# `5.bit_count` reported `call.undefined-method` on correct 4.1 code.
+#
+# TEMPORARY: delete this file once the rbs release Rigor bundles declares
+# the method upstream.
+#
+# Declared unconditionally, not gated on `target_ruby`: a 4.0-targeted
+# project calling it is an error Rigor then misses, but gating would report
+# every correct 4.1 call under the default target (ADR-121 § Rejected
+# alternatives; false positives outrank).
+#
+# Declared on a module `Integer` includes, not as a direct `def`: a second
+# direct `def` from a later rbs or a project `sig/` is a
+# `DuplicatedMethodDefinitionError` that takes all of `Integer` down to
+# `Dynamic[top]`, while a direct `def` from either source simply overrides
+# a method the class gets through `include` (see `process.rbs`).
+module RigorCoreOverlay
+  module Ruby41Integer
+    def bit_count: () -> Integer
+  end
+end
+
+class Integer
+  include RigorCoreOverlay::Ruby41Integer
+end

data/data/core_overlay/io_buffer.rbs

@@ -0,0 +1,27 @@
+# Rigor core overlay — supplemental core signatures.
+#
+# --- IO::Buffer#bit_count (Ruby 4.1) ---
+#
+# Issue #1718. Ruby 4.1 adds `IO::Buffer#bit_count` (`io_buffer.c`, call-seq
+# `bit_count([offset, [length]]) -> integer`), the population count of the
+# buffer or of a subrange. Either argument may be `nil` for its default
+# (`io_buffer_extract_offset_length`). No rbs release through 4.2 declares
+# it, so correct 4.1 code reported `call.undefined-method`.
+#
+# TEMPORARY: delete this file once the rbs release Rigor bundles declares
+# the method upstream.
+#
+# Declared unconditionally, not gated on `target_ruby` (ADR-121 § Rejected
+# alternatives; false positives outrank), and on a module `IO::Buffer`
+# includes so that a later direct declaration overrides it instead of
+# raising `DuplicatedMethodDefinitionError` for the whole class (see
+# `process.rbs`).
+module RigorCoreOverlay
+  module Ruby41IOBuffer
+    def bit_count: (?Integer? offset, ?Integer? length) -> Integer
+  end
+end
+
+class IO::Buffer
+  include RigorCoreOverlay::Ruby41IOBuffer
+end

data/data/core_overlay/kernel.rbs

@@ -0,0 +1,40 @@
+# Rigor core overlay — supplemental core signatures.
+#
+# --- Kernel#autoload_relative (Ruby 4.1) ---
+#
+# Issue #1691. Ruby 4.1 adds the global function `autoload_relative`
+# (`load.c`, call-seq `autoload_relative(const, filename) -> nil`), the
+# top-level counterpart of `Module#autoload_relative` (`module.rbs`). No rbs
+# release through 4.2 declares it, so a top-level call reported
+# `call.undefined-method` on correct 4.1 code.
+#
+# TEMPORARY: delete this file once the rbs release Rigor bundles declares
+# the method upstream.
+#
+# Declared unconditionally, not gated on `target_ruby` (ADR-121 § Rejected
+# alternatives; false positives outrank). A global function is a private
+# instance method plus a public singleton method on `Kernel` — what rbs
+# spells `def self?.` — so the two halves are declared on two modules,
+# one `Kernel` includes and one it extends. A later direct `def self?.`
+# from rbs or a project `sig/` overrides both instead of raising
+# `DuplicatedMethodDefinitionError` for the whole module (see
+# `process.rbs`). The included module's self type is `BasicObject`: the
+# default, `Object`, includes `Kernel` itself, and that cycle is a
+# `RecursiveAncestorError` that takes `Object` and every class under it
+# down to `Dynamic[top]`.
+module RigorCoreOverlay
+  module Ruby41KernelAutoloadRelative : BasicObject
+    private
+
+    def autoload_relative: (Symbol | string const, string | _ToPath filename) -> nil
+  end
+
+  module Ruby41KernelSingletonAutoloadRelative
+    def autoload_relative: (Symbol | string const, string | _ToPath filename) -> nil
+  end
+end
+
+module Kernel
+  include RigorCoreOverlay::Ruby41KernelAutoloadRelative
+  extend RigorCoreOverlay::Ruby41KernelSingletonAutoloadRelative
+end

data/data/core_overlay/match_data.rbs

@@ -0,0 +1,28 @@
+# Rigor core overlay — supplemental core signatures.
+#
+# --- MatchData#integer_at (Ruby 4.1) ---
+#
+# Issue #1691. Ruby 4.1 adds `MatchData#integer_at` (`re.c`, call-seq
+# `integer_at(index, base = 10) -> integer or nil` and
+# `integer_at(name, base = 10) -> integer or nil`): `$~.integer_at(N)` is
+# `$N&.to_i`. No rbs release through 4.2 declares it, so correct 4.1 code
+# reported `call.undefined-method`. A non-Integer first argument is read as
+# a group name; `base` goes through `NUM2INT`, hence `int`.
+#
+# TEMPORARY: delete this file once the rbs release Rigor bundles declares
+# the method upstream.
+#
+# Declared unconditionally, not gated on `target_ruby` (ADR-121 § Rejected
+# alternatives; false positives outrank), and on a module `MatchData`
+# includes so that a later direct declaration overrides it instead of
+# raising `DuplicatedMethodDefinitionError` for the whole class (see
+# `process.rbs`).
+module RigorCoreOverlay
+  module Ruby41MatchData
+    def integer_at: (Integer | String | Symbol index_or_name, ?int base) -> Integer?
+  end
+end
+
+class MatchData
+  include RigorCoreOverlay::Ruby41MatchData
+end

data/data/core_overlay/module.rbs

@@ -0,0 +1,51 @@
+# Rigor core overlay — supplemental core signatures.
+#
+# --- Module#descendants, #autoload_relative, method_defined?'s include_all (Ruby 4.1) ---
+#
+# Issue #1691. Ruby 4.1 adds, on `Module`:
+#
+#   descendants -> array                                  (class.c)
+#   autoload_relative(const, filename) -> nil             (load.c)
+#   method_defined?(symbol, inherit=true, include_all = false) -> true or false
+#                                                         (vm_method.c, Feature #22297)
+#
+# No rbs release through 4.2 declares the first two or the third argument,
+# so correct 4.1 code reported `call.undefined-method` or
+# `call.wrong-arity`. `descendants` answers classes and modules alike,
+# hence `Array[Module]`; on a `Class` it answers only classes, since no
+# module has a class among its ancestors, so `Class` narrows it to
+# `Array[Class]` as rbs's `Class#subclasses` does.
+#
+# TEMPORARY: delete each entry once the rbs release Rigor bundles declares
+# it upstream.
+#
+# Declared unconditionally, not gated on `target_ruby` (ADR-121 § Rejected
+# alternatives; false positives outrank). The new methods sit on a module
+# `Module` includes so that a later direct declaration overrides them
+# instead of raising `DuplicatedMethodDefinitionError` for the whole class
+# (see `process.rbs`). The three-argument `method_defined?` is an `| ...`
+# continuation of the upstream declaration, which every supported rbs
+# release carries. `interned` and `path` are spelled out because rbs 3.0-3.2
+# predate both aliases.
+module RigorCoreOverlay
+  module Ruby41Module
+    def descendants: () -> Array[Module]
+
+    def autoload_relative: (Symbol | string const, string | _ToPath filename) -> nil
+  end
+
+  module Ruby41ClassDescendants
+    def descendants: () -> Array[Class]
+  end
+end
+
+class Module
+  include RigorCoreOverlay::Ruby41Module
+
+  def method_defined?: (Symbol | string name, boolish inherit, boolish include_all) -> bool
+                     | ...
+end
+
+class Class
+  include RigorCoreOverlay::Ruby41ClassDescendants
+end

data/data/core_overlay/object_space.rbs

@@ -0,0 +1,29 @@
+# Rigor core overlay — supplemental core signatures.
+#
+# --- ObjectSpace.garbage_collect `global:` (Ruby 4.1) ---
+#
+# Issue #1718. Ruby 4.1's `gc.rb` adds the `global:` keyword to
+# `ObjectSpace#garbage_collect` (a `module_function`, so both the singleton
+# and the private instance method), as it does to `GC.start` (`gc.rbs`):
+#
+#   def garbage_collect full_mark: true, immediate_mark: true, immediate_sweep: true, global: true
+#
+# No rbs release through 4.2 declares it. Rigor does not check keyword
+# names today, so this entry makes the signature correct for when it does.
+# The return mirrors upstream's own `void`.
+#
+# TEMPORARY: delete this file once the rbs release Rigor bundles declares
+# the keyword upstream.
+#
+# Declared unconditionally, not gated on `target_ruby` (ADR-121 § Rejected
+# alternatives; false positives outrank), as `| ...` continuations of the
+# upstream declarations. `global:` is optional in the added arm, which then
+# answers every call the upstream arm does with the same type; a required
+# keyword would switch `call.wrong-arity` off for the method (see `gc.rbs`).
+module ObjectSpace
+  def self.garbage_collect: (?full_mark: bool, ?immediate_mark: bool, ?immediate_sweep: bool, ?global: boolish) -> void
+                          | ...
+
+  def garbage_collect: (?full_mark: bool, ?immediate_mark: bool, ?immediate_sweep: bool, ?global: boolish) -> void
+                     | ...
+end

data/data/core_overlay/proc.rbs

@@ -0,0 +1,45 @@
+# Rigor core overlay — supplemental core signatures.
+#
+# --- Proc#refined (Ruby 4.1) ---
+#
+# Ruby 4.1 adds `Proc#refined(*modules)` (Feature #22097, `proc_refined` in
+# CRuby's `proc.c`): it returns a copy of the receiver whose body runs with
+# the given modules' refinements active. Upstream `ruby/rbs` does not declare
+# it through 4.2, so
+#
+#   pr = ->(s) { s.shout }.refined(Shout)
+#
+# reported `call.undefined-method` on correct 4.1 code.
+#
+# The return is `self`, not `Proc`. CRuby builds the copy with
+# `proc_create(rb_obj_class(self), …, is_lambda)` (`vm.c`'s
+# `rb_proc_dup_with_iseq_and_recipe`) and returns the receiver itself when
+# called with no modules, so the class, lambda-ness, `parameters`, `arity`
+# and source location all carry over (`test_refined_preserves_lambda`,
+# `test_refined_preserves_location_and_parameters` in `test/ruby/test_proc.rb`).
+# A refinement changes which methods the body's calls reach, never the
+# Proc's own signature.
+#
+# Not modelled: `refined` raises `ArgumentError` on a Proc not backed by a
+# Ruby block (`:sym.to_proc`, `method(:m).to_proc`), and `TypeError` for a
+# Class argument (`Check_Type(arg, T_MODULE)`), which `*Module` accepts.
+#
+# Unconditional, not gated on `target_ruby >= 4.1` (issue #1665): gating would
+# report `call.undefined-method` on every correct 4.1 project still on the
+# default `target_ruby`. False positives outrank the missed 4.0-target error.
+#
+# Declared on a module `Proc` includes, not with a direct `def`, for the reason
+# `process.rbs` gives: a later rbs release or a project `sig/` is likely to
+# declare `Proc#refined` itself, and a second direct `def` is a
+# `DuplicatedMethodDefinitionError` that takes `Proc`'s whole instance surface
+# down to `Dynamic[top]`. A direct `def` overrides an included module's method,
+# so the overlay stands down instead of colliding.
+module RigorCoreOverlay
+  module ProcRefined
+    def refined: (*Module) -> self
+  end
+end
+
+class Proc
+  include RigorCoreOverlay::ProcRefined
+end

data/data/core_overlay/range.rbs

@@ -0,0 +1,40 @@
+# Rigor core overlay — supplemental core signatures.
+#
+# --- Range#clamp (Ruby 4.1) ---
+#
+# Issue #1691. Ruby 4.1 adds `Range#clamp` (`range.c`, call-seq
+# `clamp(min, max) -> range` / `clamp(range) -> range`), which returns a new
+# range whose ends are clamped to the bounds. No rbs release through 4.2
+# declares it, so `(1..10).clamp(2, 5)` reported `call.undefined-method` on
+# correct 4.1 code.
+#
+# Either bound may be `nil` (unbounded), which leaves that end of the
+# receiver as it is. The first two overloads answer the common case, bounds
+# of the receiver's own element type, as `Range[Elem]`. Bounds of another
+# type (`(1..10).clamp(2.5, nil)`) take the `untyped` arms rather than be
+# reported. Those arms are deliberately not generic: a `[T] (T min, T max)`
+# arm binds `T` to `Float | nil` for a `Float?` bound and puts a `nil` in the
+# result's elements that CRuby never produces, which then reports
+# `call.possible-nil-receiver` on correct code that iterates the result.
+#
+# TEMPORARY: delete this file once the rbs release Rigor bundles declares
+# the method upstream.
+#
+# Declared unconditionally, not gated on `target_ruby` (ADR-121 § Rejected
+# alternatives; false positives outrank), and on a module `Range` includes
+# so that a later direct declaration overrides it instead of raising
+# `DuplicatedMethodDefinitionError` for the whole class (see `process.rbs`).
+# `Elem` is `unchecked` on the module because the first two overloads read it
+# in parameter position.
+module RigorCoreOverlay
+  module Ruby41Range[unchecked out Elem]
+    def clamp: (Elem? min, Elem? max) -> Range[Elem]
+             | (Range[Elem?] range) -> Range[Elem]
+             | (untyped min, untyped max) -> Range[untyped]
+             | (Range[untyped] range) -> Range[untyped]
+  end
+end
+
+class Range[out Elem]
+  include RigorCoreOverlay::Ruby41Range[Elem]
+end

data/data/core_overlay/source_range.rbs

@@ -0,0 +1,78 @@
+# Rigor core overlay — supplemental core signatures.
+#
+# --- Ruby::SourceRange and the #source_range readers (Ruby 4.1) ---
+#
+# Issue #1691. Ruby 4.1 adds the `Ruby::SourceRange` class (`proc.c`) and
+# four methods that answer one:
+#
+#   Thread::Backtrace::Location#source_range -> Ruby::SourceRange  (vm_backtrace.c)
+#   Proc#source_range, Method#source_range,
+#   UnboundMethod#source_range -> Ruby::SourceRange or nil          (proc.c)
+#
+# NEWS lists only the backtrace reader; `proc.c` defines the other three
+# alongside the class. They answer `nil` for a proc or method with no Ruby
+# source (a C method, a `Symbol#to_proc`). The class's readers are, per
+# their call-seqs:
+#
+#   path -> String               absolute_path -> String or nil
+#   start_line -> Integer        start_column -> Integer
+#   end_line -> Integer          end_column -> Integer
+#
+# `Ruby::SourceRange` has no allocator (`new` is undefined), so no
+# constructor is declared. No rbs release through 4.2 declares any of
+# this, so correct 4.1 code reported `call.undefined-method`.
+#
+# TEMPORARY: delete this file once the rbs release Rigor bundles declares
+# the methods upstream.
+#
+# Declared unconditionally, not gated on `target_ruby` (ADR-121 § Rejected
+# alternatives; false positives outrank). Every method sits on a module the
+# class includes, so that a later direct declaration from rbs or a project
+# `sig/` overrides it instead of raising `DuplicatedMethodDefinitionError`
+# for the whole class (see `process.rbs`). `Ruby::SourceRange` is declared
+# without a superclass, so a later upstream `< Object` reopening agrees.
+module RigorCoreOverlay
+  module Ruby41LocationSourceRange
+    def source_range: () -> Ruby::SourceRange
+  end
+
+  module Ruby41CallableSourceRange
+    def source_range: () -> Ruby::SourceRange?
+  end
+
+  module Ruby41SourceRange
+    def path: () -> String
+
+    def absolute_path: () -> String?
+
+    def start_line: () -> Integer
+
+    def start_column: () -> Integer
+
+    def end_line: () -> Integer
+
+    def end_column: () -> Integer
+  end
+end
+
+class Thread::Backtrace::Location
+  include RigorCoreOverlay::Ruby41LocationSourceRange
+end
+
+class Proc
+  include RigorCoreOverlay::Ruby41CallableSourceRange
+end
+
+class Method
+  include RigorCoreOverlay::Ruby41CallableSourceRange
+end
+
+class UnboundMethod
+  include RigorCoreOverlay::Ruby41CallableSourceRange
+end
+
+module Ruby
+  class SourceRange
+    include RigorCoreOverlay::Ruby41SourceRange
+  end
+end