rigortype 0.4.1 → 0.4.2

data/lib/rigor/sig_gen/generator.rb

@@ -100,6 +100,9 @@ module Rigor
         @class_shells = Set.new
         @class_superclasses = {}
         @meta_layouts = {}
+        # Issue #1763 — the walked file's tree, and its refine-call query, built only when a `refine` call is walked.
+        @walk_root = nil
+        @in_effect_refinements = nil
         # Whole-run, NOT per-file: a rendering defect is reported once at the end of the run.
         @unrenderable = []
         # Issue #735 — whole-run too: `{ class name => the superclass token that resolves nowhere }`.
@@ -475,7 +478,7 @@ module Rigor
           # `rigor sig-gen` run. The `check` path recovers each *file* this way (worker_session.rb); sig-gen
           # recovers per-def so the rest of the file's candidates still emit.
 
-          classify_def(path, def_node, class_name, kind, scope_index)
+          classify_collected_def(path, def_node, class_name, kind, scope_index)
         rescue StandardError
           nil
         end
@@ -486,8 +489,9 @@ module Rigor
 
       # Walks the AST collecting `(def_node, class_name, kind)` tuples for every `def` Rigor can re-type. Slice 1
       # covered instance `def foo` methods inside a nameable `class` / `module` body. Slice 4 extends this to
-      # singleton-side methods via `def self.foo` and `class << self; def foo; end`; top-level / DSL-block defs
-      # still degrade silently (no nameable receiver).
+      # singleton-side methods via `def self.foo` and `class << self; def foo; end`. A plain top-level `def` is
+      # collected with a nil class and reported as skipped (#1676); DSL-block defs still degrade silently (no
+      # nameable receiver).
       #
       # ADR-14 gap-#3 follow-up tracks two extra pieces during the same walk so the Writer can emit kind-correct
       # RBS without guessing:
@@ -500,7 +504,10 @@ module Rigor
       #   RBS spelling that matches the dual instance + singleton dispatch the runtime produces.
       def collect_method_definitions(root, scope_index)
         @declared_types = scope_index[root].declared_types
+        @walk_root = root
+        @in_effect_refinements = nil
         out = []
+        @block_depth = 0
         walk_defs(root, [], false, false, out)
         out
       end
@@ -530,9 +537,22 @@ module Rigor
           return
         end
 
+        walk_def_children(node, prefix, in_singleton_class, module_function_active, out)
+      end
+
+      # #1676 — a block body is a DSL scope, not the file's top level, so a `def` inside one is not reported
+      # as a top-level def. Neither is a `def` in `class << obj` (a non-`self` singleton body reaches here,
+      # the `self` one returns above): it defines a singleton method on `obj`, not a private `Object` method.
+      def walk_def_children(node, prefix, in_singleton_class, module_function_active, out)
+        return if refine_block_call?(node)
+
+        in_block = node.is_a?(Prism::BlockNode) || node.is_a?(Prism::LambdaNode) ||
+                   node.is_a?(Prism::SingletonClassNode)
+        @block_depth += 1 if in_block
         node.rigor_each_child do |child|
           walk_defs(child, prefix, in_singleton_class, module_function_active, out)
         end
+        @block_depth -= 1 if in_block
       end
 
       # [#722](https://github.com/rigortype/rigor/issues/722) residue 3 — the qualified name is built by
@@ -559,6 +579,20 @@ module Rigor
         true
       end
 
+      # Issue #1763 — a `def` (or an `attr_*`) in a `refine X do … end` block defines a method of the refinement
+      # module, not of the namespace the block is written in, and RBS has no declaration for a refinement, so both
+      # walks skip the whole block: writing `def shout: () -> String` under the enclosing module declared a method
+      # that module does not have. Statement and value position alike, since the walks descend every child. The
+      # skip is silent, as for a top-level `def`: a `sig.skipped.*` row would name the enclosing class, the very
+      # misattribution this avoids. A `refine` call the engine reads as a class's own method (`Class` undefines
+      # `refine`, #1689) walks as any other block, as the engine treats it.
+      def refine_block_call?(node)
+        return false unless node.is_a?(Prism::CallNode) && Inference::ScopeIndexer.refine_call?(node)
+
+        @in_effect_refinements ||= Inference::InEffectRefinements.new(@walk_root)
+        !@in_effect_refinements.class_body_refine?(node)
+      end
+
       def declined_self_header?(node)
         path = node.constant_path
         path.is_a?(Prism::ConstantPathNode) && path.parent.is_a?(Prism::SelfNode) &&
@@ -661,7 +695,8 @@ module Rigor
         return nil unless node.value.is_a?(Prism::CallNode)
         return nil unless @meta_layouts.key?((prefix + [node.name.to_s]).join("::"))
 
-        node.value.block&.body
+        block = node.value.block
+        block.body if block.is_a?(Prism::BlockNode)
       end
 
       # Module / class bodies are walked through the `walk_statements` path so `module_function` (no-args)
@@ -684,7 +719,13 @@ module Rigor
       end
 
       def collect_def_node(node, prefix, in_singleton_class, module_function_active, out)
-        return if prefix.empty?
+        if prefix.empty?
+          # #1676 — a plain top-level `def` defines a private `Object` method. It is surfaced as a skipped
+          # candidate (no class to write it under) rather than dropped; `def self.x` and block-body defs stay
+          # unreported.
+          out << [node, nil, :instance] if node.receiver.nil? && !in_singleton_class && @block_depth.zero?
+          return
+        end
 
         kind = node.receiver.is_a?(Prism::SelfNode) || in_singleton_class ? :singleton : :instance
         class_name = prefix.join("::")
@@ -915,6 +956,13 @@ module Rigor
         end
       end
 
+      # #1676 — a top-level `def` is collected with no class; it is reported, never typed.
+      def classify_collected_def(path, def_node, class_name, kind, scope_index)
+        return skipped(path, def_node, class_name, kind, :top_level_def) if class_name.nil?
+
+        classify_def(path, def_node, class_name, kind, scope_index)
+      end
+
       def classify_def(path, def_node, class_name, kind, scope_index)
         return nil if visibility_excludes?(def_node, class_name, kind, scope_index)
         return nil if initialize_excludes?(def_node, kind)
@@ -1712,6 +1760,8 @@ module Rigor
             return
           end
         when Prism::CallNode
+          return if refine_block_call?(node)
+
           collect_attr_call(node, prefix, in_singleton_class, ctx)
         end
 

data/lib/rigor/sig_gen/method_candidate.rb

@@ -11,8 +11,8 @@ module Rigor
     # applicable to that classification.
     #
     # - `path` — the source `.rb` file the def came from.
-    # - `class_name` — qualified receiver class name (e.g. `"Foo::Bar"`). `nil` for top-level / DSL-block defs
-    #   the MVP skips.
+    # - `class_name` — qualified receiver class name (e.g. `"Foo::Bar"`). `nil` for a top-level `def`, which is only
+    #   ever `skipped` (`sig.skipped.top-level-def`, #1676).
     # - `method_name` — the def's `Symbol` name.
     # - `kind` — `:instance` or `:singleton`.
     # - `inferred_return` — `Rigor::Type` instance (or `nil` when the inference pass disqualified the def).

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.2"
 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