rigortype 0.4.0 → 0.4.2

data/lib/rigor/sig_gen/alias_index.rb

@@ -142,7 +142,7 @@ module Rigor
         buffer_name = decl.location&.buffer&.name
         return nil if buffer_name.nil?
 
-        File.expand_path(buffer_name.to_s)
+        File.absolute_path(buffer_name.to_s)
       rescue StandardError
         nil
       end

data/lib/rigor/sig_gen/classification.rb

@@ -57,7 +57,10 @@ module Rigor
         inline_generic_class: "sig.skipped.inline-generic-class",
         # ADR-112 WD4 — the member is declared inline and in `sig/`, and the two disagree. A refusal, not a
         # skip: `--write` and `--check` exit 1 until a person reconciles them or passes `--overwrite`.
-        inline_differs: "sig.skipped.inline-differs"
+        inline_differs: "sig.skipped.inline-differs",
+        # #1676 — a plain top-level `def` defines a private `Object` method and has no class to write a
+        # declaration under, so it is reported rather than silently dropped. Whether to emit it stays open.
+        top_level_def: "sig.skipped.top-level-def"
       }.freeze
     end
   end

data/lib/rigor/sig_gen/effect_annotation.rb

@@ -182,8 +182,8 @@ module Rigor
         def relative_path(path)
           return nil if path.nil?
 
-          expanded = File.expand_path(path.to_s)
-          root = "#{File.expand_path(Dir.pwd)}#{File::SEPARATOR}"
+          expanded = File.absolute_path(path.to_s)
+          root = "#{File.absolute_path(Dir.pwd)}#{File::SEPARATOR}"
           expanded.start_with?(root) ? expanded.delete_prefix(root) : nil
         end
 

data/lib/rigor/sig_gen/generator.rb

@@ -13,6 +13,7 @@ require_relative "../source/literals"
 require_relative "../source/node_children"
 require_relative "../inference/def_return_typer"
 require_relative "../inference/scope_indexer"
+require_relative "../inference/module_function_state"
 require_relative "../inference/rbs_type_translator"
 require_relative "alias_index"
 require_relative "meta_class_shape"
@@ -99,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 }`.
@@ -464,7 +468,7 @@ module Rigor
         @class_superclasses = {}
         @meta_layouts = collect_meta_layouts(scope_index)
         register_meta_classes
-        defs = collect_method_definitions(parse_result.value)
+        defs = collect_method_definitions(parse_result.value, scope_index)
         # Candidate construction freezes the per-file maps above (see {#build_candidate}), so every registration
         # pass has to be finished before the first `build_candidate` call. Meta members lead the RETURNED order —
         # a value class's members and constructors read first, ahead of the methods its block body defines.
@@ -474,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
@@ -485,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:
@@ -497,8 +502,12 @@ module Rigor
       # - `@module_function_methods` records `(class_name, method_name)` pairs where a `module_function` (no
       #   args) call preceded the `def` inside a module body. The renderer emits `def self?.name` for these, the
       #   RBS spelling that matches the dual instance + singleton dispatch the runtime produces.
-      def collect_method_definitions(root)
+      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
@@ -528,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
@@ -542,6 +564,11 @@ module Rigor
       # `prefix` stays the nesting the header is WRITTEN in for {#record_superclass}: `::` re-anchors the
       # declaration, not the superclass expression beside it, which Ruby still evaluates in the enclosing cref.
       def descend_into_namespace?(node, prefix, out)
+        # Issue #1518 — a `class self::X` / `module self::X` the indexer declined (`self` is opaque, as under
+        # `REGISTRY.first.class_eval`) names no class, so its body must not be written out under the lexical
+        # `X`. The indexer's identity table is the single source of that decision.
+        return true if declined_self_header?(node)
+
         child_prefix = Source::ConstantPath.declaration_prefix(prefix, node.constant_path)
         return false unless child_prefix
 
@@ -552,6 +579,26 @@ 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) &&
+          !@declared_types.key?(path)
+      end
+
       # ADR-14: a generated subclass declaration MUST carry its superclass, or the sidecar `sig/` misrepresents
       # the class (inherited members vanish → receiver dispatch degrades to `Dynamic`) and, worse, a nested
       # reference to an inherited type re-declares the class as a bare namespace on the RBS side and can
@@ -648,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)
@@ -662,29 +710,28 @@ module Rigor
         walk_defs(namespace_node.body, prefix, false, false, out)
       end
 
+      # The directive's reach is {Inference::ModuleFunctionState.each_sig_gen_statement}.
       def walk_statements(stmts_node, prefix, in_singleton_class, module_function_active, out)
-        stmts_node.body.each do |stmt|
-          if module_function_directive?(stmt)
-            module_function_active = true
-            next
-          end
-          walk_defs(stmt, prefix, in_singleton_class, module_function_active, out)
+        Inference::ModuleFunctionState.each_sig_gen_statement(stmts_node.body,
+                                                              module_function_active) do |stmt, active|
+          walk_defs(stmt, prefix, in_singleton_class, active, out)
         end
       end
 
-      def module_function_directive?(node)
-        return false unless node.is_a?(Prism::CallNode)
-        return false unless node.name == :module_function && node.receiver.nil?
-
-        (node.arguments&.arguments || []).empty?
-      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("::")
-        @module_function_methods << [class_name, node.name] if module_function_active && kind == :instance
+        if Inference::ModuleFunctionState.sig_gen_module_function?(module_function_active, kind)
+          @module_function_methods << [class_name, node.name]
+        end
         out << [node, class_name, kind]
       end
 
@@ -909,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)
@@ -1706,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)
@@ -991,13 +1023,37 @@ module Rigor
           end
         end
 
+        # The order a new union or intersection keeps: by each member's `describe(:short)`, which is
+        # observable in messages and in cache fingerprints, so it must not move. Two members, the common
+        # case, compare directly instead of paying `sort_by`'s work arrays; `sort_by` keeps an equal pair in
+        # place as well ([#1505](https://github.com/rigortype/rigor/issues/1505)).
         def sort_members(members)
-          members.sort_by { |m| m.describe(:short) }
+          if members.size == 2
+            first, second = members
+            return sort_key(second) < sort_key(first) ? [second, first] : members
+          end
+
+          members.sort_by { |member| sort_key(member) }
+        end
+
+        # A member's `describe(:short)`, rendered at most once per type instance between garbage collections.
+        # No type carrier has a method that changes it once built (a built type is frozen; one `Marshal.load`
+        # restores is not, but nothing mutates it either), so a memoised key cannot go stale. The memo is weak
+        # in both key and value: it keeps neither the type nor the string alive, and an entry whose string
+        # nothing else holds is dropped at the next GC. It is keyed by identity on purpose: `Constant[0.0]` and
+        # `Constant[-0.0]` are equal and hash alike, but render differently. A non-main Ractor may not read the
+        # module's ivar, so a pool worker renders the key every time, as every run did before.
+        def sort_key(member)
+          return member.describe(:short) unless Ractor.main?
+
+          @sort_keys[member] ||= member.describe(:short)
         end
       end
 
       # Eager-allocated at load time; see `untyped` method comment above.
       @untyped = Dynamic.new(Top.instance)
+      # The main Ractor's {sort_key} memo, allocated here for the same reason.
+      @sort_keys = ObjectSpace::WeakMap.new
 
       NIL_CONSTANT = Constant.new(nil)
       TRUE_CONSTANT = Constant.new(true)

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.0"
+  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