spoom 1.7.15 → 1.8.0

data/lib/spoom/sorbet/translate/validator.rb

@@ -0,0 +1,214 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Spoom
+  module Sorbet
+    module Translate
+      # Checks that a translation preserved the lines of every "landmark" (e.g. classes, method defs, and so on)
+      # so line numbers in the rewritten output still line up with the original source.
+      module Validator
+        # A description of a landmark, like "class C", "def foo", etc.
+        #: type landmarkID = String
+
+        # The integer line numbers where each landmark appears.
+        #: type landmarks = Hash[landmarkID, Array[Integer]]
+
+        class << self
+          # Compares the landmarks in both sources and returns a result describing
+          # what changed:
+          #   missing_from_rewritten_output - dropped: an occurrence in the original
+          #                                   that is gone from the rewrite
+          #   excess_in_rewritten_output    - added: an occurrence in the rewrite with
+          #                                   no match in the original
+          #   on_wrong_line                 - survived but moved to a different line
+          #: (String original, String rewritten) -> ValidationResult
+          def validate(original, rewritten)
+            original_landmarks = LandmarkFinder.find_landmarks_in(original)
+            rewritten_landmarks = LandmarkFinder.find_landmarks_in(rewritten)
+
+            missing = []
+            excess = []
+            on_wrong_line = []
+
+            (original_landmarks.keys | rewritten_landmarks.keys).each do |landmark_id|
+              original_lines = original_landmarks.fetch(landmark_id, [])
+              rewritten_lines = rewritten_landmarks.fetch(landmark_id, [])
+
+              dropped = original_lines - rewritten_lines
+              added = rewritten_lines - original_lines
+
+              if dropped.any? && added.any?
+                # Present in both but on different lines: the landmark moved.
+                on_wrong_line << { landmark_id:, expected: dropped, actual: added }
+              else
+                dropped.each { |line| missing << { landmark_id:, line: } }
+                added.each { |line| excess << { landmark_id:, line: } }
+              end
+            end
+
+            if original.lines.count != rewritten.lines.count
+              on_wrong_line << { landmark_id: "EOF", expected: [original.lines.count], actual: [rewritten.lines.count] }
+            end
+
+            ValidationResult.new(
+              missing_from_rewritten_output: missing,
+              excess_in_rewritten_output: excess,
+              on_wrong_line: on_wrong_line,
+            )
+          end
+        end
+      end
+
+      # The outcome of comparing an original source with its rewritten form.
+      class ValidationResult
+        # A landmark dropped from, or added to, the rewritten output.
+        #: type landmark_location = { landmark_id: String, line: Integer }
+
+        # A landmark present in both sources, but on different lines.
+        #: type moved_landmark = { landmark_id: String, expected: Array[Integer], actual: Array[Integer] }
+
+        # Landmarks present in the original but missing from the rewrite.
+        #: Array[landmark_location]
+        attr_reader :missing_from_rewritten_output
+
+        # Landmarks present in the rewrite with no match in the original.
+        #: Array[landmark_location]
+        attr_reader :excess_in_rewritten_output
+
+        # Landmarks present in both sources, but that moved to a different line.
+        #: Array[moved_landmark]
+        attr_reader :on_wrong_line
+
+        #: (
+        #|   missing_from_rewritten_output: Array[landmark_location],
+        #|   excess_in_rewritten_output: Array[landmark_location],
+        #|   on_wrong_line: Array[moved_landmark]
+        #| ) -> void
+        def initialize(missing_from_rewritten_output:, excess_in_rewritten_output:, on_wrong_line:)
+          @missing_from_rewritten_output = missing_from_rewritten_output
+          @excess_in_rewritten_output = excess_in_rewritten_output
+          @on_wrong_line = on_wrong_line
+        end
+
+        # True when every landmark survived the rewrite on its original line.
+        #: -> bool
+        def valid?
+          @missing_from_rewritten_output.empty? &&
+            @excess_in_rewritten_output.empty? &&
+            @on_wrong_line.empty?
+        end
+
+        # Human-readable, one-per-line descriptions of every difference. Empty when
+        # the result is valid.
+        #: -> Array[String]
+        def errors
+          errors = @missing_from_rewritten_output.map do |entry|
+            "missing `#{entry[:landmark_id]}` (expected at line #{entry[:line]})"
+          end
+          errors += @excess_in_rewritten_output.map do |entry|
+            "excess `#{entry[:landmark_id]}` (found at line #{entry[:line]})"
+          end
+          errors += @on_wrong_line.map do |entry|
+            "`#{entry[:landmark_id]}` on the wrong line " \
+              "(expected at #{format_lines(entry[:expected])}, found at #{format_lines(entry[:actual])})"
+          end
+          errors
+        end
+
+        #: (untyped) -> void
+        def pretty_print(printer)
+          if valid?
+            printer.text("#<#{self.class.name} valid>")
+            return
+          end
+
+          printer.text("#<#{self.class.name} invalid")
+          errors.each do |error|
+            printer.breakable
+            printer.text("  #{error}")
+          end
+          printer.breakable
+          printer.text(">")
+        end
+
+        private
+
+        #: (Array[Integer]) -> String
+        def format_lines(lines)
+          "#{lines.size == 1 ? "line" : "lines"} #{lines.join(", ")}"
+        end
+      end
+
+      # Walks a Prism AST and records the locations of various bits of code
+      # whose locations we want to remain constant after a rewriter.
+      class LandmarkFinder < Prism::Visitor
+        #: Validator::landmarks
+        attr_reader :landmarks
+
+        class << self
+          #: (String) -> Hash[String, Array[Integer]]
+          def find_landmarks_in(source)
+            visitor = new
+            Prism.parse(source).value.accept(visitor)
+            visitor.landmarks
+          end
+        end
+
+        #: -> void
+        def initialize
+          super
+          @landmarks = Hash.new { |h, landmark_id| h[landmark_id] = [] } #: Validator::landmarks
+        end
+
+        # @override
+        #: (Prism::ClassNode) -> void
+        def visit_class_node(node)
+          record("class #{node.name}", node)
+          super # keep descending so nested classes/modules/defs are recorded too
+        end
+
+        # @override
+        #: (Prism::ModuleNode) -> void
+        def visit_module_node(node)
+          record("module #{node.name}", node)
+          super
+        end
+
+        # @override
+        #: (Prism::SingletonClassNode) -> void
+        def visit_singleton_class_node(node)
+          # `class << self` (or `class << obj`); record its opening location.
+          record("class << #{node.expression.slice}", node)
+          super
+        end
+
+        # @override
+        #: (Prism::DefNode) -> void
+        def visit_def_node(node)
+          # `def self.foo` (and `def Foo.bar`) carry a receiver; include it so
+          # singleton methods read like their source and key separately from
+          # same-named instance methods.
+          receiver = node.receiver
+          receiver_description = receiver ? "#{receiver.slice}." : ""
+          record("def #{receiver_description}#{node.name}", node)
+          super
+        end
+
+        # @override
+        #: (Prism::SourceLineNode) -> void
+        def visit_source_line_node(node)
+          record("__LINE__", node) # its value changes if the line moves
+          super
+        end
+
+        private
+
+        #: (String landmark_id, Prism::Node) -> void
+        def record(landmark_id, node)
+          (@landmarks[landmark_id] ||= []) << node.location.start_line
+        end
+      end
+      private_constant :LandmarkFinder
+    end
+  end
+end

data/lib/spoom/sorbet/translate.rb

@@ -5,6 +5,7 @@ require "rbi"
 
 require "spoom/source/rewriter"
 require "spoom/sorbet/translate/translator"
+require "spoom/sorbet/translate/validator"
 require "spoom/sorbet/translate/rbs_comments_to_sorbet_sigs"
 require "spoom/sorbet/translate/sorbet_assertions_to_rbs_comments"
 require "spoom/sorbet/translate/sorbet_sigs_to_rbs_comments"
@@ -53,9 +54,14 @@ module Spoom
 
         # Converts all the RBS comments in the given Ruby code to `sig` nodes.
         # It also handles type members and class annotations.
-        #: (String ruby_contents, file: String, ?max_line_length: Integer?) -> String
-        def rbs_comments_to_sorbet_sigs(ruby_contents, file:, max_line_length: nil)
-          RBSCommentsToSorbetSigs.rewrite_if_needed(ruby_contents, file: file, max_line_length: max_line_length)
+        #: (String ruby_contents, file: String, ?max_line_length: Integer?, ?overloads_strategy: Symbol) -> String
+        def rbs_comments_to_sorbet_sigs(ruby_contents, file:, max_line_length: nil, overloads_strategy: :translate_all)
+          RBSCommentsToSorbetSigs.rewrite_if_needed(
+            ruby_contents,
+            file: file,
+            max_line_length: max_line_length,
+            overloads_strategy: overloads_strategy,
+          )
         end
 
         # Converts all `T.let` and `T.cast` nodes to RBS comments in the given Ruby code.

data/lib/spoom/version.rb

@@ -2,5 +2,5 @@
 # frozen_string_literal: true
 
 module Spoom
-  VERSION = "1.7.15"
+  VERSION = "1.8.0"
 end

data/lib/spoom.rb

@@ -22,3 +22,5 @@ require "spoom/counters"
 require "spoom/sorbet"
 require "spoom/cli"
 require "spoom/version"
+
+require "spoom/ext/prism_types"

data/rbi/spoom.rbi

@@ -1150,8 +1150,15 @@ Spoom::Deadcode::Plugins::ActiveJob::CALLBACKS = T.let(T.unsafe(nil), Array)
 class Spoom::Deadcode::Plugins::ActiveModel < ::Spoom::Deadcode::Plugins::Base
   sig { override.params(send: ::Spoom::Deadcode::Send).void }
   def on_send(send); end
+
+  private
+
+  sig { params(hash_node: ::Prism::HashNode, location: ::Spoom::Location).void }
+  def reference_nested_symbol_options(hash_node, location); end
 end
 
+Spoom::Deadcode::Plugins::ActiveModel::NESTED_METHOD_REFERENCE_KEYS = T.let(T.unsafe(nil), Array)
+
 class Spoom::Deadcode::Plugins::ActiveRecord < ::Spoom::Deadcode::Plugins::Base
   sig { override.params(send: ::Spoom::Deadcode::Send).void }
   def on_send(send); end
@@ -1275,8 +1282,22 @@ end
 class Spoom::Deadcode::Plugins::GraphQL < ::Spoom::Deadcode::Plugins::Base
   sig { override.params(send: ::Spoom::Deadcode::Send).void }
   def on_send(send); end
+
+  private
+
+  sig { params(send: ::Spoom::Deadcode::Send).void }
+  def on_argument(send); end
+
+  sig { params(send: ::Spoom::Deadcode::Send).void }
+  def on_builds(send); end
+
+  sig { params(send: ::Spoom::Deadcode::Send).void }
+  def on_field(send); end
 end
 
+Spoom::Deadcode::Plugins::GraphQL::ARGUMENT_SYMBOL_OPTION_KEYS = T.let(T.unsafe(nil), Array)
+Spoom::Deadcode::Plugins::GraphQL::FIELD_SYMBOL_OPTION_KEYS = T.let(T.unsafe(nil), Array)
+
 class Spoom::Deadcode::Plugins::Minitest < ::Spoom::Deadcode::Plugins::Base
   sig { override.params(definition: ::Spoom::Model::Method).void }
   def on_define_method(definition); end
@@ -2551,6 +2572,8 @@ class Spoom::Printer
   def printt; end
 end
 
+module Spoom::PrismTypes; end
+Spoom::PrismTypes::AnyScopeNode = T.type_alias { T.any(::Prism::ClassNode, ::Prism::ModuleNode, ::Prism::SingletonClassNode) }
 module Spoom::RBS; end
 class Spoom::RBS::Annotation < ::Spoom::RBS::Comment; end
 
@@ -2590,7 +2613,20 @@ module Spoom::RBS::ExtractRBSComments
   def node_rbs_comments(node); end
 end
 
-class Spoom::RBS::Signature < ::Spoom::RBS::Comment; end
+class Spoom::RBS::Signature < ::Spoom::RBS::Comment
+  sig do
+    params(
+      string: ::String,
+      location: ::Prism::Location,
+      continuation_locations: T::Array[::Prism::Location]
+    ).void
+  end
+  def initialize(string, location, continuation_locations: T.unsafe(nil)); end
+
+  sig { returns(T::Array[::Prism::Location]) }
+  def continuation_locations; end
+end
+
 class Spoom::RBS::TypeAlias < ::Spoom::RBS::Comment; end
 Spoom::SPOOM_PATH = T.let(T.unsafe(nil), String)
 module Spoom::Sorbet; end
@@ -2854,8 +2890,15 @@ Spoom::Sorbet::Sigils::VALID_STRICTNESS = T.let(T.unsafe(nil), Array)
 
 module Spoom::Sorbet::Translate
   class << self
-    sig { params(ruby_contents: ::String, file: ::String, max_line_length: T.nilable(::Integer)).returns(::String) }
-    def rbs_comments_to_sorbet_sigs(ruby_contents, file:, max_line_length: T.unsafe(nil)); end
+    sig do
+      params(
+        ruby_contents: ::String,
+        file: ::String,
+        max_line_length: T.nilable(::Integer),
+        overloads_strategy: ::Symbol
+      ).returns(::String)
+    end
+    def rbs_comments_to_sorbet_sigs(ruby_contents, file:, max_line_length: T.unsafe(nil), overloads_strategy: T.unsafe(nil)); end
 
     sig do
       params(
@@ -2890,11 +2933,73 @@ end
 
 class Spoom::Sorbet::Translate::Error < ::Spoom::Error; end
 
-class Spoom::Sorbet::Translate::RBSCommentsToSorbetSigs < ::Spoom::Sorbet::Translate::Translator
+class Spoom::Sorbet::Translate::LandmarkFinder < ::Prism::Visitor
+  sig { void }
+  def initialize; end
+
+  sig { returns(T::Hash[::String, T::Array[::Integer]]) }
+  def landmarks; 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
+
+  sig { override.params(node: ::Prism::SourceLineNode).void }
+  def visit_source_line_node(node); end
+
+  private
+
+  sig { params(landmark_id: ::String, node: ::Prism::Node).void }
+  def record(landmark_id, node); end
+
+  class << self
+    sig { params(source: ::String).returns(T::Hash[::String, T::Array[::Integer]]) }
+    def find_landmarks_in(source); end
+  end
+end
+
+module Spoom::Sorbet::Translate::RBSCommentsToSorbetSigs
+  class << self
+    sig { params(source: ::String).returns(T::Boolean) }
+    def contains_rbs_syntax?(source); end
+
+    sig do
+      params(
+        ruby_contents: ::String,
+        file: ::String,
+        max_line_length: T.nilable(::Integer),
+        overloads_strategy: ::Symbol
+      ).returns(::String)
+    end
+    def rewrite_if_needed(ruby_contents, file:, max_line_length: T.unsafe(nil), overloads_strategy: T.unsafe(nil)); end
+  end
+end
+
+class Spoom::Sorbet::Translate::RBSCommentsToSorbetSigs::BaseRBIFormat
+  abstract!
+end
+
+class Spoom::Sorbet::Translate::RBSCommentsToSorbetSigs::BaseTranslator < ::Spoom::Sorbet::Translate::Translator
   include ::Spoom::RBS::ExtractRBSComments
 
-  sig { params(ruby_contents: ::String, file: ::String, max_line_length: T.nilable(::Integer)).void }
-  def initialize(ruby_contents, file:, max_line_length: T.unsafe(nil)); end
+  abstract!
+
+  sig do
+    params(
+      ruby_contents: ::String,
+      file: ::String,
+      options: ::Spoom::Sorbet::Translate::RBSCommentsToSorbetSigs::Options
+    ).void
+  end
+  def initialize(ruby_contents, file:, options: T.unsafe(nil)); end
 
   sig { override.params(node: ::Prism::CallNode).void }
   def visit_call_node(node); end
@@ -2924,35 +3029,201 @@ class Spoom::Sorbet::Translate::RBSCommentsToSorbetSigs < ::Spoom::Sorbet::Trans
   end
   def already_extends?(node, constant_regex); end
 
+  sig do
+    abstract
+      .params(
+        annotation: ::Spoom::RBS::Annotation,
+        parent_node: T.any(::Prism::ClassNode, ::Prism::ModuleNode, ::Prism::SingletonClassNode),
+        insert_pos: ::Integer,
+        sorbet_replacement: T.nilable(::String)
+      ).void
+  end
+  def apply_class_annotation(annotation, parent_node:, insert_pos:, sorbet_replacement:); 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::Annotation], sig: ::RBI::Sig).void }
+  sig do
+    params(
+      annotations: T::Array[::Spoom::RBS::Annotation],
+      sig: ::RBI::Sig
+    ).returns(T::Array[::Spoom::RBS::Annotation])
+  end
   def apply_member_annotations(annotations, sig); end
 
+  sig do
+    params(
+      signatures: T::Array[::Spoom::RBS::Signature],
+      method_name: ::String,
+      location: ::String
+    ).returns(T::Array[::Spoom::RBS::Signature])
+  end
+  def apply_overloads_strategy(signatures, method_name:, location:); end
+
   sig { params(comments: T::Array[::Prism::Comment]).void }
   def apply_type_aliases(comments); end
 
   sig { params(comments: T::Array[::Prism::Comment]).returns(T::Array[::Spoom::RBS::TypeAlias]) }
   def collect_type_aliases(comments); end
 
+  sig do
+    abstract
+      .params(
+        mixin_name: ::String,
+        into: T.any(::Prism::ClassNode, ::Prism::ModuleNode, ::Prism::SingletonClassNode),
+        at: ::Integer
+      ).void
+  end
+  def extend_with(mixin_name, into:, at:); end
+
+  sig do
+    abstract
+      .params(
+        type_member: ::String,
+        parent_node: T.any(::Prism::ClassNode, ::Prism::ModuleNode, ::Prism::SingletonClassNode),
+        insert_pos: ::Integer
+      ).void
+  end
+  def insert_type_member(type_member, parent_node:, insert_pos:); end
+
+  sig { overridable.params(of: ::String, to_height_of: ::Spoom::RBS::Comment).returns(::String) }
+  def pad_out_line_count(of:, to_height_of:); end
+
+  sig { overridable.params(annotation: ::Spoom::RBS::Annotation, is_known: T::Boolean).void }
+  def rewrite_annotation(annotation, is_known:); end
+
   sig { params(def_node: ::Prism::DefNode, comments: ::Spoom::RBS::Comments).void }
   def rewrite_def(def_node, comments); end
 
+  sig { abstract.params(signature: ::Spoom::RBS::Signature).void }
+  def rewrite_discarded_overload(signature); end
+
+  sig { params(annotations: T::Array[::Spoom::RBS::Annotation], known: T::Array[::Spoom::RBS::Annotation]).void }
+  def rewrite_member_annotations(annotations, known:); end
+
+  sig { abstract.params(signature: ::Spoom::RBS::Signature, type_params: T::Array[::RBS::AST::TypeParam]).void }
+  def rewrite_type_params_signature(signature, type_params:); end
+
   sig { params(node: ::Prism::CallNode).void }
   def visit_attr(node); end
+end
+
+class Spoom::Sorbet::Translate::RBSCommentsToSorbetSigs::HumanReadableRBIFormat < ::Spoom::Sorbet::Translate::RBSCommentsToSorbetSigs::BaseRBIFormat
+  sig { params(max_line_length: T.nilable(::Integer)).void }
+  def initialize(max_line_length: T.unsafe(nil)); end
+
+  sig { returns(T.nilable(::Integer)) }
+  def max_line_length; end
 
   class << self
-    sig { params(source: ::String).returns(T::Boolean) }
-    def contains_rbs_syntax?(source); end
+    sig { returns(::Spoom::Sorbet::Translate::RBSCommentsToSorbetSigs::HumanReadableRBIFormat) }
+    def default; end
+  end
+end
+
+class Spoom::Sorbet::Translate::RBSCommentsToSorbetSigs::HumanReadableTranslator < ::Spoom::Sorbet::Translate::RBSCommentsToSorbetSigs::BaseTranslator
+  private
+
+  sig do
+    override
+      .params(
+        annotation: ::Spoom::RBS::Annotation,
+        parent_node: T.any(::Prism::ClassNode, ::Prism::ModuleNode, ::Prism::SingletonClassNode),
+        insert_pos: ::Integer,
+        sorbet_replacement: T.nilable(::String)
+      ).void
+  end
+  def apply_class_annotation(annotation, parent_node:, insert_pos:, sorbet_replacement:); end
+
+  sig { override.params(mixin_name: ::String, into: ::Prism::Node, at: ::Integer).void }
+  def extend_with(mixin_name, into:, at:); end
+
+  sig do
+    override
+      .params(
+        type_member: ::String,
+        parent_node: T.any(::Prism::ClassNode, ::Prism::ModuleNode, ::Prism::SingletonClassNode),
+        insert_pos: ::Integer
+      ).void
+  end
+  def insert_type_member(type_member, parent_node:, insert_pos:); end
+
+  sig { override.params(signature: ::Spoom::RBS::Signature).void }
+  def rewrite_discarded_overload(signature); end
+
+  sig { override.params(signature: ::Spoom::RBS::Signature, type_params: T::Array[::RBS::AST::TypeParam]).void }
+  def rewrite_type_params_signature(signature, type_params:); end
+end
+
+class Spoom::Sorbet::Translate::RBSCommentsToSorbetSigs::LineMatchedRBIFormat < ::Spoom::Sorbet::Translate::RBSCommentsToSorbetSigs::BaseRBIFormat
+  class << self
+    sig { returns(::Spoom::Sorbet::Translate::RBSCommentsToSorbetSigs::LineMatchedRBIFormat) }
+    def default; end
+  end
+end
+
+class Spoom::Sorbet::Translate::RBSCommentsToSorbetSigs::LineMatchingTranslator < ::Spoom::Sorbet::Translate::RBSCommentsToSorbetSigs::BaseTranslator
+  private
+
+  sig do
+    override
+      .params(
+        annotation: ::Spoom::RBS::Annotation,
+        parent_node: T.any(::Prism::ClassNode, ::Prism::ModuleNode, ::Prism::SingletonClassNode),
+        insert_pos: ::Integer,
+        sorbet_replacement: T.nilable(::String)
+      ).void
+  end
+  def apply_class_annotation(annotation, parent_node:, insert_pos:, sorbet_replacement:); end
+
+  sig { override.params(mixin_name: ::String, into: ::Prism::Node, at: ::Integer).void }
+  def extend_with(mixin_name, into:, at:); end
+
+  sig do
+    override
+      .params(
+        type_member: ::String,
+        parent_node: T.any(::Prism::ClassNode, ::Prism::ModuleNode, ::Prism::SingletonClassNode),
+        insert_pos: ::Integer
+      ).void
+  end
+  def insert_type_member(type_member, parent_node:, insert_pos:); end
+
+  sig { override.params(of: ::String, to_height_of: ::Spoom::RBS::Comment).returns(::String) }
+  def pad_out_line_count(of:, to_height_of:); end
+
+  sig { override.params(annotation: ::Spoom::RBS::Annotation, is_known: T::Boolean).void }
+  def rewrite_annotation(annotation, is_known:); end
 
-    sig { params(ruby_contents: ::String, file: ::String, max_line_length: T.nilable(::Integer)).returns(::String) }
-    def rewrite_if_needed(ruby_contents, file:, max_line_length: T.unsafe(nil)); end
+  sig { override.params(signature: ::Spoom::RBS::Signature).void }
+  def rewrite_discarded_overload(signature); end
+
+  sig { override.params(signature: ::Spoom::RBS::Signature, type_params: T::Array[::RBS::AST::TypeParam]).void }
+  def rewrite_type_params_signature(signature, type_params:); end
+end
+
+class Spoom::Sorbet::Translate::RBSCommentsToSorbetSigs::Options
+  sig do
+    params(
+      overloads_strategy: ::Symbol,
+      output_format: ::Spoom::Sorbet::Translate::RBSCommentsToSorbetSigs::BaseRBIFormat
+    ).void
+  end
+  def initialize(overloads_strategy: T.unsafe(nil), output_format: T.unsafe(nil)); end
+
+  sig { returns(::Spoom::Sorbet::Translate::RBSCommentsToSorbetSigs::BaseRBIFormat) }
+  def output_format; end
+
+  sig { returns(::Symbol) }
+  def overloads_strategy; end
+
+  class << self
+    sig { returns(::Spoom::Sorbet::Translate::RBSCommentsToSorbetSigs::Options) }
+    def default; end
   end
 end
 
-Spoom::Sorbet::Translate::RBSCommentsToSorbetSigs::RBS_ANNOTATION_MARKERS = T.let(T.unsafe(nil), Array)
-Spoom::Sorbet::Translate::RBSCommentsToSorbetSigs::RBS_REWRITE_PATTERN = T.let(T.unsafe(nil), Regexp)
+Spoom::Sorbet::Translate::RBSCommentsToSorbetSigs::Options::ALLOWED_OVERLOAD_STRATEGIES = T.let(T.unsafe(nil), Array)
 
 class Spoom::Sorbet::Translate::SorbetAssertionsToRBSComments < ::Spoom::Sorbet::Translate::Translator
   sig do
@@ -3110,6 +3381,52 @@ class Spoom::Sorbet::Translate::Translator < ::Spoom::Visitor
   def sorbet_sig?(node); end
 end
 
+class Spoom::Sorbet::Translate::ValidationResult
+  sig do
+    params(
+      missing_from_rewritten_output: T::Array[{landmark_id: ::String, line: ::Integer}],
+      excess_in_rewritten_output: T::Array[{landmark_id: ::String, line: ::Integer}],
+      on_wrong_line: T::Array[{landmark_id: ::String, expected: T::Array[::Integer], actual: T::Array[::Integer]}]
+    ).void
+  end
+  def initialize(missing_from_rewritten_output:, excess_in_rewritten_output:, on_wrong_line:); end
+
+  sig { returns(T::Array[::String]) }
+  def errors; end
+
+  sig { returns(T::Array[{landmark_id: ::String, line: ::Integer}]) }
+  def excess_in_rewritten_output; end
+
+  sig { returns(T::Array[{landmark_id: ::String, line: ::Integer}]) }
+  def missing_from_rewritten_output; end
+
+  sig { returns(T::Array[{landmark_id: ::String, expected: T::Array[::Integer], actual: T::Array[::Integer]}]) }
+  def on_wrong_line; end
+
+  sig { params(printer: T.untyped).void }
+  def pretty_print(printer); end
+
+  sig { returns(T::Boolean) }
+  def valid?; end
+
+  private
+
+  sig { params(lines: T::Array[::Integer]).returns(::String) }
+  def format_lines(lines); end
+end
+
+Spoom::Sorbet::Translate::ValidationResult::LandmarkLocation = T.type_alias { {landmark_id: ::String, line: ::Integer} }
+Spoom::Sorbet::Translate::ValidationResult::MovedLandmark = T.type_alias { {landmark_id: ::String, expected: T::Array[::Integer], actual: T::Array[::Integer]} }
+
+module Spoom::Sorbet::Translate::Validator
+  class << self
+    sig { params(original: ::String, rewritten: ::String).returns(::Spoom::Sorbet::Translate::ValidationResult) }
+    def validate(original, rewritten); end
+  end
+end
+
+Spoom::Sorbet::Translate::Validator::LandmarkID = T.type_alias { ::String }
+Spoom::Sorbet::Translate::Validator::Landmarks = T.type_alias { T::Hash[::String, T::Array[::Integer]] }
 module Spoom::Source; end
 
 class Spoom::Source::Delete < ::Spoom::Source::Edit