rigortype 0.1.3 → 0.1.5

data/lib/rigor/type_node/resolver_chain.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module Rigor
+  module TypeNode
+    # Walks an ordered list of {Rigor::Plugin::TypeNodeResolver}
+    # instances, returning the first non-nil `resolve(node, scope)`
+    # answer. ADR-13 § "`Plugin::TypeNodeResolver` shape" — first
+    # non-nil wins; registration order is the user's lever for
+    # shadowing per WD3 / WD5.
+    #
+    # The chain is itself a `TypeNodeResolver`-shaped object
+    # (`#resolve(node, scope)`) so it slots into a {NameScope} as
+    # the `resolver:` field without further indirection: a plugin
+    # resolver that wants to recursively resolve a nested argument
+    # calls `scope.resolver.resolve(arg, scope)` and reaches every
+    # resolver in the chain plus the built-in registry through the
+    # same entry point.
+    #
+    # Constructed once per `Analysis::Runner.run` from
+    # `Plugin::Registry#type_node_resolvers`. The chain is
+    # immutable and re-entrant; the parser may consult it many
+    # times for the same node.
+    class ResolverChain
+      def initialize(resolvers)
+        unless resolvers.is_a?(Array) && resolvers.all? { |r| r.respond_to?(:resolve) }
+          raise ArgumentError,
+                "TypeNode::ResolverChain expects an Array of resolvers " \
+                "responding to #resolve(node, scope), got #{resolvers.inspect}"
+        end
+
+        @resolvers = resolvers.dup.freeze
+        freeze
+      end
+
+      # @return [Array<Rigor::Plugin::TypeNodeResolver>] ordered
+      #   resolver instances, in plugin-registration order.
+      attr_reader :resolvers
+
+      # First non-nil `resolve(node, scope)` answer from the chain;
+      # `nil` when every resolver declined.
+      def resolve(node, scope)
+        @resolvers.each do |resolver|
+          result = resolver.resolve(node, scope)
+          return result unless result.nil?
+        end
+        nil
+      end
+
+      # Shared empty chain — a `NameScope` constructed without any
+      # plugin-supplied resolvers can use this to satisfy the
+      # `responds_to?(:resolve)` contract without a per-call
+      # allocation.
+      EMPTY = new([]).freeze
+    end
+  end
+end

data/lib/rigor/type_node/string_literal.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module Rigor
+  module TypeNode
+    # String-literal AST node. Used as a {Generic#args} entry for
+    # parametric forms whose argument is a String literal — namely
+    # `Pick[T, "name"]`, `pick_of[Shape, "a" | "b"]`, and downstream
+    # plugin resolvers that accept literal key selectors.
+    #
+    # ADR-13 follow-up (`docs/CURRENT_WORK.md` engineering item
+    # #2): the RBS::Extended grammar previously could not tokenise
+    # `"name"` inside a type-arg position. The resolver translates
+    # this node to a `Type::Constant` carrying the string value.
+    # Slice 1 supports double-quoted strings without escape
+    # sequences (the most common shape — TS-style key unions
+    # are bare identifier-ish names).
+    class StringLiteral < Data.define(:value)
+      def initialize(value:)
+        unless value.is_a?(String)
+          raise ArgumentError,
+                "TypeNode::StringLiteral value must be a String, " \
+                "got #{value.inspect}"
+        end
+
+        # Freeze the String field so the Data object is
+        # `Ractor.shareable?` regardless of caller frozen-
+        # string-literal state.
+        super(value: value.frozen? ? value : value.dup.freeze)
+      end
+    end
+  end
+end

data/lib/rigor/type_node/symbol_literal.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Rigor
+  module TypeNode
+    # Symbol-literal AST node. Used as a {Generic#args} entry for
+    # parametric forms whose argument is a Symbol literal — namely
+    # `Pick[T, :name]`, `pick_of[Shape, :a | :b]`, and downstream
+    # plugin resolvers that accept literal key selectors.
+    #
+    # ADR-13 follow-up (`docs/CURRENT_WORK.md` engineering item
+    # #2): the RBS::Extended grammar previously could not tokenise
+    # `:name` inside a type-arg position; this addition closes the
+    # gap so `ImportedRefinements.parse` produces a uniform AST.
+    # The resolver translates this node to a `Type::Constant`
+    # carrying the symbol value.
+    class SymbolLiteral < Data.define(:value)
+      def initialize(value:)
+        unless value.is_a?(Symbol)
+          raise ArgumentError,
+                "TypeNode::SymbolLiteral value must be a Symbol, " \
+                "got #{value.inspect}"
+        end
+
+        super
+      end
+    end
+  end
+end

data/lib/rigor/type_node/union.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module Rigor
+  module TypeNode
+    # Union AST node. Carries the nodes of a `T1 | T2 | …` union
+    # expression authored at type-arg position.
+    #
+    # ADR-13 follow-up (`docs/CURRENT_WORK.md` engineering item
+    # #2): together with {SymbolLiteral} / {StringLiteral} this
+    # closes the parser-side gap that prevented `Pick[T, :a | :b]`
+    # / `Pick[T, "a" | "b"]` from tokenising. The resolver pass
+    # recurses through each node and folds them via
+    # `Type::Combinator.union`.
+    #
+    # The field is named `:nodes` (not `:members`) to avoid
+    # shadowing `Data#members`, which is the introspection method
+    # every `Data.define` mix-in inherits.
+    #
+    # Nodes are themselves any of the {TypeNode} carriers — the
+    # parser builds a flat list (left-associative); nested
+    # `Union` nodes are permitted but the parser does not
+    # synthesise them by itself.
+    class Union < Data.define(:nodes)
+      def initialize(nodes:)
+        unless nodes.is_a?(Array) && nodes.size >= 2 && nodes.all? { |m| valid_member?(m) }
+          raise ArgumentError,
+                "TypeNode::Union nodes must be an Array (size >= 2) of " \
+                "TypeNode carriers, got #{nodes.inspect}"
+        end
+
+        super(nodes: nodes.freeze)
+      end
+
+      private
+
+      def valid_member?(node)
+        node.is_a?(Identifier) || node.is_a?(Generic) || node.is_a?(IntegerLiteral) ||
+          node.is_a?(IndexedAccess) || node.is_a?(SymbolLiteral) || node.is_a?(StringLiteral)
+      end
+    end
+  end
+end

data/lib/rigor/type_node.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Rigor
+  # Mini-AST passed to plugin-supplied `TypeNode` resolvers (see
+  # [ADR-13](../../docs/adr/13-typenode-resolver-plugin.md)). The
+  # two leaf carriers — {Identifier} and {Generic} — describe a
+  # node in an `%a{rigor:v1:...}` payload at the point the
+  # built-in registry / `ImportedRefinements::Parser` failed to
+  # resolve it and the analyzer hands the node off to plugins.
+  #
+  # Slice 1 of the ADR-13 envelope ships these two value objects
+  # only. The `NameScope` companion + plugin manifest hook arrive
+  # in slice 2; the parser integration arrives in slice 3. Until
+  # those land, the carriers are reachable only through direct
+  # instantiation in tests — they are the stable data shape every
+  # later slice consumes.
+  module TypeNode
+  end
+end
+
+require_relative "type_node/identifier"
+require_relative "type_node/integer_literal"
+require_relative "type_node/symbol_literal"
+require_relative "type_node/string_literal"
+require_relative "type_node/generic"
+require_relative "type_node/indexed_access"
+require_relative "type_node/union"
+require_relative "type_node/name_scope"
+require_relative "type_node/resolver_chain"

data/lib/rigor/version.rb

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

data/lib/rigor.rb

@@ -29,6 +29,7 @@ require_relative "rigor/cache/rbs_class_ancestor_table"
 require_relative "rigor/cache/rbs_class_type_param_names"
 require_relative "rigor/cache/rbs_environment"
 require_relative "rigor/cache/rbs_instance_definitions"
+require_relative "rigor/type_node"
 require_relative "rigor/flow_contribution"
 require_relative "rigor/flow_contribution/fact"
 require_relative "rigor/flow_contribution/conflict"
@@ -43,4 +44,5 @@ require_relative "rigor/analysis/diagnostic"
 require_relative "rigor/analysis/result"
 require_relative "rigor/analysis/check_rules"
 require_relative "rigor/analysis/runner"
+require_relative "rigor/sig_gen"
 require_relative "rigor/cli"

data/sig/rigor/analysis/check_rules/always_truthy_condition_collector.rbs

@@ -0,0 +1,10 @@
+module Rigor
+  module Analysis
+    module CheckRules
+      class AlwaysTruthyConditionCollector
+        def initialize: (untyped) -> void
+        def collect: (untyped) -> Array[untyped]
+      end
+    end
+  end
+end

data/sig/rigor/analysis/check_rules/dead_assignment_collector.rbs

@@ -0,0 +1,10 @@
+module Rigor
+  module Analysis
+    module CheckRules
+      class DeadAssignmentCollector
+        def initialize: (untyped) -> void
+        def collect: (untyped) -> Array[untyped]
+      end
+    end
+  end
+end

data/sig/rigor/analysis/dependency_source_inference/gem_resolver.rbs

@@ -0,0 +1,25 @@
+module Rigor
+  module Analysis
+    module DependencySourceInference
+      module GemResolver
+        class Resolved
+          def descriptor_key: () -> Array[untyped]
+        end
+
+        class Unresolvable
+        end
+      end
+    end
+  end
+end
+
+module Rigor
+  module Analysis
+    module DependencySourceInference
+      module GemResolver
+        def self?.resolve: (untyped) -> (Rigor::Analysis::DependencySourceInference::GemResolver::Resolved | Rigor::Analysis::DependencySourceInference::GemResolver::Unresolvable)
+        def self?.locate_gem_spec: (untyped) -> (Gem::BasicSpecification | Gem::Specification | nil)
+      end
+    end
+  end
+end

data/sig/rigor/analysis/dependency_source_inference/index.rbs

@@ -0,0 +1,9 @@
+module Rigor
+  module Analysis
+    module DependencySourceInference
+      class Index
+        def initialize: (?resolved_gems: untyped, ?unresolvable: untyped, ?method_catalog: untyped, ?budget_exceeded: untyped, ?class_to_gem: untyped, ?budget_overrun_strategy: untyped) -> void
+      end
+    end
+  end
+end

data/sig/rigor/cli/diff_command.rbs

@@ -0,0 +1,4 @@
+class Rigor::CLI::DiffCommand
+  def initialize: (argv: untyped, out: untyped, err: untyped) -> void
+  def run: () -> (0 | 1 | Integer)
+end

data/sig/rigor/cli/explain_command.rbs

@@ -0,0 +1,4 @@
+class Rigor::CLI::ExplainCommand
+  def initialize: (argv: untyped, out: untyped, err: untyped) -> void
+  def run: () -> (0 | Integer)
+end

data/sig/rigor/cli/sig_gen_command.rbs

@@ -0,0 +1,4 @@
+class Rigor::CLI::SigGenCommand
+  def initialize: (argv: untyped, out: untyped, err: untyped) -> void
+  def run: () -> (0 | Integer)
+end

data/sig/rigor/cli/type_scan_command.rbs

@@ -0,0 +1,3 @@
+class Rigor::CLI::TypeScanCommand::ScanAccumulator
+  def record_parse_error: (untyped, untyped) -> Array[untyped]
+end

data/sig/rigor/environment.rbs

@@ -8,16 +8,21 @@ module Rigor
     attr_reader rbs_loader: RbsLoader?
     attr_reader plugin_registry: untyped?
     attr_reader dependency_source_index: untyped?
+    attr_reader rbs_extended_reporter: untyped?
+    attr_reader boundary_cross_reporter: untyped?
+    attr_reader name_scope: untyped?
+    attr_reader synthetic_method_index: untyped?
 
     def self.default: () -> Environment
-    def self.for_project: (?root: String, ?libraries: Array[String], ?signature_paths: Array[String | _ToPath]?, ?cache_store: untyped?, ?plugin_registry: untyped?, ?dependency_source_index: untyped?) -> Environment
+    def self.for_project: (?root: String, ?libraries: Array[String], ?signature_paths: Array[String | _ToPath]?, ?cache_store: untyped?, ?plugin_registry: untyped?, ?dependency_source_index: untyped?, ?rbs_extended_reporter: untyped?, ?boundary_cross_reporter: untyped?, ?bundler_bundle_path: String?, ?bundler_auto_detect: bool, ?synthetic_method_index: untyped?) -> Environment
 
-    def initialize: (?class_registry: ClassRegistry, ?rbs_loader: RbsLoader?, ?plugin_registry: untyped?, ?dependency_source_index: untyped?) -> void
+    def initialize: (?class_registry: ClassRegistry, ?rbs_loader: RbsLoader?, ?plugin_registry: untyped?, ?dependency_source_index: untyped?, ?rbs_extended_reporter: untyped?, ?boundary_cross_reporter: untyped?, ?synthetic_method_index: untyped?) -> void
     def nominal_for_name: (String | Symbol name) -> Type::Nominal?
     def singleton_for_name: (String | Symbol name) -> Type::Singleton?
     def constant_for_name: (String | Symbol name) -> Type::t?
     def class_known?: (String | Symbol name) -> bool
     def class_ordering: (String | Symbol lhs, String | Symbol rhs) -> ordering
+    def reflection: () -> untyped?
 
     class ClassRegistry
       def self.default: () -> ClassRegistry
@@ -39,6 +44,7 @@ module Rigor
       def self.default: () -> RbsLoader
       def self.reset_default!: () -> void
       def self.build_env_for: (libraries: Array[String], signature_paths: Array[String | _ToPath]) -> untyped
+      def self.vendored_gem_sig_paths: () -> Array[Pathname]
 
       def initialize: (?libraries: Array[String], ?signature_paths: Array[String | _ToPath], ?cache_store: untyped?) -> void
       def class_known?: (String | Symbol name) -> bool

data/sig/rigor/inference/builtins/method_catalog.rbs

@@ -0,0 +1,4 @@
+class Rigor::Inference::Builtins::MethodCatalog
+  def initialize: (path: String, ?mutating_selectors: Hash[String, Set[untyped]]) -> void
+  def reset!: () -> nil
+end

data/sig/rigor/inference/builtins/numeric_catalog.rbs

@@ -0,0 +1,3 @@
+class Rigor::Inference::Builtins::NumericCatalog
+  def self.reset!: () -> nil
+end

data/sig/rigor/inference/builtins.rbs

@@ -0,0 +1,2 @@
+module Rigor::Inference::Builtins
+end

data/sig/rigor/plugin/access_denied_error.rbs

@@ -0,0 +1,3 @@
+class Rigor::Plugin::AccessDeniedError
+  def initialize: (untyped, reason: untyped, ?resource: untyped) -> void
+end

data/sig/rigor/plugin/base.rbs

@@ -0,0 +1,6 @@
+class Rigor::Plugin::Base
+  def self.manifest: () -> Rigor::Plugin::Manifest
+  def initialize: (services: untyped, ?config: untyped) -> void
+  def init: (untyped) -> nil
+  def prepare: (untyped) -> nil
+end

data/sig/rigor/plugin/blueprint.rbs

@@ -0,0 +1,7 @@
+class Rigor::Plugin::Blueprint
+  attr_reader klass_name: String
+  attr_reader config: Hash[untyped, untyped]
+
+  def initialize: (klass_name: String | Module, ?config: Hash[untyped, untyped]) -> void
+  def materialize: (services: untyped) -> Rigor::Plugin::Base
+end

data/sig/rigor/plugin/fact_store.rbs

@@ -0,0 +1,11 @@
+class Rigor::Plugin::FactStore
+  def initialize: () -> void
+  def publish: (plugin_id: untyped, name: untyped, value: untyped) -> nil
+  def read: (plugin_id: untyped, name: untyped) -> untyped
+  def published?: (plugin_id: untyped, name: untyped) -> bool
+  def each_fact: () { (untyped) -> void } -> void
+end
+
+class Rigor::Plugin::FactStore::Conflict
+  def initialize: (plugin_id: untyped, name: untyped, existing: untyped, incoming: untyped) -> void
+end

data/sig/rigor/plugin/io_boundary.rbs

@@ -0,0 +1,4 @@
+class Rigor::Plugin::IoBoundary
+  def initialize: (policy: untyped, plugin_id: untyped, ?http_client: untyped) -> void
+  def read_file: (untyped) -> String
+end

data/sig/rigor/plugin/load_error.rbs

@@ -0,0 +1,6 @@
+class Rigor::Plugin::LoadError < StandardError
+  attr_reader plugin_ref: untyped
+  attr_reader cause: untyped
+  attr_reader reason: Symbol
+  def initialize: (untyped, plugin_ref: untyped, ?cause: untyped, ?reason: untyped) -> void
+end

data/sig/rigor/plugin/loader.rbs

@@ -0,0 +1,20 @@
+module Rigor
+  module Plugin
+    # Resolves the project's `.rigor.yml` `plugins:` entries into
+    # instantiated plugin instances. The other Plugin namespaces
+    # (`Services`, `Registry`, `Base`, etc.) are not yet
+    # sig-covered, so reference them as `untyped` for now. The
+    # critical declaration here is `self.load`: without it, Steep
+    # matches against `Kernel#load`'s `(::String, ?(::Module | bool)) -> bool`
+    # signature and reports `MethodParameterMismatch` for the
+    # keyword-only shape.
+    class Loader
+      attr_reader services: untyped
+      attr_reader requirer: ^(String) -> untyped
+
+      def self.load: (configuration: Configuration, services: untyped, ?requirer: ^(String) -> untyped) -> untyped
+      def initialize: (services: untyped, ?requirer: ^(String) -> untyped) -> void
+      def load: (Array[String | Hash[untyped, untyped]] entries) -> untyped
+    end
+  end
+end

data/sig/rigor/plugin/manifest.rbs

@@ -0,0 +1,9 @@
+class Rigor::Plugin::Manifest::Consumption
+  def initialize: (plugin_id: untyped, name: untyped, ?optional: untyped) -> void
+end
+
+class Rigor::Plugin::Manifest
+  def initialize: (id: untyped, version: untyped, ?description: untyped, ?protocols: untyped, ?config_schema: untyped, ?produces: untyped, ?consumes: untyped, ?owns_receivers: untyped, ?type_node_resolvers: untyped, ?block_as_methods: untyped, ?heredoc_templates: untyped, ?trait_registries: untyped, ?external_files: untyped) -> void
+  def validate_config: (untyped) -> Array[String]
+  def to_h: () -> Hash[String, untyped]
+end

data/sig/rigor/plugin/registry.rbs

@@ -0,0 +1,16 @@
+class Rigor::Plugin::Registry
+  attr_reader plugins: untyped
+  attr_reader load_errors: untyped
+  attr_reader blueprints: untyped
+
+  EMPTY: Rigor::Plugin::Registry
+
+  def self.materialize: (blueprints: untyped, services: untyped) -> Rigor::Plugin::Registry
+
+  def initialize: (?plugins: untyped, ?load_errors: untyped, ?blueprints: untyped) -> void
+  def find: (String | Symbol id) -> untyped
+  def ids: () -> Array[String]
+  def empty?: () -> bool
+  def any_load_errors?: () -> bool
+  def type_node_resolvers: () -> Array[untyped]
+end

data/sig/rigor/plugin/services.rbs

@@ -0,0 +1,3 @@
+class Rigor::Plugin::Services
+  def initialize: (reflection: untyped, type: untyped, configuration: untyped, ?cache_store: untyped, ?trust_policy: untyped, ?fact_store: untyped) -> void
+end

data/sig/rigor/plugin/trust_policy.rbs

@@ -0,0 +1,4 @@
+class Rigor::Plugin::TrustPolicy
+  def initialize: (?trusted_gems: untyped, ?allowed_read_roots: untyped, ?network_policy: untyped, ?allowed_url_hosts: untyped) -> void
+  def to_h: () -> Hash[String, untyped]
+end

data/sig/rigor/plugin/type_node_resolver.rbs

@@ -0,0 +1,3 @@
+class Rigor::Plugin::TypeNodeResolver
+  def resolve: (untyped, untyped) -> nil
+end

data/sig/rigor/plugin.rbs

@@ -0,0 +1,8 @@
+module Rigor
+  module Plugin
+    def self.register: (Class plugin_class) -> Class
+    def self.registered_for: (String | Symbol id) -> Class?
+    def self.registered: () -> Hash[String, Class]
+    def self.unregister!: (?(String | Symbol)? id) -> untyped
+  end
+end

data/sig/rigor/scope.rbs

@@ -16,10 +16,12 @@ module Rigor
     attr_reader discovered_methods: Hash[String, Hash[Symbol, Symbol]]
     attr_reader discovered_def_nodes: Hash[String, Hash[Symbol, untyped]]
     attr_reader discovered_method_visibilities: Hash[String, Hash[Symbol, Symbol]]
+    attr_reader source_path: String?
 
-    def self.empty: (?environment: Environment) -> Scope
+    def self.empty: (?environment: Environment, ?source_path: String?) -> Scope
 
-    def initialize: (environment: Environment, locals: Hash[Symbol, Type::t], ?fact_store: Analysis::FactStore, ?self_type: Type::t?, ?declared_types: Hash[untyped, Type::t], ?ivars: Hash[Symbol, Type::t], ?cvars: Hash[Symbol, Type::t], ?globals: Hash[Symbol, Type::t]) -> void
+    def initialize: (environment: Environment, locals: Hash[Symbol, Type::t], ?fact_store: Analysis::FactStore, ?self_type: Type::t?, ?declared_types: Hash[untyped, Type::t], ?ivars: Hash[Symbol, Type::t], ?cvars: Hash[Symbol, Type::t], ?globals: Hash[Symbol, Type::t], ?source_path: String?) -> void
+    def with_source_path: (String? path) -> Scope
     def local: (String | Symbol name) -> Type::t?
     def ivar: (String | Symbol name) -> Type::t?
     def cvar: (String | Symbol name) -> Type::t?

data/sig/rigor/type.rbs

@@ -7,34 +7,34 @@ module Rigor
     class Top
       def self.instance: () -> Top
       def describe: (?Symbol verbosity) -> String
-      def erase_to_rbs: () -> String
+      def erase_to_rbs: () -> "top"
       def top: () -> Trinary
       def bot: () -> Trinary
       def dynamic: () -> Trinary
       def accepts: (Type::t other, ?mode: accepts_mode) -> AcceptsResult
       def ==: (untyped other) -> bool
       def hash: () -> Integer
-      def inspect: () -> String
+      def inspect: () -> "#<Rigor::Type::Top>"
     end
 
     class Bot
       def self.instance: () -> Bot
       def describe: (?Symbol verbosity) -> String
-      def erase_to_rbs: () -> String
+      def erase_to_rbs: () -> "bot"
       def top: () -> Trinary
       def bot: () -> Trinary
       def dynamic: () -> Trinary
       def accepts: (Type::t other, ?mode: accepts_mode) -> AcceptsResult
       def ==: (untyped other) -> bool
       def hash: () -> Integer
-      def inspect: () -> String
+      def inspect: () -> "#<Rigor::Type::Bot>"
     end
 
     class Dynamic
       attr_reader static_facet: Type::t
       def initialize: (Type::t static_facet) -> void
       def describe: (?Symbol verbosity) -> String
-      def erase_to_rbs: () -> String
+      def erase_to_rbs: () -> "untyped"
       def top: () -> Trinary
       def bot: () -> Trinary
       def dynamic: () -> Trinary
@@ -72,7 +72,7 @@ module Rigor
       def upper: () -> (Integer | Float)
       def describe: (?Symbol verbosity) -> String
       def generic_description: () -> String
-      def erase_to_rbs: () -> String
+      def erase_to_rbs: () -> "Integer"
       def top: () -> Trinary
       def bot: () -> Trinary
       def dynamic: () -> Trinary
@@ -156,6 +156,21 @@ module Rigor
       def inspect: () -> String
     end
 
+    class BoundMethod
+      attr_reader receiver_type: Type::t
+      attr_reader method_name: Symbol
+      def initialize: (receiver_type: Type::t, method_name: Symbol) -> void
+      def describe: (?Symbol verbosity) -> String
+      def erase_to_rbs: () -> String
+      def top: () -> Trinary
+      def bot: () -> Trinary
+      def dynamic: () -> Trinary
+      def accepts: (Type::t other, ?mode: accepts_mode) -> AcceptsResult
+      def ==: (untyped other) -> bool
+      def hash: () -> Integer
+      def inspect: () -> String
+    end
+
     class Intersection
       attr_reader members: Array[Type::t]
       def initialize: (Array[Type::t] members) -> void
@@ -232,6 +247,7 @@ module Rigor
       def self?.nominal_of: (Module | String class_name_or_object, ?type_args: Array[Type::t]) -> Nominal
       def self?.singleton_of: (Module | String class_name_or_object) -> Singleton
       def self?.constant_of: (untyped value) -> Constant
+      def self?.bound_method_of: (Type::t receiver_type, Symbol method_name) -> BoundMethod
       def self?.difference: (Type::t base, Type::t removed) -> Difference
       def self?.non_empty_string: () -> Difference
       def self?.non_zero_int: () -> Difference
@@ -268,6 +284,12 @@ module Rigor
       def self?.int_mask: (Array[Integer] flags) -> Type::t?
       def self?.int_mask_of: (Type::t type) -> Type::t?
       def self?.indexed_access: (Type::t type, Type::t key) -> Type::t
+      def self?.pick_of: (Type::t type, Type::t keys) -> Type::t
+      def self?.omit_of: (Type::t type, Type::t keys) -> Type::t
+      def self?.partial_of: (Type::t type) -> Type::t
+      def self?.required_of: (Type::t type) -> Type::t
+      def self?.readonly_of: (Type::t type) -> Type::t
+      def self?.shape_projection_lossy?: (Type::t type) -> bool
     end
   end
 end

data/sig/rigor.rbs

@@ -54,13 +54,46 @@ module Rigor
 
     class Result
       attr_reader diagnostics: Array[Diagnostic]
+      attr_reader stats: RunStats?
 
-      def initialize: (?diagnostics: Array[Diagnostic]) -> void
+      def initialize: (?diagnostics: Array[Diagnostic], ?stats: RunStats?) -> void
       def success?: () -> bool
       def error_count: () -> Integer
       def to_h: () -> Hash[String, untyped]
     end
 
+    class RunStats
+      attr_reader wall_seconds: Float
+      attr_reader peak_rss_bytes: Integer?
+      attr_reader target_files: Integer
+      attr_reader rbs_classes_total: Integer
+      attr_reader rbs_classes_project_sig: Integer
+      attr_reader rbs_classes_bundled: Integer
+      attr_reader gem_walk_classes: Integer
+      attr_reader gem_walk_gems: Integer
+      attr_reader rbs_attribution_available: bool
+
+      CACHED_SENTINEL: String
+
+      def self.peak_rss_bytes: () -> Integer?
+      def self.partition_classes: (class_decl_paths: Hash[String, String], signature_paths: Array[untyped]) -> [Integer, Integer]
+      def self.attribution_available?: (class_decl_paths: Hash[String, String]) -> bool
+
+      def initialize: (
+        wall_seconds: Float,
+        peak_rss_bytes: Integer?,
+        target_files: Integer,
+        rbs_classes_total: Integer,
+        rbs_classes_project_sig: Integer,
+        rbs_classes_bundled: Integer,
+        gem_walk_classes: Integer,
+        gem_walk_gems: Integer,
+        ?rbs_attribution_available: bool
+      ) -> void
+      def format: (untyped out, ?prefix: String) -> void
+      def to_h: () -> Hash[Symbol, untyped]
+    end
+
     class Runner
       RUBY_GLOB: String
       DEFAULT_CACHE_ROOT: String
@@ -71,7 +104,7 @@ module Rigor
       # otherwise raises `RBS::UnknownTypeName` for the named type.
       attr_reader cache_store: untyped
       attr_reader plugin_registry: untyped
-      def initialize: (configuration: Configuration, ?explain: bool, ?cache_store: untyped, ?plugin_requirer: untyped) -> void
+      def initialize: (configuration: Configuration, ?explain: bool, ?cache_store: untyped, ?plugin_requirer: untyped, ?workers: Integer, ?collect_stats: bool) -> void
       def run: (?Array[String] paths) -> Result
     end
   end