rigortype 0.0.1

data/sig/rigor/analysis/fact_store.rbs

@@ -0,0 +1,51 @@
+module Rigor
+  module Analysis
+    module CheckRules
+      def self?.diagnose: (path: String, root: untyped, scope_index: Hash[untyped, Scope]) -> Array[Diagnostic]
+    end
+
+    class FactStore
+      type bucket = :local_binding | :captured_local | :object_content | :global_storage | :dynamic_origin | :relational
+      type polarity = :positive | :negative
+      type stability = :local_binding | :unstable | :pure | :immutable
+
+      BUCKETS: Array[bucket]
+
+      class Target
+        attr_reader kind: Symbol
+        attr_reader name: untyped
+        def self.local: (String | Symbol name) -> Target
+        def self.new: (kind: Symbol, name: untyped) -> Target
+        def initialize: (kind: Symbol, name: untyped) -> void
+      end
+
+      class Fact
+        attr_reader bucket: bucket
+        attr_reader target: Target | Array[Target]
+        attr_reader predicate: Symbol
+        attr_reader payload: untyped
+        attr_reader polarity: polarity
+        attr_reader stability: stability
+        def self.new: (bucket: bucket, target: Target | Array[Target], predicate: Symbol, ?payload: untyped, ?polarity: polarity, ?stability: stability) -> Fact
+        def initialize: (bucket: bucket, target: Target | Array[Target], predicate: Symbol, ?payload: untyped, ?polarity: polarity, ?stability: stability) -> void
+      end
+
+      attr_reader facts: Array[Fact]
+
+      def self.empty: () -> FactStore
+
+      def initialize: (?facts: Array[Fact]) -> void
+      def empty?: () -> bool
+      def with_fact: (Fact fact) -> FactStore
+      def with_local_fact: (String | Symbol name, predicate: Symbol, ?payload: untyped, ?bucket: bucket, ?polarity: polarity) -> FactStore
+      def facts_for: (?target: Target?, ?bucket: bucket?) -> Array[Fact]
+      def invalidate_target: (Target target, ?buckets: Array[bucket]?) -> FactStore
+      def join: (FactStore other) -> FactStore
+      def ==: (untyped other) -> bool
+      def eql?: (untyped other) -> bool
+      def hash: () -> Integer
+      def normalize: (Array[Fact] raw_facts) -> Array[Fact]
+      def fact_targets: (Fact fact) -> Array[Target]
+    end
+  end
+end

data/sig/rigor/ast.rbs

@@ -0,0 +1,11 @@
+module Rigor
+  module AST
+    class TypeNode
+      attr_reader type: Type::t
+      def initialize: (Type::t type) -> void
+      def ==: (untyped other) -> bool
+      def hash: () -> Integer
+      def inspect: () -> String
+    end
+  end
+end

data/sig/rigor/environment.rbs

@@ -0,0 +1,59 @@
+module Rigor
+  class Environment
+    type ordering = :equal | :subclass | :superclass | :disjoint | :unknown
+
+    DEFAULT_LIBRARIES: Array[String]
+
+    attr_reader class_registry: ClassRegistry
+    attr_reader rbs_loader: RbsLoader?
+
+    def self.default: () -> Environment
+    def self.for_project: (?root: String, ?libraries: Array[String], ?signature_paths: Array[String | _ToPath]?) -> Environment
+
+    def initialize: (?class_registry: ClassRegistry, ?rbs_loader: RbsLoader?) -> 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
+
+    class ClassRegistry
+      def self.default: () -> ClassRegistry
+      def self.build_default: () -> ClassRegistry
+      def initialize: () -> void
+      def register: (Module class_object) -> void
+      def registered?: (Module class_object) -> bool
+      def nominal_for: (Module class_object) -> Type::Nominal
+      def nominal_for_name: (String | Symbol name) -> Type::Nominal?
+      def class_ordering: (String | Symbol lhs, String | Symbol rhs) -> ordering
+      def normalize_name: (Module | String | Symbol name) -> String
+    end
+
+    class RbsLoader
+      attr_reader libraries: Array[String]
+      attr_reader signature_paths: Array[String | _ToPath]
+
+      def self.default: () -> RbsLoader
+      def self.reset_default!: () -> void
+
+      def initialize: (?libraries: Array[String], ?signature_paths: Array[String | _ToPath]) -> void
+      def class_known?: (String | Symbol name) -> bool
+      def instance_definition: (String | Symbol class_name) -> untyped
+      def instance_method: (class_name: String | Symbol, method_name: String | Symbol) -> untyped
+      def singleton_definition: (String | Symbol class_name) -> untyped
+      def singleton_method: (class_name: String | Symbol, method_name: String | Symbol) -> untyped
+      def class_type_param_names: (String | Symbol class_name) -> Array[Symbol]
+      def class_ordering: (String | Symbol lhs, String | Symbol rhs) -> ordering
+      def constant_type: (String name) -> Type::t?
+      def instance_definition: (String | Symbol class_name) -> untyped?
+      def singleton_definition: (String | Symbol class_name) -> untyped?
+    end
+
+    class RbsHierarchy
+      def initialize: (RbsLoader loader) -> void
+      def class_ordering: (String | Symbol lhs, String | Symbol rhs) -> ordering
+      def loader: () -> RbsLoader
+      def normalize_name: (String | Symbol name) -> String
+    end
+  end
+end

data/sig/rigor/inference.rbs

@@ -0,0 +1,151 @@
+module Rigor
+  module Inference
+    type closure_classification = :non_escaping | :escaping | :unknown
+
+    class ExpressionTyper
+      def initialize: (scope: Scope, ?tracer: FallbackTracer?) -> void
+      def type_of: (untyped node) -> Type::t
+      def scope: () -> Scope
+      def tracer: () -> FallbackTracer?
+      def dynamic_top: () -> Type::Dynamic
+      def statements_or_nil: (untyped statements_node) -> Type::t
+      def fallback_for: (untyped node, family: Symbol) -> Type::t
+      def record_fallback: (untyped node, family: Symbol, inner_type: Type::t) -> void
+      def type_of_virtual: (untyped node) -> Type::t
+      def call_receiver_type_for: (untyped node) -> Type::t?
+      def call_arg_types: (untyped node) -> Array[Type::t]
+      def block_return_type_for: (untyped call_node, Type::t? receiver_type, Array[Type::t] arg_types) -> Type::t?
+    end
+
+    class StatementEvaluator
+      class ClassFrame
+        attr_reader name: String
+        attr_reader singleton: bool
+        def self.new: (name: String, singleton: bool) -> ClassFrame
+        def initialize: (name: String, singleton: bool) -> void
+      end
+
+      def initialize: (scope: Scope, ?tracer: FallbackTracer?, ?on_enter: (^(untyped, Scope) -> void)?, ?class_context: Array[ClassFrame]) -> void
+      def evaluate: (untyped node) -> [Type::t, Scope]
+      def scope: () -> Scope
+      def tracer: () -> FallbackTracer?
+      def sub_eval: (untyped node, Scope with_scope, ?class_context: Array[ClassFrame]) -> [Type::t, Scope]
+      def eval_branch_or_nil: (untyped? branch_node, Scope branch_scope) -> [Type::t, Scope]
+      def join_with_nil_injection: (Scope scope_a, Scope scope_b) -> Scope
+      def reduce_scopes_with_nil_injection: (Array[Scope] scopes) -> Scope
+      def call_arg_types_for: (untyped call_node) -> Array[Type::t]
+      def expected_block_param_types_for: (untyped call_node) -> Array[Type::t]
+      def build_block_entry_scope: (untyped call_node, untyped block_node) -> Scope
+      def build_method_entry_scope: (untyped def_node) -> Scope
+      def current_class_path: () -> String?
+      def current_frame_singleton?: () -> bool
+      def singleton_def?: (untyped def_node) -> bool
+      def self_type_for_class_body: (Array[ClassFrame] class_context) -> Type::t?
+      def self_type_for_method_body: (singleton: bool) -> Type::t?
+      def qualified_name_for: (untyped constant_path_node) -> String?
+      def render_constant_path: (untyped node) -> String
+      def singleton_context_for: (untyped node) -> Array[ClassFrame]
+      def captured_local_writes: (untyped block_node, Scope base_scope) -> Array[Symbol]
+      def block_introduced_locals: (untyped block_node) -> Set[Symbol]
+      def drop_captured_narrowing: (untyped block_node, Scope base_scope) -> Scope
+      def classify_closure_escape: (untyped call_node) -> closure_classification
+      def record_closure_escape_if_any: (untyped node) -> Scope
+      def evaluate_block_if_present: (untyped node) -> void
+      def eval_class_body: (untyped node, Array[ClassFrame] new_context) -> [Type::t, Scope]
+    end
+
+    module MethodDispatcher
+      def self?.dispatch: (receiver_type: Type::t?, method_name: Symbol, arg_types: Array[Type::t], ?block_type: Type::t?, ?environment: Environment?) -> Type::t?
+      def self?.expected_block_param_types: (receiver_type: Type::t?, method_name: Symbol, arg_types: Array[Type::t], ?environment: Environment?) -> Array[Type::t]
+    end
+
+    class MethodParameterBinder
+      def initialize: (environment: Environment, class_path: String, singleton: bool) -> void
+      def bind: (untyped def_node) -> Hash[Symbol, Type::t]
+    end
+
+    class BlockParameterBinder
+      def initialize: (?expected_param_types: Array[Type::t]) -> void
+      def bind: (untyped block_node) -> Hash[Symbol, Type::t]
+      def positional_type_at: (Integer index) -> Type::t
+      def bind_numbered_parameters: (untyped numbered_node) -> Hash[Symbol, Type::t]
+      def bind_block_parameters: (untyped params_root) -> Hash[Symbol, Type::t]
+    end
+
+    module MultiTargetBinder
+      def self?.bind: (untyped target_node, Type::t rhs_type) -> Hash[Symbol, Type::t]
+    end
+
+    module Narrowing
+      def self?.narrow_truthy: (Type::t type) -> Type::t
+      def self?.narrow_falsey: (Type::t type) -> Type::t
+      def self?.narrow_nil: (Type::t type) -> Type::t
+      def self?.narrow_non_nil: (Type::t type) -> Type::t
+      def self?.narrow_equal: (Type::t type, untyped literal) -> Type::t
+      def self?.narrow_not_equal: (Type::t type, untyped literal) -> Type::t
+      def self?.narrow_class: (Type::t type, String class_name, ?exact: bool, ?environment: Environment) -> Type::t
+      def self?.narrow_not_class: (Type::t type, String class_name, ?exact: bool, ?environment: Environment) -> Type::t
+      def self?.predicate_scopes: (untyped node, Scope scope) -> [Scope, Scope]
+      def self?.case_when_scopes: (untyped subject, Array[untyped] conditions, Scope scope) -> [Scope, Scope]
+      def self?.analyse: (untyped node, Scope scope) -> untyped
+      def self?.subclass_of?: (String rigor_class_name, String target_class_name, untyped context) -> bool
+      def self?.class_ordering: (String lhs, String rhs, untyped context) -> Symbol
+      def self?.trusted_equality_literal?: (untyped literal) -> bool
+      def self?.falsey_value?: (untyped value) -> bool
+      def self?.falsey_nominal?: (Type::Nominal nominal) -> bool
+    end
+
+    module ClosureEscapeAnalyzer
+      def self?.classify: (receiver_type: Type::t?, method_name: Symbol, ?environment: Environment?) -> closure_classification
+    end
+
+    module Acceptance
+      def self?.accepts: (Type::t self_type, Type::t other_type, ?mode: Type::accepts_mode) -> Type::AcceptsResult
+    end
+
+    module RbsTypeTranslator
+      def self.translate: (untyped rbs_type, ?self_type: Type::t?, ?instance_type: Type::t?, ?type_vars: Hash[Symbol, Type::t]) -> Type::t
+    end
+
+    class Fallback
+      attr_reader node_class: Class
+      attr_reader location: untyped
+      attr_reader family: Symbol
+      attr_reader inner_type: Type::t
+      def initialize: (node_class: Class, location: untyped, family: Symbol, inner_type: Type::t) -> void
+    end
+
+    class FallbackTracer
+      def initialize: () -> void
+      def events: () -> Array[Fallback]
+      def record_fallback: (Fallback event) -> void
+      def empty?: () -> bool
+      def size: () -> Integer
+      def each: () { (Fallback) -> void } -> self
+                | () -> Enumerator[Fallback, self]
+      def kinds: () -> Array[Class]
+      def families: () -> Array[Symbol]
+      def clear: () -> void
+    end
+
+    module ScopeIndexer
+      def self?.index: (untyped root, default_scope: Scope) -> Hash[untyped, Scope]
+      def self?.build_declaration_overrides: (untyped root) -> Hash[untyped, Type::t]
+      def self?.record_declarations: (untyped node, Array[String] qualified_prefix, Hash[untyped, Type::t] table) -> void
+      def self?.qualified_name_for: (untyped constant_path_node) -> String?
+      def self?.render_constant_path: (untyped node) -> String
+      def self?.propagate: (untyped node, Hash[untyped, Scope] table, Scope parent_scope) -> void
+    end
+
+    class CoverageScanner
+      class Stats
+        def visited_count: () -> Integer
+        def unrecognized_count: () -> Integer
+        def unrecognized_ratio: () -> Float
+      end
+
+      def initialize: (?scope: Scope?) -> void
+      def scan: (untyped root) -> Stats
+    end
+  end
+end

data/sig/rigor/rbs_extended.rbs

@@ -0,0 +1,22 @@
+module Rigor
+  module RbsExtended
+    DIRECTIVE_PREFIX: String
+
+    type predicate_edge = :truthy_only | :falsey_only
+    type target_kind = :parameter | :self
+
+    class PredicateEffect
+      attr_reader edge: predicate_edge
+      attr_reader target_kind: target_kind
+      attr_reader target_name: Symbol
+      attr_reader class_name: String
+
+      def self.new: (edge: predicate_edge, target_kind: target_kind, target_name: Symbol, class_name: String) -> PredicateEffect
+      def truthy_only?: () -> bool
+      def falsey_only?: () -> bool
+    end
+
+    def self?.read_predicate_effects: (untyped method_def) -> Array[PredicateEffect]
+    def self?.parse_predicate_annotation: (String string) -> PredicateEffect?
+  end
+end

data/sig/rigor/scope.rbs

@@ -0,0 +1,49 @@
+module Rigor
+  class Scope
+    attr_reader environment: Environment
+    attr_reader locals: Hash[Symbol, Type::t]
+    attr_reader fact_store: Analysis::FactStore
+    attr_reader self_type: Type::t?
+    attr_reader declared_types: Hash[untyped, Type::t]
+    attr_reader ivars: Hash[Symbol, Type::t]
+    attr_reader cvars: Hash[Symbol, Type::t]
+    attr_reader globals: Hash[Symbol, Type::t]
+    attr_reader class_ivars: Hash[String, Hash[Symbol, Type::t]]
+    attr_reader class_cvars: Hash[String, Hash[Symbol, Type::t]]
+    attr_reader program_globals: Hash[Symbol, Type::t]
+    attr_reader discovered_classes: Hash[String, Type::Singleton]
+    attr_reader in_source_constants: Hash[String, Type::t]
+    attr_reader discovered_methods: Hash[String, Hash[Symbol, Symbol]]
+
+    def self.empty: (?environment: Environment) -> 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 local: (String | Symbol name) -> Type::t?
+    def ivar: (String | Symbol name) -> Type::t?
+    def cvar: (String | Symbol name) -> Type::t?
+    def global: (String | Symbol name) -> Type::t?
+    def with_local: (String | Symbol name, Type::t type) -> Scope
+    def with_ivar: (String | Symbol name, Type::t type) -> Scope
+    def with_cvar: (String | Symbol name, Type::t type) -> Scope
+    def with_global: (String | Symbol name, Type::t type) -> Scope
+    def class_ivars_for: (String | Symbol? class_name) -> Hash[Symbol, Type::t]
+    def with_class_ivars: (Hash[String, Hash[Symbol, Type::t]] table) -> Scope
+    def class_cvars_for: (String | Symbol? class_name) -> Hash[Symbol, Type::t]
+    def with_class_cvars: (Hash[String, Hash[Symbol, Type::t]] table) -> Scope
+    def with_program_globals: (Hash[Symbol, Type::t] table) -> Scope
+    def with_discovered_classes: (Hash[String, Type::Singleton] table) -> Scope
+    def with_in_source_constants: (Hash[String, Type::t] table) -> Scope
+    def with_discovered_methods: (Hash[String, Hash[Symbol, Symbol]] table) -> Scope
+    def discovered_method?: (String | Symbol class_name, String | Symbol method_name, Symbol kind) -> bool
+    def with_fact: (Analysis::FactStore::Fact fact) -> Scope
+    def with_self_type: (Type::t? type) -> Scope
+    def with_declared_types: (Hash[untyped, Type::t] table) -> Scope
+    def facts_for: (?target: Analysis::FactStore::Target?, ?bucket: Symbol?) -> Array[Analysis::FactStore::Fact]
+    def local_facts: (String | Symbol name, ?bucket: Symbol?) -> Array[Analysis::FactStore::Fact]
+    def type_of: (untyped node, ?tracer: Inference::FallbackTracer?) -> Type::t
+    def evaluate: (untyped node, ?tracer: Inference::FallbackTracer?) -> [Type::t, Scope]
+    def join: (Scope other) -> Scope
+    def ==: (untyped other) -> bool
+    def hash: () -> Integer
+  end
+end

data/sig/rigor/source.rbs

@@ -0,0 +1,20 @@
+module Rigor
+  module Source
+    class NodeLocator
+      class OutOfRangeError < StandardError
+      end
+
+      def self.at_position: (source: String, root: untyped, line: Integer, column: Integer) -> untyped?
+      def self.at_offset: (root: untyped, offset: Integer) -> untyped?
+      def initialize: (source: String, root: untyped) -> void
+      def at_position: (line: Integer, column: Integer) -> untyped?
+      def at_offset: (Integer offset) -> untyped?
+    end
+
+    module NodeWalker
+      def self?.each: (untyped root) { (untyped) -> void } -> nil
+                    | (untyped root) -> Enumerator[untyped, nil]
+      def self?.walk: (untyped node) { (untyped) -> void } -> void
+    end
+  end
+end

data/sig/rigor/testing.rbs

@@ -0,0 +1,9 @@
+module Rigor
+  module Testing
+    def self?.dump_type: (untyped value) -> untyped
+    def self?.assert_type: (String expected, untyped value) -> untyped
+  end
+
+  def self.dump_type: (untyped value) -> untyped
+  def self.assert_type: (String expected, untyped value) -> untyped
+end

data/sig/rigor/trinary.rbs

@@ -0,0 +1,29 @@
+module Rigor
+  class Trinary
+    type value = :yes | :no | :maybe
+
+    VALUES: Array[value]
+    YES: Trinary
+    NO: Trinary
+    MAYBE: Trinary
+
+    attr_reader value: value
+
+    def self.yes: () -> Trinary
+    def self.no: () -> Trinary
+    def self.maybe: () -> Trinary
+    def self.from_symbol: (Symbol symbol) -> Trinary
+
+    def initialize: (value value) -> void
+    def yes?: () -> bool
+    def no?: () -> bool
+    def maybe?: () -> bool
+    def negate: () -> Trinary
+    def and: (Trinary other) -> Trinary
+    def or: (Trinary other) -> Trinary
+    def ==: (untyped other) -> bool
+    def hash: () -> Integer
+    def to_s: () -> String
+    def inspect: () -> String
+  end
+end

data/sig/rigor/type.rbs

@@ -0,0 +1,171 @@
+module Rigor
+  module Type
+    type t = Top | Bot | Dynamic | Constant | Nominal | Singleton | Union | Tuple | HashShape
+
+    type accepts_mode = :strict | :gradual | :loose
+
+    class Top
+      def self.instance: () -> Top
+      def describe: (?Symbol verbosity) -> String
+      def erase_to_rbs: () -> String
+      def top: () -> Top
+      def bot: () -> Bot
+      def dynamic: () -> Dynamic
+      def accepts: (Type::t other, ?mode: accepts_mode) -> AcceptsResult
+      def ==: (untyped other) -> bool
+      def hash: () -> Integer
+      def inspect: () -> String
+    end
+
+    class Bot
+      def self.instance: () -> Bot
+      def describe: (?Symbol verbosity) -> String
+      def erase_to_rbs: () -> String
+      def top: () -> Top
+      def bot: () -> Bot
+      def dynamic: () -> Dynamic
+      def accepts: (Type::t other, ?mode: accepts_mode) -> AcceptsResult
+      def ==: (untyped other) -> bool
+      def hash: () -> Integer
+      def inspect: () -> String
+    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 top: () -> Top
+      def bot: () -> Bot
+      def dynamic: () -> Dynamic
+      def accepts: (Type::t other, ?mode: accepts_mode) -> AcceptsResult
+      def ==: (untyped other) -> bool
+      def hash: () -> Integer
+      def inspect: () -> String
+    end
+
+    class Constant
+      attr_reader value: untyped
+      def initialize: (untyped value) -> void
+      def describe: (?Symbol verbosity) -> String
+      def erase_to_rbs: () -> String
+      def top: () -> Top
+      def bot: () -> Bot
+      def dynamic: () -> Dynamic
+      def accepts: (Type::t other, ?mode: accepts_mode) -> AcceptsResult
+      def ==: (untyped other) -> bool
+      def hash: () -> Integer
+      def inspect: () -> String
+    end
+
+    class Nominal
+      attr_reader class_name: String
+      attr_reader type_args: Array[Type::t]
+      def initialize: (String class_name, ?Array[Type::t] type_args) -> void
+      def describe: (?Symbol verbosity) -> String
+      def erase_to_rbs: () -> String
+      def top: () -> Top
+      def bot: () -> Bot
+      def dynamic: () -> Dynamic
+      def accepts: (Type::t other, ?mode: accepts_mode) -> AcceptsResult
+      def ==: (untyped other) -> bool
+      def hash: () -> Integer
+      def inspect: () -> String
+    end
+
+    class Singleton
+      attr_reader class_name: String
+      def initialize: (String class_name) -> void
+      def describe: (?Symbol verbosity) -> String
+      def erase_to_rbs: () -> String
+      def top: () -> Top
+      def bot: () -> Bot
+      def dynamic: () -> Dynamic
+      def accepts: (Type::t other, ?mode: accepts_mode) -> AcceptsResult
+      def ==: (untyped other) -> bool
+      def hash: () -> Integer
+      def inspect: () -> String
+    end
+
+    class Union
+      attr_reader members: Array[Type::t]
+      def initialize: (Array[Type::t] members) -> void
+      def describe: (?Symbol verbosity) -> String
+      def erase_to_rbs: () -> String
+      def top: () -> Top
+      def bot: () -> Bot
+      def dynamic: () -> Dynamic
+      def accepts: (Type::t other, ?mode: accepts_mode) -> AcceptsResult
+      def ==: (untyped other) -> bool
+      def hash: () -> Integer
+      def inspect: () -> String
+    end
+
+    class Tuple
+      attr_reader elements: Array[Type::t]
+      def initialize: (Array[Type::t] elements) -> void
+      def describe: (?Symbol verbosity) -> String
+      def erase_to_rbs: () -> String
+      def top: () -> Top
+      def bot: () -> Bot
+      def dynamic: () -> Dynamic
+      def accepts: (Type::t other, ?mode: accepts_mode) -> AcceptsResult
+      def ==: (untyped other) -> bool
+      def hash: () -> Integer
+      def inspect: () -> String
+    end
+
+    class HashShape
+      attr_reader pairs: Hash[untyped, Type::t]
+      attr_reader required_keys: Array[untyped]
+      attr_reader optional_keys: Array[untyped]
+      attr_reader read_only_keys: Array[untyped]
+      attr_reader extra_keys: Symbol
+      def initialize: (?Hash[untyped, Type::t]? pairs, **untyped keywords) -> void
+      def describe: (?Symbol verbosity) -> String
+      def erase_to_rbs: () -> String
+      def open?: () -> bool
+      def closed?: () -> bool
+      def required_key?: (untyped key) -> bool
+      def optional_key?: (untyped key) -> bool
+      def read_only_key?: (untyped key) -> bool
+      def top: () -> Top
+      def bot: () -> Bot
+      def dynamic: () -> Dynamic
+      def accepts: (Type::t other, ?mode: accepts_mode) -> AcceptsResult
+      def ==: (untyped other) -> bool
+      def hash: () -> Integer
+      def inspect: () -> String
+    end
+
+    class AcceptsResult
+      attr_reader trinary: Trinary
+      attr_reader mode: accepts_mode
+      attr_reader reasons: Array[String]
+      def self.yes: (?mode: accepts_mode, ?reasons: (Array[String] | String)?) -> AcceptsResult
+      def self.no: (?mode: accepts_mode, ?reasons: (Array[String] | String)?) -> AcceptsResult
+      def self.maybe: (?mode: accepts_mode, ?reasons: (Array[String] | String)?) -> AcceptsResult
+      def initialize: (Trinary trinary, ?mode: accepts_mode, ?reasons: (Array[String] | String)?) -> void
+      def yes?: () -> bool
+      def no?: () -> bool
+      def maybe?: () -> bool
+      def with_reason: (String reason) -> AcceptsResult
+      def ==: (untyped other) -> bool
+      def hash: () -> Integer
+      def inspect: () -> String
+    end
+
+    module Combinator
+      def self?.top: () -> Top
+      def self?.bot: () -> Bot
+      def self?.untyped: () -> Dynamic
+      def self?.dynamic: (Type::t static_facet) -> Dynamic
+      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?.tuple_of: (*Type::t elements) -> Tuple
+      def self?.hash_shape_of: (?Hash[untyped, Type::t]? pairs, **untyped options) -> HashShape
+      def self?.union: (*Type::t types) -> Type::t
+    end
+  end
+end

data/sig/rigor.rbs

@@ -0,0 +1,70 @@
+module Rigor
+  VERSION: String
+
+  class Configuration
+    DEFAULT_PATH: String
+    DEFAULTS: Hash[String, untyped]
+
+    attr_reader target_ruby: String
+    attr_reader paths: Array[String]
+    attr_reader plugins: Array[String]
+    attr_reader cache_path: String
+
+    def self.load: (?String path) -> Configuration
+    def initialize: (?Hash[String, untyped] data) -> void
+    def to_h: () -> Hash[String, untyped]
+  end
+
+  class CLI
+    EXIT_USAGE: Integer
+
+    def self.start: (?Array[String] argv, ?out: untyped, ?err: untyped) -> Integer
+
+    def initialize: (?Array[String] argv, ?out: untyped, ?err: untyped) -> void
+    def run: () -> Integer
+
+    class TypeOfCommand
+      USAGE: String
+
+      def initialize: (argv: Array[String], out: untyped, err: untyped) -> void
+      def run: () -> Integer
+    end
+
+    class TypeScanCommand
+      USAGE: String
+
+      def initialize: (argv: Array[String], out: untyped, err: untyped) -> void
+      def run: () -> Integer
+    end
+  end
+
+  module Analysis
+    class Diagnostic
+      attr_reader path: String
+      attr_reader line: Integer
+      attr_reader column: Integer
+      attr_reader message: String
+      attr_reader severity: Symbol
+
+      def initialize: (path: String, line: Integer, column: Integer, message: String, ?severity: Symbol) -> void
+      def error?: () -> bool
+      def to_h: () -> Hash[String, untyped]
+      def to_s: () -> String
+    end
+
+    class Result
+      attr_reader diagnostics: Array[Diagnostic]
+
+      def initialize: (?diagnostics: Array[Diagnostic]) -> void
+      def success?: () -> bool
+      def error_count: () -> Integer
+      def to_h: () -> Hash[String, untyped]
+    end
+
+    class Runner
+      RUBY_GLOB: String
+      def initialize: (configuration: Configuration) -> void
+      def run: (?Array[String] paths) -> Result
+    end
+  end
+end