spoom 1.6.3 → 1.7.1

data/rbi/spoom.rbi

@@ -6,11 +6,8 @@
 
 module Spoom
   class << self
-    sig { params(ruby: ::String, file: ::String).returns(::Prism::Node) }
-    def parse_ruby(ruby, file:); end
-
-    sig { params(ruby: ::String, file: ::String).returns([::Prism::Node, T::Array[::Prism::Comment]]) }
-    def parse_ruby_with_comments(ruby, file:); end
+    sig { params(ruby: ::String, file: ::String, comments: T::Boolean).returns(::Prism::Node) }
+    def parse_ruby(ruby, file:, comments: T.unsafe(nil)); end
   end
 end
 
@@ -168,10 +165,19 @@ class Spoom::Cli::Srb::Main < ::Thor
   def coverage(*args); end
   def help(command = T.unsafe(nil), subcommand = T.unsafe(nil)); end
   def lsp(*args); end
+  def metrics(*args); end
   def sigs(*args); end
   def tc(*args); end
 end
 
+class Spoom::Cli::Srb::Metrics < ::Thor
+  include ::Spoom::Colorize
+  include ::Spoom::Cli::Helper
+
+  def help(command = T.unsafe(nil), subcommand = T.unsafe(nil)); end
+  def show(*paths); end
+end
+
 class Spoom::Cli::Srb::Sigs < ::Thor
   include ::Spoom::Colorize
   include ::Spoom::Cli::Helper
@@ -425,6 +431,17 @@ module Spoom::Context::Sorbet
   def write_sorbet_config!(contents, append: T.unsafe(nil)); end
 end
 
+class Spoom::Counters < ::Hash
+  sig { void }
+  def initialize; end
+
+  sig { params(key: ::String).returns(::Integer) }
+  def [](key); end
+
+  sig { params(key: ::String).void }
+  def increment(key); end
+end
+
 module Spoom::Coverage
   class << self
     sig { params(context: ::Spoom::Context).returns(::Spoom::FileTree) }
@@ -1133,6 +1150,7 @@ end
 
 Spoom::Deadcode::Plugins::ActiveRecord::ARRAY_METHODS = T.let(T.unsafe(nil), Array)
 Spoom::Deadcode::Plugins::ActiveRecord::CALLBACKS = T.let(T.unsafe(nil), Array)
+Spoom::Deadcode::Plugins::ActiveRecord::CALLBACK_CONDITIONS = T.let(T.unsafe(nil), Array)
 Spoom::Deadcode::Plugins::ActiveRecord::CRUD_METHODS = T.let(T.unsafe(nil), Array)
 
 class Spoom::Deadcode::Plugins::ActiveSupport < ::Spoom::Deadcode::Plugins::Base
@@ -2100,8 +2118,8 @@ class Spoom::Model::AttrReader < ::Spoom::Model::Attr; end
 class Spoom::Model::AttrWriter < ::Spoom::Model::Attr; end
 
 class Spoom::Model::Builder < ::Spoom::Model::NamespaceVisitor
-  sig { params(model: ::Spoom::Model, file: ::String, comments: T::Array[::Prism::Comment]).void }
-  def initialize(model, file, comments:); end
+  sig { params(model: ::Spoom::Model, file: ::String).void }
+  def initialize(model, file); end
 
   sig { override.params(node: ::Prism::CallNode).void }
   def visit_call_node(node); end
@@ -2447,29 +2465,25 @@ end
 class Spoom::ParseError < ::Spoom::Error; end
 
 class Spoom::Poset
-  extend T::Generic
-
-  E = type_member { { upper: Object } }
-
   sig { void }
   def initialize; end
 
-  sig { params(value: E).returns(Spoom::Poset::Element[E]) }
+  sig { params(value: T.untyped).returns(Spoom::Poset::Element[T.untyped]) }
   def [](value); end
 
-  sig { params(from: E, to: E).void }
+  sig { params(from: T.untyped, to: T.untyped).void }
   def add_direct_edge(from, to); end
 
-  sig { params(value: E).returns(Spoom::Poset::Element[E]) }
+  sig { params(value: T.untyped).returns(Spoom::Poset::Element[T.untyped]) }
   def add_element(value); end
 
-  sig { params(from: E, to: E).returns(T::Boolean) }
+  sig { params(from: T.untyped, to: T.untyped).returns(T::Boolean) }
   def direct_edge?(from, to); end
 
-  sig { params(from: E, to: E).returns(T::Boolean) }
+  sig { params(from: T.untyped, to: T.untyped).returns(T::Boolean) }
   def edge?(from, to); end
 
-  sig { params(value: E).returns(T::Boolean) }
+  sig { params(value: T.untyped).returns(T::Boolean) }
   def element?(value); end
 
   sig { params(direct: T::Boolean, transitive: T::Boolean).void }
@@ -2480,39 +2494,36 @@ class Spoom::Poset
 end
 
 class Spoom::Poset::Element
-  extend T::Generic
   include ::Comparable
 
-  E = type_member { { upper: Object } }
-
-  sig { params(value: E).void }
+  sig { params(value: T.untyped).void }
   def initialize(value); end
 
   sig { params(other: T.untyped).returns(T.nilable(::Integer)) }
   def <=>(other); end
 
-  sig { returns(T::Array[E]) }
+  sig { returns(T::Array[T.untyped]) }
   def ancestors; end
 
-  sig { returns(T::Array[E]) }
+  sig { returns(T::Array[T.untyped]) }
   def children; end
 
-  sig { returns(T::Array[E]) }
+  sig { returns(T::Array[T.untyped]) }
   def descendants; end
 
   def dfroms; end
 
-  sig { returns(T::Set[Spoom::Poset::Element[E]]) }
+  sig { returns(T::Set[Spoom::Poset::Element[T.untyped]]) }
   def dtos; end
 
   def froms; end
 
-  sig { returns(T::Array[E]) }
+  sig { returns(T::Array[T.untyped]) }
   def parents; end
 
   def tos; end
 
-  sig { returns(E) }
+  sig { returns(T.untyped) }
   def value; end
 end
 
@@ -2554,117 +2565,42 @@ class Spoom::Printer
   def printt; end
 end
 
-Spoom::SPOOM_PATH = T.let(T.unsafe(nil), String)
-module Spoom::Sorbet; end
-
-class Spoom::Sorbet::Assertions
-  class << self
-    sig { params(ruby_contents: ::String, file: ::String).returns(::String) }
-    def rbi_to_rbs(ruby_contents, file:); end
-
-    private
+module Spoom::RBS; end
+class Spoom::RBS::Annotations < ::Spoom::RBS::Comment; end
 
-    sig { params(ruby_contents: ::String, file: ::String).returns(T::Array[::Spoom::Sorbet::Assertions::AssignNode]) }
-    def collect_assigns(ruby_contents, file:); end
-
-    sig { params(assign: ::Spoom::Sorbet::Assertions::AssignNode).returns(::String) }
-    def dedent_value(assign); end
-  end
-end
-
-class Spoom::Sorbet::Assertions::AssignNode
-  sig do
-    params(
-      node: T.any(::Prism::ClassVariableAndWriteNode, ::Prism::ClassVariableOperatorWriteNode, ::Prism::ClassVariableOrWriteNode, ::Prism::ClassVariableWriteNode, ::Prism::ConstantAndWriteNode, ::Prism::ConstantOperatorWriteNode, ::Prism::ConstantOrWriteNode, ::Prism::ConstantPathAndWriteNode, ::Prism::ConstantPathOperatorWriteNode, ::Prism::ConstantPathOrWriteNode, ::Prism::ConstantPathWriteNode, ::Prism::ConstantWriteNode, ::Prism::GlobalVariableAndWriteNode, ::Prism::GlobalVariableOperatorWriteNode, ::Prism::GlobalVariableOrWriteNode, ::Prism::GlobalVariableWriteNode, ::Prism::InstanceVariableAndWriteNode, ::Prism::InstanceVariableOperatorWriteNode, ::Prism::InstanceVariableOrWriteNode, ::Prism::InstanceVariableWriteNode, ::Prism::LocalVariableAndWriteNode, ::Prism::LocalVariableOperatorWriteNode, ::Prism::LocalVariableOrWriteNode, ::Prism::LocalVariableWriteNode),
-      operator_loc: ::Prism::Location,
-      value: ::Prism::Node,
-      type: ::Prism::Node
-    ).void
-  end
-  def initialize(node, operator_loc, value, type); end
-
-  sig do
-    returns(T.any(::Prism::ClassVariableAndWriteNode, ::Prism::ClassVariableOperatorWriteNode, ::Prism::ClassVariableOrWriteNode, ::Prism::ClassVariableWriteNode, ::Prism::ConstantAndWriteNode, ::Prism::ConstantOperatorWriteNode, ::Prism::ConstantOrWriteNode, ::Prism::ConstantPathAndWriteNode, ::Prism::ConstantPathOperatorWriteNode, ::Prism::ConstantPathOrWriteNode, ::Prism::ConstantPathWriteNode, ::Prism::ConstantWriteNode, ::Prism::GlobalVariableAndWriteNode, ::Prism::GlobalVariableOperatorWriteNode, ::Prism::GlobalVariableOrWriteNode, ::Prism::GlobalVariableWriteNode, ::Prism::InstanceVariableAndWriteNode, ::Prism::InstanceVariableOperatorWriteNode, ::Prism::InstanceVariableOrWriteNode, ::Prism::InstanceVariableWriteNode, ::Prism::LocalVariableAndWriteNode, ::Prism::LocalVariableOperatorWriteNode, ::Prism::LocalVariableOrWriteNode, ::Prism::LocalVariableWriteNode))
-  end
-  def node; end
+class Spoom::RBS::Comment
+  sig { params(string: ::String, location: ::Prism::Location).void }
+  def initialize(string, location); end
 
   sig { returns(::Prism::Location) }
-  def operator_loc; end
+  def location; end
 
   sig { returns(::String) }
-  def rbs_type; end
-
-  def type; end
-
-  sig { returns(::Prism::Node) }
-  def value; end
+  def string; end
 end
 
-Spoom::Sorbet::Assertions::AssignType = T.type_alias { T.any(::Prism::ClassVariableAndWriteNode, ::Prism::ClassVariableOperatorWriteNode, ::Prism::ClassVariableOrWriteNode, ::Prism::ClassVariableWriteNode, ::Prism::ConstantAndWriteNode, ::Prism::ConstantOperatorWriteNode, ::Prism::ConstantOrWriteNode, ::Prism::ConstantPathAndWriteNode, ::Prism::ConstantPathOperatorWriteNode, ::Prism::ConstantPathOrWriteNode, ::Prism::ConstantPathWriteNode, ::Prism::ConstantWriteNode, ::Prism::GlobalVariableAndWriteNode, ::Prism::GlobalVariableOperatorWriteNode, ::Prism::GlobalVariableOrWriteNode, ::Prism::GlobalVariableWriteNode, ::Prism::InstanceVariableAndWriteNode, ::Prism::InstanceVariableOperatorWriteNode, ::Prism::InstanceVariableOrWriteNode, ::Prism::InstanceVariableWriteNode, ::Prism::LocalVariableAndWriteNode, ::Prism::LocalVariableOperatorWriteNode, ::Prism::LocalVariableOrWriteNode, ::Prism::LocalVariableWriteNode) }
-
-class Spoom::Sorbet::Assertions::Locator < ::Spoom::Visitor
+class Spoom::RBS::Comments
   sig { void }
   def initialize; end
 
-  sig { returns(T::Array[::Spoom::Sorbet::Assertions::AssignNode]) }
-  def assigns; end
-
-  sig { params(node: ::Prism::Node).returns(T::Boolean) }
-  def contains_heredoc?(node); end
-
-  sig { params(node: T.nilable(::Prism::Node)).returns(T::Boolean) }
-  def t?(node); end
-
-  sig { params(node: ::Prism::CallNode).returns(T::Boolean) }
-  def t_annotation?(node); end
-
-  sig do
-    params(
-      node: T.any(::Prism::ClassVariableAndWriteNode, ::Prism::ClassVariableOperatorWriteNode, ::Prism::ClassVariableOrWriteNode, ::Prism::ClassVariableWriteNode, ::Prism::ConstantAndWriteNode, ::Prism::ConstantOperatorWriteNode, ::Prism::ConstantOrWriteNode, ::Prism::ConstantPathAndWriteNode, ::Prism::ConstantPathOperatorWriteNode, ::Prism::ConstantPathOrWriteNode, ::Prism::ConstantPathWriteNode, ::Prism::ConstantWriteNode, ::Prism::GlobalVariableAndWriteNode, ::Prism::GlobalVariableOperatorWriteNode, ::Prism::GlobalVariableOrWriteNode, ::Prism::GlobalVariableWriteNode, ::Prism::InstanceVariableAndWriteNode, ::Prism::InstanceVariableOperatorWriteNode, ::Prism::InstanceVariableOrWriteNode, ::Prism::InstanceVariableWriteNode, ::Prism::LocalVariableAndWriteNode, ::Prism::LocalVariableOperatorWriteNode, ::Prism::LocalVariableOrWriteNode, ::Prism::LocalVariableWriteNode)
-    ).void
-  end
-  def visit_assign(node); end
-
-  def visit_class_variable_and_write_node(*args, **_arg1, &blk); end
-  def visit_class_variable_operator_write_node(*args, **_arg1, &blk); end
-  def visit_class_variable_or_write_node(*args, **_arg1, &blk); end
-  def visit_class_variable_write_node(*args, **_arg1, &blk); end
-  def visit_constant_and_write_node(*args, **_arg1, &blk); end
-  def visit_constant_operator_write_node(*args, **_arg1, &blk); end
-  def visit_constant_or_write_node(*args, **_arg1, &blk); end
-  def visit_constant_path_and_write_node(*args, **_arg1, &blk); end
-  def visit_constant_path_operator_write_node(*args, **_arg1, &blk); end
-  def visit_constant_path_or_write_node(*args, **_arg1, &blk); end
-  def visit_constant_path_write_node(*args, **_arg1, &blk); end
-  def visit_constant_write_node(*args, **_arg1, &blk); end
-  def visit_global_variable_and_write_node(*args, **_arg1, &blk); end
-  def visit_global_variable_operator_write_node(*args, **_arg1, &blk); end
-  def visit_global_variable_or_write_node(*args, **_arg1, &blk); end
-  def visit_global_variable_write_node(*args, **_arg1, &blk); end
-  def visit_instance_variable_and_write_node(*args, **_arg1, &blk); end
-  def visit_instance_variable_operator_write_node(*args, **_arg1, &blk); end
-  def visit_instance_variable_or_write_node(*args, **_arg1, &blk); end
-  def visit_instance_variable_write_node(*args, **_arg1, &blk); end
-  def visit_local_variable_and_write_node(*args, **_arg1, &blk); end
-  def visit_local_variable_operator_write_node(*args, **_arg1, &blk); end
-  def visit_local_variable_or_write_node(*args, **_arg1, &blk); end
-  def visit_local_variable_write_node(*args, **_arg1, &blk); end
-  def visit_multi_write_node(*args, **_arg1, &blk); end
-end
-
-Spoom::Sorbet::Assertions::Locator::ANNOTATION_METHODS = T.let(T.unsafe(nil), Array)
-
-class Spoom::Sorbet::Assertions::Locator::HeredocVisitor < ::Spoom::Visitor
-  sig { void }
-  def initialize; end
+  sig { returns(T::Array[::Spoom::RBS::Annotations]) }
+  def annotations; end
 
   sig { returns(T::Boolean) }
-  def contains_heredoc; end
+  def empty?; end
 
-  sig { override.params(node: T.nilable(::Prism::Node)).void }
-  def visit(node); end
+  sig { returns(T::Array[::Spoom::RBS::Signature]) }
+  def signatures; end
+end
+
+module Spoom::RBS::ExtractRBSComments
+  sig { params(node: ::Prism::Node).returns(::Spoom::RBS::Comments) }
+  def node_rbs_comments(node); end
 end
 
+class Spoom::RBS::Signature < ::Spoom::RBS::Comment; end
+Spoom::SPOOM_PATH = T.let(T.unsafe(nil), String)
+module Spoom::Sorbet; end
 Spoom::Sorbet::BIN_PATH = T.let(T.unsafe(nil), String)
 Spoom::Sorbet::CONFIG_PATH = T.let(T.unsafe(nil), String)
 
@@ -2809,12 +2745,72 @@ Spoom::Sorbet::GEM_PATH = T.let(T.unsafe(nil), String)
 Spoom::Sorbet::GEM_VERSION = T.let(T.unsafe(nil), String)
 Spoom::Sorbet::KILLED_CODE = T.let(T.unsafe(nil), Integer)
 
-module Spoom::Sorbet::MetricsParser
+module Spoom::Sorbet::Metrics
+  class << self
+    sig { params(files: T::Array[::String]).returns(Spoom::Counters) }
+    def collect_code_metrics(files); end
+  end
+end
+
+class Spoom::Sorbet::Metrics::CodeMetricsVisitor < ::Spoom::Visitor
+  include ::Spoom::RBS::ExtractRBSComments
+
+  sig { params(counters: Spoom::Counters).void }
+  def initialize(counters); end
+
+  sig { returns(Spoom::Counters) }
+  def counters; end
+
+  sig { override.params(node: T.nilable(::Prism::Node)).void }
+  def visit(node); end
+
+  sig { override.params(node: ::Prism::CallNode).void }
+  def visit_call_node(node); end
+
+  sig { override.params(node: ::Prism::ClassNode).void }
+  def visit_class_node(node); end
+
+  sig { override.params(node: ::Prism::DefNode).void }
+  def visit_def_node(node); end
+
+  sig { override.params(node: ::Prism::ModuleNode).void }
+  def visit_module_node(node); end
+
+  sig { override.params(node: ::Prism::SingletonClassNode).void }
+  def visit_singleton_class_node(node); end
+
+  private
+
+  sig { returns(T::Array[::Prism::CallNode]) }
+  def collect_last_srb_sigs; end
+
+  sig { params(node: T.any(::Prism::ClassNode, ::Prism::ModuleNode, ::Prism::SingletonClassNode)).returns(::String) }
+  def node_key(node); end
+
+  sig { params(node: ::Prism::CallNode).void }
+  def visit_attr_accessor(node); end
+
+  sig do
+    params(
+      node: T.any(::Prism::ClassNode, ::Prism::ModuleNode, ::Prism::SingletonClassNode),
+      block: T.proc.void
+    ).void
+  end
+  def visit_scope(node, &block); end
+
+  sig { params(node: ::Prism::CallNode).void }
+  def visit_sig(node); end
+
+  sig { params(node: ::Prism::CallNode).void }
+  def visit_type_member(node); end
+end
+
+module Spoom::Sorbet::Metrics::MetricsFileParser
   class << self
     sig { params(path: ::String, prefix: ::String).returns(T::Hash[::String, ::Integer]) }
     def parse_file(path, prefix = T.unsafe(nil)); end
 
-    sig { params(obj: T::Hash[::String, T.untyped], prefix: ::String).returns(T::Hash[::String, ::Integer]) }
+    sig { params(obj: T::Hash[::String, T.untyped], prefix: ::String).returns(Spoom::Counters) }
     def parse_hash(obj, prefix = T.unsafe(nil)); end
 
     sig { params(string: ::String, prefix: ::String).returns(T::Hash[::String, ::Integer]) }
@@ -2822,7 +2818,7 @@ module Spoom::Sorbet::MetricsParser
   end
 end
 
-Spoom::Sorbet::MetricsParser::DEFAULT_PREFIX = T.let(T.unsafe(nil), String)
+Spoom::Sorbet::Metrics::MetricsFileParser::DEFAULT_PREFIX = T.let(T.unsafe(nil), String)
 Spoom::Sorbet::SEGFAULT_CODE = T.let(T.unsafe(nil), Integer)
 
 module Spoom::Sorbet::Sigils
@@ -2859,87 +2855,250 @@ Spoom::Sorbet::Sigils::STRICTNESS_STRONG = T.let(T.unsafe(nil), String)
 Spoom::Sorbet::Sigils::STRICTNESS_TRUE = T.let(T.unsafe(nil), String)
 Spoom::Sorbet::Sigils::VALID_STRICTNESS = T.let(T.unsafe(nil), Array)
 
-class Spoom::Sorbet::Sigs
+module Spoom::Sorbet::Translate
   class << self
-    sig { params(ruby_contents: ::String, positional_names: T::Boolean).returns(::String) }
-    def rbi_to_rbs(ruby_contents, positional_names: T.unsafe(nil)); end
+    sig { params(ruby_contents: ::String, file: ::String).returns(::String) }
+    def rbs_comments_to_sorbet_sigs(ruby_contents, file:); end
 
-    sig { params(ruby_contents: ::String).returns(::String) }
-    def rbs_to_rbi(ruby_contents); end
+    sig { params(ruby_contents: ::String, file: ::String).returns(::String) }
+    def sorbet_assertions_to_rbs_comments(ruby_contents, file:); end
 
-    sig { params(ruby_contents: ::String).returns(::String) }
-    def strip(ruby_contents); end
+    sig { params(ruby_contents: ::String, file: ::String, positional_names: T::Boolean).returns(::String) }
+    def sorbet_sigs_to_rbs_comments(ruby_contents, file:, positional_names: T.unsafe(nil)); end
 
-    private
+    sig { params(ruby_contents: ::String, file: ::String).returns(::String) }
+    def strip_sorbet_sigs(ruby_contents, file:); end
+  end
+end
+
+class Spoom::Sorbet::Translate::Error < ::Spoom::Error; end
+
+class Spoom::Sorbet::Translate::RBSCommentsToSorbetSigs < ::Spoom::Sorbet::Translate::Translator
+  include ::Spoom::RBS::ExtractRBSComments
 
-    sig { params(ruby_contents: ::String).returns(T::Array[[::RBI::RBSComment, T.any(::RBI::Attr, ::RBI::Method)]]) }
-    def collect_rbs_comments(ruby_contents); end
+  sig { override.params(node: ::Prism::CallNode).void }
+  def visit_call_node(node); end
 
-    sig { params(ruby_contents: ::String).returns(T::Array[[::RBI::Sig, T.any(::RBI::Attr, ::RBI::Method)]]) }
-    def collect_sorbet_sigs(ruby_contents); end
+  sig { override.params(node: ::Prism::ClassNode).void }
+  def visit_class_node(node); end
+
+  sig { override.params(node: ::Prism::DefNode).void }
+  def visit_def_node(node); end
+
+  sig { override.params(node: ::Prism::ModuleNode).void }
+  def visit_module_node(node); end
+
+  sig { override.params(node: ::Prism::SingletonClassNode).void }
+  def visit_singleton_class_node(node); end
+
+  private
+
+  sig do
+    params(
+      node: T.any(::Prism::ClassNode, ::Prism::ModuleNode, ::Prism::SingletonClassNode),
+      constant_regex: ::Regexp
+    ).returns(T::Boolean)
   end
+  def already_extends?(node, constant_regex); end
+
+  sig { params(node: T.any(::Prism::ClassNode, ::Prism::ModuleNode, ::Prism::SingletonClassNode)).void }
+  def apply_class_annotations(node); end
+
+  sig { params(annotations: T::Array[::Spoom::RBS::Annotations], sig: ::RBI::Sig).void }
+  def apply_member_annotations(annotations, sig); end
+
+  sig { params(node: ::Prism::CallNode).void }
+  def visit_attr(node); end
 end
 
-class Spoom::Sorbet::Sigs::Error < ::Spoom::Error; end
+class Spoom::Sorbet::Translate::SorbetAssertionsToRBSComments < ::Spoom::Sorbet::Translate::Translator
+  sig { override.params(node: ::Prism::CallNode).void }
+  def visit_call_node(node); end
 
-class Spoom::Sorbet::Sigs::RBIToRBSTranslator
-  class << self
-    sig do
-      params(
-        sig: ::RBI::Sig,
-        node: T.any(::RBI::Attr, ::RBI::Method),
-        positional_names: T::Boolean
-      ).returns(::String)
-    end
-    def translate(sig, node, positional_names: T.unsafe(nil)); end
+  private
 
-    private
+  sig { params(node: ::Prism::Node).returns(T::Boolean) }
+  def at_end_of_line?(node); end
 
-    sig { params(sig: ::RBI::Sig, node: ::RBI::Attr, positional_names: T::Boolean).returns(::String) }
-    def translate_attr_sig(sig, node, positional_names: T.unsafe(nil)); end
+  sig { params(call: ::Prism::CallNode).void }
+  def build_rbs_annotation(call); end
 
-    sig { params(sig: ::RBI::Sig, node: ::RBI::Method, positional_names: T::Boolean).returns(::String) }
-    def translate_method_sig(sig, node, positional_names: T.unsafe(nil)); end
-  end
+  sig { params(assign: ::Prism::Node, value: ::Prism::Node).returns(::String) }
+  def dedent_value(assign, value); end
+
+  sig { params(node: T.nilable(::Prism::Node)).returns(T::Boolean) }
+  def t?(node); end
+
+  sig { params(node: ::Prism::CallNode).returns(T::Boolean) }
+  def t_annotation?(node); end
 end
 
-class Spoom::Sorbet::Sigs::RBSToRBITranslator
-  class << self
-    sig { params(comment: ::RBI::RBSComment, node: T.any(::RBI::Attr, ::RBI::Method)).returns(T.nilable(::String)) }
-    def translate(comment, node); end
+Spoom::Sorbet::Translate::SorbetAssertionsToRBSComments::LINE_BREAK = T.let(T.unsafe(nil), Integer)
 
-    private
+class Spoom::Sorbet::Translate::SorbetSigsToRBSComments < ::Spoom::Sorbet::Translate::Translator
+  sig { params(ruby_contents: ::String, file: ::String, positional_names: T::Boolean).void }
+  def initialize(ruby_contents, file:, positional_names:); end
+
+  sig { override.params(node: ::Prism::CallNode).void }
+  def visit_call_node(node); end
 
-    sig { params(comment: ::RBI::RBSComment, node: ::RBI::Attr).returns(::String) }
-    def translate_attr_sig(comment, node); end
+  sig { override.params(node: ::Prism::ClassNode).void }
+  def visit_class_node(node); end
 
-    sig { params(rbs_comment: ::RBI::RBSComment, node: ::RBI::Method).returns(::String) }
-    def translate_method_sig(rbs_comment, node); end
+  sig { override.params(node: ::Prism::ConstantWriteNode).void }
+  def visit_constant_write_node(node); end
+
+  sig { override.params(node: ::Prism::DefNode).void }
+  def visit_def_node(node); end
+
+  sig { override.params(node: ::Prism::ModuleNode).void }
+  def visit_module_node(node); end
+
+  sig { override.params(node: ::Prism::SingletonClassNode).void }
+  def visit_singleton_class_node(node); end
+
+  private
+
+  sig { params(sigs: T::Array[[::Prism::CallNode, ::RBI::Sig]]).void }
+  def apply_member_annotations(sigs); end
+
+  sig { params(node: ::Prism::ConstantWriteNode).returns(::String) }
+  def build_type_member_string(node); end
+
+  sig { params(node: ::Prism::CallNode).void }
+  def visit_attr(node); end
+
+  sig { params(node: ::Prism::CallNode).void }
+  def visit_class_annotation(node); end
+
+  sig { params(node: ::Prism::CallNode).void }
+  def visit_extend(node); end
+
+  sig do
+    params(
+      node: T.any(::Prism::ClassNode, ::Prism::ModuleNode, ::Prism::SingletonClassNode),
+      block: T.proc.void
+    ).void
   end
+  def visit_scope(node, &block); end
+
+  sig { params(node: ::Prism::CallNode).void }
+  def visit_sig(node); end
+end
+
+class Spoom::Sorbet::Translate::StripSorbetSigs < ::Spoom::Sorbet::Translate::Translator
+  sig { override.params(node: ::Prism::CallNode).void }
+  def visit_call_node(node); end
+end
+
+class Spoom::Sorbet::Translate::Translator < ::Spoom::Visitor
+  abstract!
+
+  sig { params(ruby_contents: ::String, file: ::String).void }
+  def initialize(ruby_contents, file:); end
+
+  sig { returns(::String) }
+  def rewrite; end
+
+  private
+
+  sig { params(offset: ::Integer).returns(::Integer) }
+  def adjust_to_line_end(offset); end
+
+  sig { params(offset: ::Integer).returns(::Integer) }
+  def adjust_to_line_start(offset); end
+
+  sig { params(offset: ::Integer).returns(::Integer) }
+  def adjust_to_new_line(offset); end
+
+  sig { params(node: ::Prism::CallNode).returns(T::Boolean) }
+  def sorbet_sig?(node); end
+end
+
+module Spoom::Source; end
+
+class Spoom::Source::Delete < ::Spoom::Source::Edit
+  sig { params(from: ::Integer, to: ::Integer).void }
+  def initialize(from, to); end
+
+  sig { override.params(bytes: T::Array[T.untyped]).void }
+  def apply(bytes); end
+
+  sig { returns(::Integer) }
+  def from; end
+
+  sig { override.returns([::Integer, ::Integer]) }
+  def range; end
+
+  def to; end
+
+  sig { override.returns(::String) }
+  def to_s; end
 end
 
-class Spoom::Sorbet::Sigs::Scanner
-  sig { params(source: ::String).void }
-  def initialize(source); end
+class Spoom::Source::Edit
+  abstract!
+
+  sig { abstract.params(bytes: T::Array[::Integer]).void }
+  def apply(bytes); end
 
-  sig { params(line: ::Integer, character: ::Integer).returns(::Integer) }
-  def find_char_position(line, character); end
+  sig { abstract.returns([::Integer, ::Integer]) }
+  def range; end
 end
 
-Spoom::Sorbet::Sigs::Scanner::LINE_BREAK = T.let(T.unsafe(nil), Integer)
+class Spoom::Source::Insert < ::Spoom::Source::Edit
+  sig { params(position: ::Integer, text: ::String).void }
+  def initialize(position, text); end
+
+  sig { override.params(bytes: T::Array[::Integer]).void }
+  def apply(bytes); end
+
+  sig { returns(::Integer) }
+  def position; end
+
+  sig { override.returns([::Integer, ::Integer]) }
+  def range; end
+
+  sig { returns(::String) }
+  def text; end
+
+  sig { override.returns(::String) }
+  def to_s; end
+end
+
+class Spoom::Source::PositionError < ::Spoom::Error; end
+
+class Spoom::Source::Replace < ::Spoom::Source::Edit
+  sig { params(from: ::Integer, to: ::Integer, text: ::String).void }
+  def initialize(from, to, text); end
 
-class Spoom::Sorbet::Sigs::SigsLocator < ::RBI::Visitor
+  sig { override.params(bytes: T::Array[::Integer]).void }
+  def apply(bytes); end
+
+  sig { returns(::Integer) }
+  def from; end
+
+  sig { override.returns([::Integer, ::Integer]) }
+  def range; end
+
+  sig { returns(::String) }
+  def text; end
+
+  def to; end
+
+  sig { override.returns(::String) }
+  def to_s; end
+end
+
+class Spoom::Source::Rewriter
   sig { void }
   def initialize; end
 
-  sig { returns(T::Array[[::RBI::RBSComment, T.any(::RBI::Attr, ::RBI::Method)]]) }
-  def rbs_comments; end
+  sig { params(other: ::Spoom::Source::Edit).void }
+  def <<(other); end
 
-  sig { returns(T::Array[[::RBI::Sig, T.any(::RBI::Attr, ::RBI::Method)]]) }
-  def sigs; end
-
-  sig { override.params(node: T.nilable(::RBI::Node)).void }
-  def visit(node); end
+  sig { params(bytes: T::Array[::Integer]).void }
+  def rewrite!(bytes); end
 end
 
 class Spoom::Timeline