rigortype 0.4.0 → 0.4.2

data/data/core_overlay/string.rbs

@@ -0,0 +1,86 @@
+# Rigor core overlay — supplemental core signatures.
+#
+# --- String bit operations and String#tr with a Hash (Ruby 4.1) ---
+#
+# Issue #1691. Ruby 4.1 adds bit access and bitwise operations on a
+# string's bytes (`string.c`), and lets `tr` / `tr!` take a single Hash of
+# replacement pairs (Feature #22238). No rbs release through 4.2 declares
+# any of them, so correct 4.1 code reported `call.undefined-method`, or
+# `call.wrong-arity` for `"hello".tr("e" => "er")`. Signatures follow the
+# CRuby call-seqs:
+#
+#   bit_get(offset, lsb_first: true) -> 0, 1, or nil
+#   bit_set?(offset, lsb_first: true) -> true, false, or nil
+#   bit_set / bit_clear / bit_flip(offset, lsb_first: true) -> self
+#                                 (offset, length, lsb_first: true) -> self
+#                                 (range, lsb_first: true) -> self
+#   bit_count -> integer
+#   bit_count(offset, length, lsb_first: true) -> integer
+#   bit_count(range, lsb_first: true) -> integer
+#   bitwise_not -> string             bitwise_not! -> self
+#   bitwise_and / _or / _xor(other) -> string, and their `!` forms -> self
+#   tr(pairs) -> new_string           tr!(pairs) -> self or nil
+#
+# `lsb_first` raises unless it is `true` or `false`, hence `bool`. `other`
+# is converted with `to_str`, hence `string`.
+#
+# 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
+# `String` includes so that a later direct declaration from rbs or a
+# project `sig/` overrides them instead of raising
+# `DuplicatedMethodDefinitionError` for the whole class (see
+# `process.rbs`). The `tr` / `tr!` Hash form is an `| ...` continuation of
+# the upstream declaration, which every supported rbs release carries; a
+# later release that declares the same overload only repeats it.
+module RigorCoreOverlay
+  module Ruby41StringBits
+    def bit_get: (int offset, ?lsb_first: bool) -> (0 | 1)?
+
+    def bit_set?: (int offset, ?lsb_first: bool) -> bool?
+
+    def bit_set: (int offset, ?lsb_first: bool) -> self
+               | (int offset, int length, ?lsb_first: bool) -> self
+               | (Range[Integer?] range, ?lsb_first: bool) -> self
+
+    def bit_clear: (int offset, ?lsb_first: bool) -> self
+                 | (int offset, int length, ?lsb_first: bool) -> self
+                 | (Range[Integer?] range, ?lsb_first: bool) -> self
+
+    def bit_flip: (int offset, ?lsb_first: bool) -> self
+                | (int offset, int length, ?lsb_first: bool) -> self
+                | (Range[Integer?] range, ?lsb_first: bool) -> self
+
+    def bit_count: () -> Integer
+                 | (int offset, int length, ?lsb_first: bool) -> Integer
+                 | (Range[Integer?] range, ?lsb_first: bool) -> Integer
+
+    def bitwise_not: () -> String
+
+    def bitwise_not!: () -> self
+
+    def bitwise_and: (string other) -> String
+
+    def bitwise_and!: (string other) -> self
+
+    def bitwise_or: (string other) -> String
+
+    def bitwise_or!: (string other) -> self
+
+    def bitwise_xor: (string other) -> String
+
+    def bitwise_xor!: (string other) -> self
+  end
+end
+
+class String
+  include RigorCoreOverlay::Ruby41StringBits
+
+  def tr: (Hash[string, string] pairs) -> String
+        | ...
+
+  def tr!: (Hash[string, string] pairs) -> self?
+         | ...
+end

data/data/vendored_gem_sigs/prime/integer-extension.rbs

@@ -0,0 +1,41 @@
+%a{annotate:rdoc:skip}
+class Integer
+  # <!--
+  #   rdoc-file=lib/prime.rb
+  #   - each_prime(ubound) { |prime| ... }
+  # -->
+  # Iterates the given block over all prime numbers.
+  #
+  # See `Prime`#each for more details.
+  #
+  def self.each_prime: (Integer) { (Integer) -> void } -> void
+
+  # <!--
+  #   rdoc-file=lib/prime.rb
+  #   - from_prime_division(pd)
+  # -->
+  # Re-composes a prime factorization and returns the product.
+  #
+  # See Prime#int_from_prime_division for more details.
+  #
+  def self.from_prime_division: (Array[[ Integer, Integer ]]) -> Integer
+
+  # <!--
+  #   rdoc-file=lib/prime.rb
+  #   - prime_division(generator = Prime::Generator23.new)
+  # -->
+  # Returns the factorization of `self`.
+  #
+  # See Prime#prime_division for more details.
+  #
+  def prime_division: (?Prime::PseudoPrimeGenerator) -> Array[[ Integer, Integer ]]
+
+  # <!--
+  #   rdoc-file=lib/prime.rb
+  #   - prime?()
+  # -->
+  # Returns true if `self` is a prime number, else returns false. Not recommended
+  # for very big integers (> 10**23).
+  #
+  def prime?: () -> bool
+end

data/data/vendored_gem_sigs/prime/prime.rbs

@@ -0,0 +1,372 @@
+# <!-- rdoc-file=lib/prime.rb -->
+# The set of all prime numbers.
+#
+# ## Example
+#
+#     Prime.each(100) do |prime|
+#       p prime  #=> 2, 3, 5, 7, 11, ...., 97
+#     end
+#
+# Prime is Enumerable:
+#
+#     Prime.first 5 # => [2, 3, 5, 7, 11]
+#
+# ## Retrieving the instance
+#
+# For convenience, each instance method of `Prime`.instance can be accessed as a
+# class method of `Prime`.
+#
+# e.g.
+#     Prime.instance.prime?(2)  #=> true
+#     Prime.prime?(2)           #=> true
+#
+# ## Generators
+#
+# A "generator" provides an implementation of enumerating pseudo-prime numbers
+# and it remembers the position of enumeration and upper bound. Furthermore, it
+# is an external iterator of prime enumeration which is compatible with an
+# Enumerator.
+#
+# `Prime`::`PseudoPrimeGenerator` is the base class for generators. There are
+# few implementations of generator.
+#
+# `Prime`::`EratosthenesGenerator`
+# :   Uses Eratosthenes' sieve.
+# `Prime`::`TrialDivisionGenerator`
+# :   Uses the trial division method.
+# `Prime`::`Generator23`
+# :   Generates all positive integers which are not divisible by either 2 or 3.
+#     This sequence is very bad as a pseudo-prime sequence. But this is faster
+#     and uses much less memory than the other generators. So, it is suitable
+#     for factorizing an integer which is not large but has many prime factors.
+#     e.g. for Prime#prime? .
+#
+class Prime
+  include Singleton
+
+  include Enumerable[Integer]
+
+  extend Enumerable[Integer]
+
+  # <!--
+  #   rdoc-file=lib/prime.rb
+  #   - each(ubound = nil, generator = EratosthenesGenerator.new, &block)
+  # -->
+  # Iterates the given block over all prime numbers.
+  #
+  # ## Parameters
+  #
+  # `ubound`
+  # :   Optional. An arbitrary positive number. The upper bound of enumeration.
+  #     The method enumerates prime numbers infinitely if `ubound` is nil.
+  # `generator`
+  # :   Optional. An implementation of pseudo-prime generator.
+  #
+  #
+  # ## Return value
+  #
+  # An evaluated value of the given block at the last time. Or an enumerator which
+  # is compatible to an `Enumerator` if no block given.
+  #
+  # ## Description
+  #
+  # Calls `block` once for each prime number, passing the prime as a parameter.
+  #
+  # `ubound`
+  # :   Upper bound of prime numbers. The iterator stops after it yields all prime
+  #     numbers p <= `ubound`.
+  #
+  def self.each: (?Integer? ubound, ?PseudoPrimeGenerator generator) { (Integer) -> void } -> void
+                | (?Integer? ubound, ?PseudoPrimeGenerator generator) -> PseudoPrimeGenerator
+
+  # <!--
+  #   rdoc-file=lib/prime.rb
+  #   - each(ubound = nil, generator = EratosthenesGenerator.new, &block)
+  # -->
+  # Iterates the given block over all prime numbers.
+  #
+  # ## Parameters
+  #
+  # `ubound`
+  # :   Optional. An arbitrary positive number. The upper bound of enumeration.
+  #     The method enumerates prime numbers infinitely if `ubound` is nil.
+  # `generator`
+  # :   Optional. An implementation of pseudo-prime generator.
+  #
+  #
+  # ## Return value
+  #
+  # An evaluated value of the given block at the last time. Or an enumerator which
+  # is compatible to an `Enumerator` if no block given.
+  #
+  # ## Description
+  #
+  # Calls `block` once for each prime number, passing the prime as a parameter.
+  #
+  # `ubound`
+  # :   Upper bound of prime numbers. The iterator stops after it yields all prime
+  #     numbers p <= `ubound`.
+  #
+  def each: (?Integer? ubound, ?PseudoPrimeGenerator generator) { (Integer) -> void } -> void
+          | (?Integer? ubound, ?PseudoPrimeGenerator generator) -> PseudoPrimeGenerator
+
+  # <!--
+  #   rdoc-file=lib/prime.rb
+  #   - int_from_prime_division(pd)
+  # -->
+  # Re-composes a prime factorization and returns the product.
+  #
+  # For the decomposition:
+  #
+  #     [[p_1, e_1], [p_2, e_2], ..., [p_n, e_n]],
+  #
+  # it returns:
+  #
+  #     p_1**e_1 * p_2**e_2 * ... * p_n**e_n.
+  #
+  # ## Parameters
+  # `pd`
+  # :   Array of pairs of integers. Each pair consists of a prime number -- a
+  #     prime factor -- and a natural number -- its exponent (multiplicity).
+  #
+  #
+  # ## Example
+  #     Prime.int_from_prime_division([[3, 2], [5, 1]])  #=> 45
+  #     3**2 * 5                                         #=> 45
+  #
+  def self.int_from_prime_division: (Array[[ Integer, Integer ]]) -> (Integer | Rational)
+
+  # <!--
+  #   rdoc-file=lib/prime.rb
+  #   - int_from_prime_division(pd)
+  # -->
+  # Re-composes a prime factorization and returns the product.
+  #
+  # For the decomposition:
+  #
+  #     [[p_1, e_1], [p_2, e_2], ..., [p_n, e_n]],
+  #
+  # it returns:
+  #
+  #     p_1**e_1 * p_2**e_2 * ... * p_n**e_n.
+  #
+  # ## Parameters
+  # `pd`
+  # :   Array of pairs of integers. Each pair consists of a prime number -- a
+  #     prime factor -- and a natural number -- its exponent (multiplicity).
+  #
+  #
+  # ## Example
+  #     Prime.int_from_prime_division([[3, 2], [5, 1]])  #=> 45
+  #     3**2 * 5                                         #=> 45
+  #
+  def int_from_prime_division: (Array[[ Integer, Integer ]]) -> (Integer | Rational)
+
+  # <!--
+  #   rdoc-file=lib/prime.rb
+  #   - prime?(value, generator = Prime::Generator23.new)
+  # -->
+  # Returns true if `value` is a prime number, else returns false. Integer#prime?
+  # is much more performant.
+  #
+  # ## Parameters
+  #
+  # `value`
+  # :   an arbitrary integer to be checked.
+  # `generator`
+  # :   optional. A pseudo-prime generator.
+  #
+  def self.prime?: (Integer value, ?PseudoPrimeGenerator generator) -> bool
+
+  # <!--
+  #   rdoc-file=lib/prime.rb
+  #   - prime?(value, generator = Prime::Generator23.new)
+  # -->
+  # Returns true if `value` is a prime number, else returns false. Integer#prime?
+  # is much more performant.
+  #
+  # ## Parameters
+  #
+  # `value`
+  # :   an arbitrary integer to be checked.
+  # `generator`
+  # :   optional. A pseudo-prime generator.
+  #
+  def prime?: (Integer value, ?PseudoPrimeGenerator generator) -> bool
+
+  # <!--
+  #   rdoc-file=lib/prime.rb
+  #   - prime_division(value, generator = Prime::Generator23.new)
+  # -->
+  # Returns the factorization of `value`.
+  #
+  # For an arbitrary integer:
+  #
+  #     p_1**e_1 * p_2**e_2 * ... * p_n**e_n,
+  #
+  # prime_division returns an array of pairs of integers:
+  #
+  #     [[p_1, e_1], [p_2, e_2], ..., [p_n, e_n]].
+  #
+  # Each pair consists of a prime number -- a prime factor -- and a natural number
+  # -- its exponent (multiplicity).
+  #
+  # ## Parameters
+  # `value`
+  # :   An arbitrary integer.
+  # `generator`
+  # :   Optional. A pseudo-prime generator. `generator`.succ must return the next
+  #     pseudo-prime number in ascending order. It must generate all prime
+  #     numbers, but may also generate non-prime numbers, too.
+  #
+  #
+  # ### Exceptions
+  # `ZeroDivisionError`
+  # :   when `value` is zero.
+  #
+  #
+  # ## Example
+  #
+  #     Prime.prime_division(45)  #=> [[3, 2], [5, 1]]
+  #     3**2 * 5                  #=> 45
+  #
+  def self.prime_division: (Integer, ?PseudoPrimeGenerator generator) -> Array[[ Integer, Integer ]]
+
+  # <!--
+  #   rdoc-file=lib/prime.rb
+  #   - prime_division(value, generator = Prime::Generator23.new)
+  # -->
+  # Returns the factorization of `value`.
+  #
+  # For an arbitrary integer:
+  #
+  #     p_1**e_1 * p_2**e_2 * ... * p_n**e_n,
+  #
+  # prime_division returns an array of pairs of integers:
+  #
+  #     [[p_1, e_1], [p_2, e_2], ..., [p_n, e_n]].
+  #
+  # Each pair consists of a prime number -- a prime factor -- and a natural number
+  # -- its exponent (multiplicity).
+  #
+  # ## Parameters
+  # `value`
+  # :   An arbitrary integer.
+  # `generator`
+  # :   Optional. A pseudo-prime generator. `generator`.succ must return the next
+  #     pseudo-prime number in ascending order. It must generate all prime
+  #     numbers, but may also generate non-prime numbers, too.
+  #
+  #
+  # ### Exceptions
+  # `ZeroDivisionError`
+  # :   when `value` is zero.
+  #
+  #
+  # ## Example
+  #
+  #     Prime.prime_division(45)  #=> [[3, 2], [5, 1]]
+  #     3**2 * 5                  #=> 45
+  #
+  def prime_division: (Integer, ?PseudoPrimeGenerator generator) -> Array[[ Integer, Integer ]]
+
+  # Returns the singleton instance.
+  #
+  def self.instance: () -> Prime
+
+  # <!-- rdoc-file=lib/prime.rb -->
+  # An abstract class for enumerating pseudo-prime numbers.
+  #
+  # Concrete subclasses should override succ, next, rewind.
+  #
+  class PseudoPrimeGenerator
+    # <!--
+    #   rdoc-file=lib/prime.rb
+    #   - new(ubound = nil)
+    # -->
+    #
+    def initialize: (?Integer?) -> void
+
+    include Enumerable[Integer]
+
+    # <!--
+    #   rdoc-file=lib/prime.rb
+    #   - upper_bound()
+    # -->
+    # ----
+    # <!--
+    #   rdoc-file=lib/prime.rb
+    #   - upper_bound=(ubound)
+    # -->
+    #
+    attr_accessor upper_bound(): Integer?
+
+    # <!--
+    #   rdoc-file=lib/prime.rb
+    #   - each() { |prime| ... }
+    # -->
+    # Iterates the given block for each prime number.
+    #
+    def each: () { (Integer) -> void } -> void
+
+    # <!--
+    #   rdoc-file=lib/prime.rb
+    #   - next()
+    # -->
+    # alias of `succ`.
+    #
+    def next: () -> Integer
+
+    # <!--
+    #   rdoc-file=lib/prime.rb
+    #   - rewind()
+    # -->
+    # Rewinds the internal position for enumeration.
+    #
+    # See `Enumerator`#rewind.
+    #
+    def rewind: () -> void
+
+    # <!--
+    #   rdoc-file=lib/prime.rb
+    #   - size()
+    # -->
+    #
+    def size: () -> Float
+
+    # <!--
+    #   rdoc-file=lib/prime.rb
+    #   - succ()
+    # -->
+    # returns the next pseudo-prime number, and move the internal position forward.
+    #
+    # `PseudoPrimeGenerator`#succ raises `NotImplementedError`.
+    #
+    def succ: () -> Integer
+  end
+
+  # <!-- rdoc-file=lib/prime.rb -->
+  # An implementation of `PseudoPrimeGenerator`.
+  #
+  # Uses `EratosthenesSieve`.
+  #
+  class EratosthenesGenerator < PseudoPrimeGenerator
+  end
+
+  # <!-- rdoc-file=lib/prime.rb -->
+  # An implementation of `PseudoPrimeGenerator` which uses a prime table generated
+  # by trial division.
+  #
+  class TrialDivisionGenerator < PseudoPrimeGenerator
+  end
+
+  # <!-- rdoc-file=lib/prime.rb -->
+  # Generates all integers which are greater than 2 and are not divisible by
+  # either 2 or 3.
+  #
+  # This is a pseudo-prime generator, suitable on checking primality of an integer
+  # by brute force method.
+  #
+  class Generator23 < PseudoPrimeGenerator
+  end
+end

data/docs/handbook/01-getting-started.md

@@ -282,9 +282,9 @@ non-default behaviours: extra `paths`, an alternative
 If you used the [AI-assisted setup](#the-fast-path-let-an-ai-agent-set-it-up),
 the `rigor-project-init` skill already wrote one for you. To
 write a starter by hand, `rigor init` emits `.rigor.dist.yml`
-— the project default that gets committed, with `target_ruby`,
-`paths`, and a `severity_profile` filled in and the rest
-commented out. That is all most projects need; the key
+— the project default that gets committed, with `paths` and a
+`severity_profile` filled in, `target_ruby` commented out until
+you set it to your project's Ruby, and the rest commented out. That is all most projects need; the key
 reference, the JSON-schema editor integration, and `includes:`
 composition are in
 [Configuration](../manual/03-configuration.md).

data/docs/handbook/06-classes.md

@@ -96,7 +96,9 @@ u.name    # Constant<"Alice">  — through in-source dispatch +
 both. The setter's argument type is whatever the call site
 provides. The `def.ivar-write-mismatch` rule (v0.1.2) checks
 that two writes to the same ivar in the same class body
-agree on the concrete class — see
+agree on the concrete class, unless the class's RBS
+declaration of the ivar (`@name: String | Integer`, or
+`attr_reader name: String | Integer`) admits both — see
 [manual — Diagnostics](../manual/04-diagnostics.md)
 for the rule's exact contract; it lets you catch an
 accidental rebind from `String` to `Array` in the same class

data/docs/handbook/08-understanding-errors.md

@@ -114,8 +114,9 @@ mostly a question of *how much* you want to say:
 
 1. **`severity_profile:`** — the project's overall stance.
    `lenient` for a legacy codebase you are easing Rigor into,
-   `balanced` for everyday work, `strict` for a project with
-   no legacy noise.
+   `balanced` for everyday work, new projects included, and
+   `strict` only if you are ready to resolve inference gaps
+   through signatures and RBS yourself.
 2. **`severity_overrides:`** — one rule (or one family) at a
    different severity from the rest of the profile. The right
    layer when a rule is *useful but not blocking* for you.

data/docs/handbook/11-sig-gen.md

@@ -159,6 +159,12 @@ The `sig.skipped.*` reasons are:
   inline and in `sig/`, and the two disagree. A refusal:
   `--write` and `--check` exit `1`. See
   [Methods declared inline](#methods-declared-inline).
+- `sig.skipped.top-level-def` — a plain top-level `def`, which
+  defines a private `Object` method. sig-gen lists it (file,
+  method name and this reason in `--format=json`) but writes no
+  RBS for it, so `--write` and `--check` are unaffected. Its
+  JSON row has no `class` key. `def self.x`, a `def` inside a
+  block body and one inside `class << obj` are not reported.
 - `sig.skipped.unrenderable-rbs` — the signature Rigor
   rendered for this method does not parse as RBS. This one
   is a **bug in Rigor**, not a property of your code: every

data/docs/handbook/appendix-liskov.md

@@ -482,6 +482,11 @@ stays silent), only a proven (`:no`) violation fires, and severity
 maps through `severity_profile:` (`lenient` → off, `balanced` →
 warning, `strict` → error). The ancestor scope is the superclass
 chain plus included/prepended modules, resolved cross-file.
+Constructors and copy hooks (`initialize`, `initialize_copy`,
+`initialize_dup`, `initialize_clone`) are outside the family:
+`Class#new`, `dup` and `clone` call them on the receiver's own class,
+never through a parent-typed reference, so a subclass constructor
+that takes different arguments is not a violation.
 
 The escape hatch for a *legitimate* specialization that looks like a
 narrowing is **generics first, not suppression**: declare the parent