rigortype 0.4.0 → 0.4.2

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

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

@@ -0,0 +1,83 @@
+module AcLibraryRb
+  # A segment tree over the monoid `(S, op, e)`.
+  class Segtree[S]
+    attr_reader d: Array[S]
+    attr_reader op: _Call2[S, S, S]
+    attr_reader n: Integer
+    attr_reader leaf_size: Integer
+    attr_reader log: Integer
+
+    def initialize: (Array[S] | Integer v, S e) { (S, S) -> S } -> void
+                  | (Array[S] | Integer v, _Call2[S, S, S] op, S e) -> void
+
+    def set: (Integer pos, S x) -> void
+    alias []= set
+
+    def get: (Integer pos) -> S
+    alias [] get
+
+    def prod: (Integer l, Integer r) -> S
+            | (Range[Integer] range) -> S
+
+    def all_prod: () -> S
+
+    def max_right: (Integer l) { (S) -> boolish } -> Integer
+
+    def min_left: (Integer r) { (S) -> boolish } -> Integer
+
+    def update: (Integer k) -> S
+  end
+
+  class SegTree = Segtree
+
+  # A lazy segment tree over the monoid `(S, op, e)` acted on by the maps `(F, composition, id)`, where
+  # `mapping.call(f, x)` applies `f` to `x` and `composition.call(f, g)` is `f` after `g`.
+  class LazySegtree[S, F]
+    attr_reader d: Array[S]
+    attr_reader lz: Array[F]
+    attr_reader e: S
+    attr_reader id: F
+    attr_accessor op: _Call2[S, S, S]
+    attr_accessor mapping: _Call2[F, S, S]?
+    attr_accessor composition: _Call2[F, F, F]?
+
+    # The first form is chosen when the second argument is a `Proc`.
+    def initialize: (Array[S] | Integer v, ^(S, S) -> S op, S e, _Call2[F, S, S] mapping,
+                     _Call2[F, F, F] composition, F id) -> void
+                  | (Array[S] | Integer v, S e, F id, ?_Call2[S, S, S]? op, ?_Call2[F, S, S]? mapping,
+                     ?_Call2[F, F, F]? composition) ?{ (S, S) -> S } -> void
+
+    def set_mapping: () { (F, S) -> S } -> Proc
+
+    def set_composition: () { (F, F) -> F } -> Proc
+
+    def set: (Integer pos, S x) -> void
+    alias []= set
+
+    def get: (Integer pos) -> S
+    alias [] get
+
+    def prod: (Integer l, Integer r) -> S
+            | (Range[Integer] range) -> S
+
+    def all_prod: () -> S
+
+    def apply: (Integer pos, F f) -> void
+             | (Integer l, Integer r, F f) -> void
+             | (Range[Integer] range, F f) -> void
+
+    def range_apply: (Integer l, Integer r, F f) -> void
+
+    def max_right: (Integer l) { (S) -> boolish } -> Integer
+
+    def min_left: (Integer r) { (S) -> boolish } -> Integer
+
+    def update: (Integer k) -> S
+
+    def all_apply: (Integer k, F f) -> void
+
+    def push: (Integer k) -> void
+  end
+
+  class LazySegTree = LazySegtree
+end

data/plugins/rigor-actionpack/lib/rigor/plugin/actionpack/analyzer.rb

@@ -309,8 +309,9 @@ module Rigor
           args
         end
 
+        # The name is interned later (`filter_name.to_sym`), so a name no Symbol can hold reads as nil.
         def literal_symbol_or_string(node)
-          Rigor::Source::Literals.symbol_or_string_name(node)
+          Rigor::Source::Literals.symbol_or_string(node)&.to_s
         end
 
         def filter_lookup_violation(call_node, arg_node, filter_name, methods, spell_checker, ambiguous_filters:)

data/plugins/rigor-activerecord/lib/rigor/plugin/activerecord/association_roots.rb

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+
+module Rigor
+  module Plugin
+    class Activerecord < Rigor::Plugin::Base
+      # The model classes ActiveRecord loads BY NAME from an association (`belongs_to :user` → `User`), for
+      # `rigor unused` (ADR-102 WD3). The name is derived at runtime and never written in source, so a
+      # reference index sees a model reached only this way as unreferenced.
+      #
+      # The rows come from the {ModelIndex}'s association list, which {ModelDiscoverer} already extracts
+      # (class-body declarations and `with_options` groups only — not `class << self`, a `def` or another
+      # block). This module only resolves them, mirroring ActiveRecord:
+      #
+      # - `class_name:` (String or Symbol) wins; `"::Foo"` is rooted.
+      # - otherwise `has_many` / `has_and_belongs_to_many` → `name.singularize.camelize`, and
+      #   `belongs_to` / `has_one` → `name.camelize` (`Reflection#derive_class_name`).
+      # - the name is tried as nested in the owner itself, then in each enclosing namespace innermost first,
+      #   then at top level (`ActiveRecord::Inheritance#compute_type`).
+      # - a root is published only when the project declares a model of that name.
+      #
+      # Declined — no root, never a guess: a polymorphic association (no single target), a non-literal
+      # `class_name:` / `**opts`, `anonymous_class:`, a `with_options` group with non-literal options, and a
+      # `through:` association without a literal `class_name:` / `source_type:`. Without them a `through:` target is the SOURCE association's class on the through model, and
+      # that association (declared there, hence in this same index) roots it itself.
+      #
+      # A computed name equal to the owner's own demodulized name declines too (Rails 7.2+ tries `::Name`
+      # first; the target is then the owner itself or a top-level class).
+      #
+      # ActiveRecord takes the first candidate that is a defined constant. The index knows only models, so the
+      # walk stops (declines) at a candidate that is not a model but is a namespace of one: Rails would pick
+      # that module and fail, never the next candidate. A non-model class at an earlier candidate is invisible
+      # here.
+      #
+      # The roots are flat: an association on a model `rigor unused` itself reports as dead still roots its
+      # target, exactly as the other plugins' roots do.
+      module AssociationRoots
+        COLLECTION_MACROS = %i[has_many has_and_belongs_to_many].freeze
+        ROOTED_MACROS = (COLLECTION_MACROS + %i[belongs_to has_one]).freeze
+        VALID_NAME = /\A(?:::)?[A-Z][A-Za-z0-9_]*(?:::[A-Z][A-Za-z0-9_]*)*\z/
+        private_constant :VALID_NAME
+
+        module_function
+
+        # Sorted, unique model class names. Raises {Rigor::Plugin::Inflector::Unavailable} when a name had to
+        # be inflected and could not be.
+        def call(model_index)
+          namespaces = model_index.class_names.flat_map { |name| prefixes(name) }.to_set
+          roots = model_index.entries.each_value.flat_map do |entry|
+            entry.associations.filter_map { |row| resolve(entry.class_name, row, model_index, namespaces) }
+          end
+          roots.uniq.sort
+        end
+
+        def prefixes(name)
+          segments = name.split("::")
+          (1...segments.length).map { |n| segments.first(n).join("::") }
+        end
+
+        def resolve(owner, row, model_index, namespaces)
+          return nil unless ROOTED_MACROS.include?(row[:macro])
+          return nil if row[:polymorphic] || row[:roots_declined]
+
+          type_name = type_name(row)
+          return nil if type_name.nil? || !VALID_NAME.match?(type_name)
+          # Rails 7.2+ (`MacroReflection#_klass`) tries `::Name` first when the computed name is the owner's
+          # own demodulized name, so the target may be the owner or a top-level class: decline.
+          return nil if type_name == owner.split("::").last
+
+          candidates(owner, type_name).each do |candidate|
+            return candidate if model_index.model?(candidate)
+            return nil if namespaces.include?(candidate)
+          end
+          nil
+        end
+
+        def type_name(row)
+          option = row[:class_name_option]
+          option = row[:source_type_option] if option.nil? && row[:through]
+          return nil if option == :dynamic
+          return option unless option.nil?
+          return nil if row[:through]
+
+          name = row[:name].to_s
+          name = Rigor::Plugin::Inflector.singularize(name) if COLLECTION_MACROS.include?(row[:macro])
+          Rigor::Plugin::Inflector.camelize(name)
+        end
+
+        # `compute_type`: a rooted name is looked up as is; otherwise the owner ITSELF first (`Post has_many
+        # :comments` tries `Post::Comment`), then its enclosing namespaces innermost first, then top level.
+        def candidates(owner, type_name)
+          return [type_name.delete_prefix("::")] if type_name.start_with?("::")
+
+          segments = owner.split("::")
+          nested = segments.length.downto(1).map { |n| "#{segments.first(n).join('::')}::#{type_name}" }
+          nested + [type_name]
+        end
+      end
+    end
+  end
+end