rigortype 0.4.1 → 0.4.3

data/lib/rigor/sig_gen/skip_reason_catalog.rb

@@ -135,6 +135,18 @@ module Rigor
                        "body, not the override the subclass actually runs.",
           next_step: "Generate signatures for the overriding subclass too — widen the `sig-gen` path set to " \
                      "cover it — and the parent's declaration becomes safe to emit."
+        ),
+        "sig.skipped.top-level-def" => Entry.new(
+          id: "sig.skipped.top-level-def",
+          summary: "A top-level `def` defines a private `Object` method, and sig-gen writes no signature for it.",
+          explanation: "Not a gap in inference. A `def` outside any `class` or `module` has no class to " \
+                       "declare the member under, and Ruby makes it a private method on `Object`. sig-gen " \
+                       "reports it instead of dropping it silently, so a file that defines only top-level " \
+                       "methods is not mistaken for one that was never read. Whether to emit it as a private " \
+                       "`Object` method is undecided (#1676); `def self.x` and `def` inside a block body are " \
+                       "not reported.",
+          next_step: "Nothing is required. To type the method, move it into a module (`module_function` or " \
+                     "`extend self` keeps the call sites), or write the `Object` declaration by hand in `sig/`."
         )
       }.freeze
 

data/lib/rigor/source/alias_names.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+require "prism"
+require_relative "symbol_name"
+
+module Rigor
+  module Source
+    # The `[new_name, old_name]` pair a method-alias statement names, read off its syntax alone: the `alias` keyword
+    # (`alias to_m to_modint`, `alias :to_m :to_modint`) and an implicit-self `alias_method :to_m, :to_modint` call
+    # whose two arguments are Symbol or String literals. A computed name (`alias_method name, :x`, an interpolated
+    # symbol) is runtime data and reads as nil, so no walker files an alias for it.
+    #
+    # The one reader the per-file discovery walk ({Inference::ScopeIndexer}) and the `pre_eval:` pre-pass
+    # ({Inference::ProjectPatchedScanner}) share, so a patch file's aliases mean the same thing in both.
+    module AliasNames
+      module_function
+
+      # The pair for an `alias` keyword whose two names are plain symbols (a bare identifier parses as one), or nil.
+      def keyword_names(alias_node)
+        new_name = symbol_name(alias_node.new_name)
+        old_name = symbol_name(alias_node.old_name)
+        return nil if new_name.nil? || old_name.nil?
+
+        [new_name, old_name]
+      end
+
+      # The pair for an implicit-self `alias_method` call with two literal Symbol / String arguments, or nil.
+      def alias_method_call_names(call_node)
+        return nil unless call_node.name == :alias_method && call_node.receiver.nil?
+
+        args = call_node.arguments&.arguments
+        return nil unless args && args.size == 2
+
+        new_name = literal_name(args[0])
+        old_name = literal_name(args[1])
+        return nil if new_name.nil? || old_name.nil?
+
+        [new_name, old_name]
+      end
+
+      def symbol_name(node)
+        node.is_a?(Prism::SymbolNode) ? SymbolName.of(node.unescaped) : nil
+      end
+
+      def literal_name(node)
+        return nil unless node.is_a?(Prism::SymbolNode) || node.is_a?(Prism::StringNode)
+
+        SymbolName.of(node.unescaped)
+      end
+    end
+  end
+end

data/lib/rigor/source/literals.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require "prism"
+require_relative "symbol_name"
 
 module Rigor
   module Source
@@ -34,7 +35,7 @@ module Rigor
       def symbol_or_string(node)
         return nil unless node.is_a?(Prism::SymbolNode) || node.is_a?(Prism::StringNode)
 
-        node.unescaped.to_sym
+        SymbolName.of(node.unescaped)
       end
 
       # The String a literal `Prism::SymbolNode` / `Prism::StringNode` names, or `nil` for any other node
@@ -53,7 +54,7 @@ module Rigor
       def symbol(node)
         return nil unless node.is_a?(Prism::SymbolNode)
 
-        node.unescaped.to_sym
+        SymbolName.of(node.unescaped)
       end
 
       # The String a literal `Prism::SymbolNode` names, or `nil` for any other node (including a

data/lib/rigor/source/symbol_name.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Rigor
+  module Source
+    # The Symbol a name's text denotes, or `nil` when no Symbol can hold its bytes.
+    #
+    # `"\xff".to_sym` raises EncodingError, and a String literal may carry any bytes (a Symbol literal with invalid
+    # bytes is a syntax error, so no analysed file has one). Every reader of a literal name goes through here, so such
+    # a name reads as `nil` — the answer a computed name already gets — instead of aborting the file's analysis (#1821).
+    # `valid_encoding?` is the test, not `ascii_only?`: a name that is valid in its own encoding (a binary or Shift_JIS
+    # source) is a real Symbol.
+    module SymbolName
+      module_function
+
+      def of(text)
+        text.to_sym if text&.valid_encoding?
+      end
+    end
+  end
+end

data/lib/rigor/type/combinator.rb

@@ -832,7 +832,8 @@ module Rigor
         # instead of several readings of it. The normative relation is
         # docs/type-specification/normalization.md § "Member absorption"; {absorbed_by?} is that list.
         #
-        # Only a `FloatRange`, `Tuple` or `HashShape` member can be dropped, so the O(n²) scan is
+        # Only a `FloatRange`, `Tuple`, `HashShape` or element-carrying `Enumerator::ArithmeticSequence` member
+        # can be dropped (the last also joins with its kind, {join_sequence_elements}), so the O(n²) scan is
         # skipped for every union that carries none of them — this runs on the hot path of every join.
         #
         # The `!absorbed_by?(other, member)` re-check costs one predicate call per pair that absorbed
@@ -841,6 +842,7 @@ module Rigor
         def absorb_contained_members(members)
           return members unless members.any? { |m| absorbable_member?(m) }
 
+          members = join_sequence_elements(members)
           members.reject do |member|
             absorbable_member?(member) &&
               members.any? do |other|
@@ -850,7 +852,36 @@ module Rigor
         end
 
         def absorbable_member?(type)
-          type.is_a?(FloatRange) || type.is_a?(Tuple) || type.is_a?(HashShape)
+          type.is_a?(FloatRange) || type.is_a?(Tuple) || type.is_a?(HashShape) || element_sequence?(type)
+        end
+
+        ARITHMETIC_SEQUENCE = "Enumerator::ArithmeticSequence"
+        private_constant :ARITHMETIC_SEQUENCE
+
+        # Issue #1794 — the `Enumerator::ArithmeticSequence[E]` block-less `Integer#step` returns, whose element is
+        # a Rigor-private type argument (`Nominal::RIGOR_PRIVATE_TYPE_ARGS`).
+        def element_sequence?(type)
+          type.is_a?(Nominal) && type.class_name == ARITHMETIC_SEQUENCE && type.type_args.size == 1
+        end
+
+        def plain_sequence?(type)
+          type.is_a?(Nominal) && type.class_name == ARITHMETIC_SEQUENCE && type.type_args.empty?
+        end
+
+        # Two element-carrying sequences join into one over the union of their elements, so a join of
+        # `1.step(10, 2)` and `1.step(10, 3)` stays one sequence whose block reads `Integer`, the answer each arm
+        # gives. (A plain sequence absorbing one with an element is the {absorbed_by?} clause.)
+        def join_sequence_elements(members)
+          sequences = members.select { |member| element_sequence?(member) }
+          return members if sequences.size < 2
+
+          joined = nominal_of(ARITHMETIC_SEQUENCE, type_args: [union(*sequences.map { |seq| seq.type_args.first })])
+          first = sequences.first
+          members.filter_map do |member|
+            if member.equal?(first) then joined
+            elsif !sequences.include?(member) then member
+            end
+          end
         end
 
         # `narrower`'s inhabitants are a subset of `wider`'s under a rule the union already applies to
@@ -864,6 +895,7 @@ module Rigor
           return true if listed_in_union?(narrower, wider)
 
           case narrower
+          when Nominal then element_sequence?(narrower) && plain_sequence?(wider)
           when FloatRange then float_range_absorbed_by?(narrower, wider)
           when Tuple then wider.is_a?(Tuple) && tuple_absorbed_by?(narrower, wider)
           when HashShape then wider.is_a?(HashShape) && hash_shape_absorbed_by?(narrower, wider)

data/lib/rigor/type/float_range.rb

@@ -11,7 +11,7 @@ module Rigor
     # bounds, never sentinels, because Ruby orders them. The range may exclude its end (`0.0...1.0`)
     # and never its beginning, because Ruby's literal has no exclusive begin.
     #
-    # No bounded range contains NaN: `(a..b).cover?(Float::NAN)` is false for every `a` and `b`, so
+    # No bounded range contains NaN (`#covers?` answers false for it on every Ruby), so
     # the range from `-Float::INFINITY` to `Float::INFINITY` is "every Float except NaN"
     # (`non-nan-float`), not `Float`. The whole of `Float` (`nil..nil` in Ruby, which does cover NaN)
     # is never a carrier; the payload builder normalises it to `Nominal[Float]`.
@@ -58,6 +58,9 @@ module Rigor
       # displays as does.
       def covers?(value)
         return false unless value.is_a?(Float)
+        # NaN is in no bounded range, so answer false here: `Range#cover?(Float::NAN)` raises
+        # ArgumentError on ruby-head (4.1), where Ruby 4.0 returned false.
+        return false if value.nan?
 
         Range.new(min, max, @exclude_end).cover?(value)
       end

data/lib/rigor/type/nominal.rb

@@ -49,9 +49,14 @@ module Rigor
         "#{rendered_name}[#{rendered}]"
       end
 
+      # Classes RBS declares without a type parameter, on which Rigor carries one of its own: the element type of
+      # the `Enumerator::ArithmeticSequence` that `Integer#step` returns (issue #1794). RBS has no slot for it, so
+      # the argument erases away.
+      RIGOR_PRIVATE_TYPE_ARGS = %w[Enumerator::ArithmeticSequence].freeze
+
       def erase_to_rbs
         return "untyped" if AnonymousClassName.match?(class_name)
-        return class_name if type_args.empty?
+        return class_name if type_args.empty? || RIGOR_PRIVATE_TYPE_ARGS.include?(class_name)
 
         rendered = type_args.map(&:erase_to_rbs).join(", ")
         "#{class_name}[#{rendered}]"

data/lib/rigor/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Rigor
-  VERSION = "0.4.1"
+  VERSION = "0.4.3"
 end

data/plugins/rigor-ac-library-rb/lib/rigor/plugin/ac_library_rb.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require "rigor/plugin"
+
+module Rigor
+  module Plugin
+    # A pure RBS-bundle plugin for ac-library-rb, the Ruby port of the AtCoder Library. It emits no diagnostic and
+    # declares no producer: the manifest's `signature_paths: ["sig"]` adds the bundled `AcLibraryRb` signatures to the
+    # RBS environment.
+    #
+    # Inference cannot write these. The containers are generic over values the caller picks (a segment tree's monoid,
+    # a priority queue's elements), and their methods read parameters no call site in the library constrains, so
+    # `rigor sig-gen` over the gem's `lib_lock/` leaves 95 of its methods untyped. The signatures were written against
+    # that output and the gem's documentation, and `rigor check` over `lib_lock/` holds the method bodies to them.
+    class AcLibraryRb < Base
+      manifest(
+        id: "ac-library-rb",
+        target_gems: ["ac-library-rb"],
+        version: "0.1.0",
+        description: "RBS bundle for ac-library-rb (AtCoder Library): Segtree, LazySegtree, DSU, ModInt, flows " \
+                     "and the math and string algorithms.",
+        signature_paths: ["sig"]
+      )
+    end
+  end
+end
+
+Rigor::Plugin.register(Rigor::Plugin::AcLibraryRb)

data/plugins/rigor-ac-library-rb/lib/rigor-ac-library-rb.rb

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+require_relative "rigor/plugin/ac_library_rb"

data/plugins/rigor-ac-library-rb/sig/ac_library_rb/convolution.rbs

@@ -0,0 +1,7 @@
+module AcLibraryRb
+  class Convolution
+    def initialize: (?Integer mod, ?Integer? primitive_root) -> void
+
+    def convolution: (Array[Integer] a, Array[Integer] b) -> Array[Integer]
+  end
+end

data/plugins/rigor-ac-library-rb/sig/ac_library_rb/data_structures.rbs

@@ -0,0 +1,160 @@
+module AcLibraryRb
+  class DSU
+    attr_reader parent_or_size: Array[Integer]
+    attr_reader n: Integer
+
+    def initialize: (?Integer n) -> void
+
+    # The leader of the merged component.
+    def merge: (Integer a, Integer b) -> Integer
+    alias unite merge
+
+    def same?: (Integer a, Integer b) -> bool
+    alias same same?
+
+    def leader: (Integer a) -> Integer
+    alias root leader
+    alias find leader
+
+    # Like `leader`, growing the set to hold `a` when it is out of range.
+    def []: (Integer a) -> Integer
+
+    def size: (Integer a) -> Integer
+
+    def groups: () -> Array[Array[Integer]]
+
+    def to_s: () -> String
+  end
+
+  class UnionFind = DSU
+
+  # Element values are whatever the caller adds: the tree starts from `0` and adds with `+`, so an
+  # `Integer`, a `Float` and a `ModInt` all work.
+  class FenwickTree
+    attr_reader data: Array[untyped]
+    attr_reader size: Integer
+
+    def initialize: (Array[untyped] | Integer arg) -> void
+
+    def add: (Integer i, untyped x) -> void
+
+    def sum: (Integer l, Integer r) -> untyped
+           | (Integer r) -> untyped
+           | (Range[Integer] range) -> untyped
+
+    def _sum: (Integer i) -> untyped
+    alias left_sum _sum
+
+    def to_s: () -> String
+  end
+
+  # A binary heap that pops the highest-priority element first: the largest by default, or the first
+  # argument of the block when it returns truthy.
+  class PriorityQueue[T]
+    # The factories answer `PriorityQueue[untyped]`: bound from a literal array, `T` would be the literals it
+    # starts with, and a later `pop` would read as one of them.
+    def self.max: (Array[untyped] array) -> PriorityQueue[untyped]
+
+    def self.min: (Array[untyped] array) -> PriorityQueue[untyped]
+
+    def self.[]: (*untyped array) ?{ (untyped, untyped) -> boolish } -> PriorityQueue[untyped]
+
+    def initialize: (?Array[T] array) ?{ (T, T) -> boolish } -> void
+
+    attr_reader heap: Array[T]
+    alias to_a heap
+
+    def push: (T item) -> self
+    alias << push
+    alias append push
+
+    def pop: () -> T?
+
+    def get: () -> T?
+    alias top get
+    alias first get
+
+    def empty?: () -> bool
+
+    def size: () -> Integer
+
+    def to_s: () -> String
+  end
+
+  class HeapQueue = PriorityQueue
+
+  class Deque[T]
+    include Enumerable[T]
+
+    def self.[]: (*untyped args) -> Deque[untyped]
+
+    def initialize: (?Array[T] arg, ?untyped value, ?initial_capacity: Integer) -> void
+                  | (Integer size, ?T value, ?initial_capacity: Integer) -> void
+
+    def empty?: () -> bool
+
+    def size: () -> Integer
+    alias length size
+
+    def <<: (T x) -> self
+
+    def push: (*T args) -> self
+    alias append push
+
+    def unshift: (*T args) -> self
+    alias prepend unshift
+
+    def pop: () -> T?
+
+    def shift: () -> T?
+
+    def last: () -> T?
+
+    def slice: (Integer idx) -> T?
+
+    def []: (Integer idx) -> T?
+          | (Integer start, Integer length) -> Deque[T]?
+          | (Range[Integer] range) -> Deque[T]?
+
+    def at: (Integer idx) -> T?
+
+    def []=: (Integer idx, T value) -> T
+
+    def ==: (untyped other) -> bool
+
+    def hash: () -> Integer
+
+    def reverse: () -> Deque[T]
+
+    def reverse!: () -> self
+
+    def reversed?: () -> bool
+
+    def dig: (int idx, *untyped) -> untyped
+
+    def each: () { (T) -> void } -> Array[T]
+            | () -> Enumerator[T, Array[T]]
+
+    def clear: () -> self
+
+    def join: (?String? sep) -> String
+
+    def rotate!: (?Integer cnt) -> self
+
+    def rotate: (?Integer cnt) -> Deque[T]
+
+    def sample: () -> T?
+
+    def shuffle: () -> Deque[T]
+
+    def replace: (_ToA[T] other) -> self
+
+    def swap: (Integer i, Integer j) -> self
+
+    def to_a: () -> Array[T]
+
+    def to_s: () -> String
+
+    def inspect: () -> String
+  end
+end

data/plugins/rigor-ac-library-rb/sig/ac_library_rb/graph.rbs

@@ -0,0 +1,94 @@
+module AcLibraryRb
+  class MaxFlow
+    def initialize: (Integer n) -> void
+
+    # The index of the added edge.
+    def add_edge: (Integer from, Integer to, Integer cap) -> Integer
+
+    def add_edges: (_Each[[Integer, Integer, Integer]] edges) -> self
+
+    def add: (Integer from, Integer to, Integer cap) -> Integer
+           | (_Each[[Integer, Integer, Integer]] edges) -> self
+
+    # `[from, to, cap]`, as `gets.split.map(&:to_i)` reads it.
+    def push: (Array[Integer] edge) -> Integer
+    alias << push
+
+    # `[from, to, cap, flow]` of the `i`-th edge.
+    def []: (Integer i) -> [Integer, Integer, Integer, Integer]
+    alias get_edge []
+    alias edge []
+
+    def edges: () -> Array[[Integer, Integer, Integer, Integer]]
+
+    def change_edge: (Integer i, Integer new_cap, Integer new_flow) -> void
+
+    # A `Float` limit the capacities do not bound comes back as the flow.
+    def flow: (Integer s, Integer t, ?Integer flow_limit) -> Integer
+            | (Integer s, Integer t, (Integer | Float) flow_limit) -> (Integer | Float)
+    alias max_flow flow
+
+    # Whether each vertex is reachable from `s` in the residual graph.
+    def min_cut: (Integer s) -> Array[bool]
+  end
+
+  class MinCostFlow
+    def initialize: (Integer n) -> void
+
+    # The index of the added edge.
+    def add_edge: (Integer from, Integer to, Integer cap, Integer cost) -> Integer
+
+    def add_edges: (_Each[[Integer, Integer, Integer, Integer]] edges) -> self
+
+    def add: (Integer from, Integer to, Integer cap, Integer cost) -> Integer
+           | (_Each[[Integer, Integer, Integer, Integer]] edges) -> self
+
+    # `[from, to, cap, flow, cost]` of the `i`-th edge.
+    def get_edge: (Integer i) -> [Integer, Integer, Integer, Integer, Integer]
+    alias edge get_edge
+    alias [] get_edge
+
+    def edges: () -> Array[[Integer, Integer, Integer, Integer, Integer]]
+
+    # `[flow, cost]`.
+    # The default limit is `Float::MAX`, which the capacities always bound; a smaller `Float` limit may not.
+    def flow: (Integer s, Integer t, ?Integer flow_limit) -> [Integer, Integer]
+            | (Integer s, Integer t, (Integer | Float) flow_limit) -> [Integer | Float, Integer | Float]
+    alias min_cost_max_flow flow
+
+    def dual_ref: (Integer s, Integer t) -> bool
+
+    # The `[flow, cost]` breakpoints of the cost curve.
+    def slope: (Integer s, Integer t, ?Integer flow_limit) -> Array[[Integer, Integer]]
+             | (Integer s, Integer t, (Integer | Float) flow_limit) -> Array[[Integer | Float, Integer | Float]]
+    alias min_cost_slop slope
+  end
+
+  class SCC
+    def initialize: (Integer n) -> void
+
+    def add_edge: (Integer from, Integer to) -> self
+
+    def add_edges: (_Each[[Integer, Integer]] edges) -> self
+
+    def add: (Integer from, Integer to) -> self
+           | (_Each[[Integer, Integer]] edges) -> self
+
+    # The strongly connected components in topological order.
+    def scc: () -> Array[Array[Integer]]
+  end
+
+  class TwoSAT
+    def initialize: (Integer n) -> void
+
+    # One assignment per variable once `satisfiable?` has answered true; `nil` before that.
+    attr_reader answer: Array[bool?]
+
+    def add_clause: (Integer i, boolish f, Integer j, boolish g) -> nil
+
+    def satisfiable?: () -> bool
+    alias satisfiable satisfiable?
+  end
+
+  class TwoSat = TwoSAT
+end

data/plugins/rigor-ac-library-rb/sig/ac_library_rb/math.rbs

@@ -0,0 +1,42 @@
+# ac-library-rb's math and string algorithms, instance methods of `AcLibraryRb` that a caller reaches by
+# including the module.
+module AcLibraryRb
+  # A callable taking two arguments: a `Proc`, a lambda or a `Method`.
+  interface _Call2[A, B, R]
+    def call: (A, B) -> R
+  end
+
+  # An object `Deque#replace` can read elements from.
+  interface _ToA[T]
+    def to_a: () -> Array[T]
+  end
+
+  def convolution: (Array[Integer] a, Array[Integer] b, ?mod: Integer, ?k: Integer, ?z: Integer) -> Array[Integer]
+
+  # `[remainder, modulus]`, or `[0, 0]` when there is no solution.
+  def crt: (Array[Integer] r, Array[Integer] m) -> [Integer, Integer]
+
+  def inv_gcd: (Integer a, Integer b) -> [Integer, Integer]
+
+  def floor_sum: (Integer n, Integer m, Integer a, Integer b) -> Integer
+
+  def floor_sum_unsigned: (Integer n, Integer m, Integer a, Integer b) -> Integer
+
+  def inv_mod: (Integer x, Integer m) -> Integer
+
+  def _inv_gcd: (Integer a, Integer b) -> [Integer, Integer]
+
+  def pow_mod: (Integer x, Integer n, Integer m) -> Integer
+
+  def suffix_array: (String s) -> Array[Integer]
+                  | (Array[untyped] a, ?Integer? upper) -> Array[Integer]
+
+  def sa_is: (Array[Integer] s, Integer upper) -> Array[Integer]
+
+  def sa_is_induce: (Array[Integer] s, Array[bool] ls, Array[Integer] sum_l, Array[Integer] sum_s,
+                     Array[Integer] lms) -> Array[Integer]
+
+  def lcp_array: (String | Array[untyped] s, Array[Integer] sa) -> Array[Integer]
+
+  def z_algorithm: (String | Array[untyped] s) -> Array[Integer]
+end

data/plugins/rigor-ac-library-rb/sig/ac_library_rb/modint.rbs

@@ -0,0 +1,71 @@
+module AcLibraryRb
+  # An integer modulo the global modulus set by `ModInt.set_mod`.
+  class ModInt < ::Numeric
+    def self.set_mod: (Integer mod) -> bool
+
+    def self.mod=: (Integer mod) -> bool
+
+    def self.mod: () -> Integer
+
+    def self.raw: (_ToI val) -> ModInt
+
+    def self.prime?: (Integer n) -> bool
+
+    def self.inv_gcd: (Integer a, Integer b) -> [Integer, Integer]
+
+    attr_accessor val: Integer
+    alias to_i val
+
+    def initialize: (?_ToI val) -> void
+
+    def inc!: () -> self
+
+    def dec!: () -> self
+
+    def add!: (_ToI other) -> self
+
+    def sub!: (_ToI other) -> self
+
+    def mul!: (_ToI other) -> self
+
+    def div!: (_ToI other) -> self
+
+    def +@: () -> self
+
+    def -@: () -> ModInt
+
+    # Answers the Integer `0` when the modulus is 1. Declared `ModInt` all the same: a union return reached
+    # `1 + m ** 2` as an argument, where overload selection reads a union whole (#1356), typed the sum `Integer`
+    # and reported `call.undefined-method` for `.val` on correct code.
+    def **: (Integer other) -> ModInt
+    alias pow **
+
+    def inv: () -> ModInt
+
+    def coerce: (_ToI other) -> [ModInt, ModInt]
+
+    def +: (_ToI other) -> ModInt
+
+    def -: (_ToI other) -> ModInt
+
+    def *: (_ToI other) -> ModInt
+
+    def /: (_ToI other) -> ModInt
+
+    def ==: (untyped other) -> bool
+
+    def pred: () -> ModInt
+
+    def succ: () -> ModInt
+
+    def zero?: () -> bool
+
+    def dup: () -> ModInt
+
+    def to_int: () -> Integer
+
+    def to_s: () -> String
+
+    def inspect: () -> String
+  end
+end

data/plugins/rigor-ac-library-rb/sig/ac_library_rb/object.rbs

@@ -0,0 +1,37 @@
+# The core extensions under `ac-library-rb/core_ext/`. `ac-library-rb/modint` loads the `ModInt` conversions;
+# `Integer#divisors` and the `Array` conversions need `ac-library-rb/core_ext/all` (or `integer`).
+class Object
+  private
+
+  def ModInt: (_ToI val) -> AcLibraryRb::ModInt
+end
+
+class Array[unchecked out Elem]
+  def to_fenwick_tree: () -> AcLibraryRb::FenwickTree
+  alias to_fetree to_fenwick_tree
+
+  # The element type is not carried over: a literal array would pin it to the literals it starts with.
+  def to_priority_queue: () -> AcLibraryRb::PriorityQueue[untyped]
+  alias to_pq to_priority_queue
+end
+
+class Integer
+  # `ModInt#coerce` makes an Integer on the left answer a `ModInt`.
+  def +: (AcLibraryRb::ModInt) -> AcLibraryRb::ModInt | ...
+  def -: (AcLibraryRb::ModInt) -> AcLibraryRb::ModInt | ...
+  def *: (AcLibraryRb::ModInt) -> AcLibraryRb::ModInt | ...
+  def /: (AcLibraryRb::ModInt) -> AcLibraryRb::ModInt | ...
+
+  def divisors: () -> Array[Integer]
+
+  def each_divisor: () { (Integer) -> void } -> Array[Integer]
+                  | () -> Enumerator[Integer, Array[Integer]]
+
+  def to_modint: () -> AcLibraryRb::ModInt
+  alias to_m to_modint
+end
+
+class String
+  def to_modint: () -> AcLibraryRb::ModInt
+  alias to_m to_modint
+end