spoom 1.7.2 → 1.7.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 59987238a3b2bae115f02d1da2a7e2a4cd6b3532d816bbe80d9153fa7819f989
-  data.tar.gz: d7e6bccfa046b7c457cb3e5d3d4383141243949021bd584b22cde0db0cc165ef
+  metadata.gz: c8447b66e12a52fef3147761f8331749ba52cebaaba146888a7ca35a253acdf9
+  data.tar.gz: d6a84c3091e71c56d26aceebb40f3a6486589266c0b9b984268bf32036b98a26
 SHA512:
-  metadata.gz: b2f53478b7fdee59bfa7c579c3686b6d6c388db8737584c02f613daa2c4d42c0be2c1baaa39c50e90137697f62d7b8bb04e9fdbb458defdfa7813be3b6cbbd36
-  data.tar.gz: 57b26d457d2235bedaff15c832accc34a9c5ffcb89876306394f12b74a87ce03964d0309cd62e213e9954607150968607227436ebeb522a84f27782f7cc8cac8
+  metadata.gz: 9827d000700721b1e30028eedcaf41c5e5e45811e1b62693dbaa2d859b5adf379c5f5da4acbaac8e0a0a78a8bb4928fbd5d8a395b5527a7c1f3fc0a72f207cc3
+  data.tar.gz: a7c46380dc2e26c622b8b96290964ede0b5f455d060a176d1336db3aa09ca3e7dbccb656d7a6c1451e43406b0e9cf7847b9a985418b905ae8114c20dae294240

data/Gemfile

@@ -5,6 +5,8 @@ source "https://rubygems.org"
 
 gemspec
 
+gem "minitest"
+
 group :development do
   gem "debug"
   gem "rubocop-shopify", require: false

data/lib/spoom/deadcode/plugins/active_job.rb

@@ -7,6 +7,25 @@ module Spoom
       class ActiveJob < Base
         ignore_classes_named("ApplicationJob")
         ignore_methods_named("perform", "build_enumerator", "each_iteration")
+
+        CALLBACKS = [
+          "after_enqueue",
+          "after_perform",
+          "around_enqueue",
+          "around_perform",
+          "before_enqueue",
+          "before_perform",
+        ].freeze
+
+        # @override
+        #: (Send send) -> void
+        def on_send(send)
+          return unless send.recv.nil? && CALLBACKS.include?(send.name)
+
+          send.each_arg(Prism::SymbolNode) do |arg|
+            @index.reference_method(arg.unescaped, send.location)
+          end
+        end
       end
     end
   end

data/lib/spoom/rbs.rb

@@ -4,7 +4,7 @@
 module Spoom
   module RBS
     class Comments
-      #: Array[Annotations]
+      #: Array[Annotation]
       attr_reader :annotations
 
       #: Array[Signature]
@@ -12,7 +12,7 @@ module Spoom
 
       #: -> void
       def initialize
-        @annotations = [] #: Array[Annotations]
+        @annotations = [] #: Array[Annotation]
         @signatures = [] #: Array[Signature]
       end
 
@@ -20,6 +20,32 @@ module Spoom
       def empty?
         @annotations.empty? && @signatures.empty?
       end
+
+      #: -> Array[Annotation]
+      def class_annotations
+        @annotations.select do |annotation|
+          case annotation.string
+          when "@abstract", "@interface", "@sealed", "@final"
+            true
+          when /^@requires_ancestor: /
+            true
+          else
+            false
+          end
+        end
+      end
+
+      #: -> Array[Annotation]
+      def method_annotations
+        @annotations.select do |annotation|
+          case annotation.string
+          when "@abstract", "@final", "@override", "@override(allow_incompatible: true)", "@overridable", "@without_runtime"
+            true
+          else
+            false
+          end
+        end
+      end
     end
 
     class Comment
@@ -36,7 +62,7 @@ module Spoom
       end
     end
 
-    class Annotations < Comment; end
+    class Annotation < Comment; end
     class Signature < Comment; end
 
     module ExtractRBSComments
@@ -54,7 +80,7 @@ module Spoom
 
           if string.start_with?("# @")
             string = string.delete_prefix("#").strip
-            res.annotations << Annotations.new(string, comment.location)
+            res.annotations << Annotation.new(string, comment.location)
           elsif string.start_with?("#: ")
             string = string.delete_prefix("#:").strip
             location = comment.location

data/lib/spoom/sorbet/metrics/code_metrics_visitor.rb

@@ -34,9 +34,6 @@ module Spoom
       class CodeMetricsVisitor < Spoom::Visitor
         include RBS::ExtractRBSComments
 
-        #: Counters
-        attr_reader :counters
-
         #: (Spoom::Counters) -> void
         def initialize(counters)
           super()

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

@@ -48,14 +48,14 @@ module Spoom
             translator = RBI::RBS::MethodTypeTranslator.new(rbi_node)
             translator.visit(method_type)
             sig = translator.result
-            apply_member_annotations(comments.annotations, sig)
+            apply_member_annotations(comments.method_annotations, sig)
 
             @rewriter << Source::Replace.new(
               signature.location.start_offset,
               signature.location.end_offset,
               sig.string,
             )
-          rescue ::RBS::ParsingError
+          rescue ::RBS::ParsingError, ::RBI::Error
             # Ignore signatures with errors
             next
           end
@@ -99,13 +99,16 @@ module Spoom
 
             sig.return_type = RBI::RBS::TypeTranslator.translate(attr_type)
 
-            apply_member_annotations(comments.annotations, sig)
+            apply_member_annotations(comments.method_annotations, sig)
 
             @rewriter << Source::Replace.new(
               signature.location.start_offset,
               signature.location.end_offset,
               sig.string,
             )
+          rescue ::RBS::ParsingError, ::RBI::Error
+            # Ignore signatures with errors
+            next
           end
         end
 
@@ -124,12 +127,13 @@ module Spoom
             node.expression.location.end_offset
           end
 
-          if comments.annotations.any?
+          class_annotations = comments.class_annotations
+          if class_annotations.any?
             unless already_extends?(node, /^(::)?T::Helpers$/)
               @rewriter << Source::Insert.new(insert_pos, "\n#{indent}extend T::Helpers\n")
             end
 
-            comments.annotations.reverse_each do |annotation|
+            class_annotations.reverse_each do |annotation|
               from = adjust_to_line_start(annotation.location.start_offset)
               to = adjust_to_line_end(annotation.location.end_offset)
 
@@ -154,6 +158,9 @@ module Spoom
 
               newline = node.body.nil? ? "" : "\n"
               @rewriter << Source::Insert.new(insert_pos, "\n#{indent}#{content}#{newline}")
+            rescue ::RBS::ParsingError, ::RBI::Error
+              # Ignore annotations with errors
+              next
             end
           end
 
@@ -195,12 +202,15 @@ module Spoom
 
                 newline = node.body.nil? ? "" : "\n"
                 @rewriter << Source::Insert.new(insert_pos, "\n#{indent}#{type_member}#{newline}")
+              rescue ::RBS::ParsingError, ::RBI::Error
+                # Ignore signatures with errors
+                next
               end
             end
           end
         end
 
-        #: (Array[RBS::Annotations], RBI::Sig) -> void
+        #: (Array[RBS::Annotation], RBI::Sig) -> void
         def apply_member_annotations(annotations, sig)
           annotations.each do |annotation|
             case annotation.string

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

@@ -9,22 +9,75 @@ module Spoom
         LINE_BREAK = "\n".ord #: Integer
 
         # @override
-        #: (Prism::CallNode) -> void
-        def visit_call_node(node)
-          return super unless t_annotation?(node)
-          return super unless at_end_of_line?(node)
+        #: (Prism::StatementsNode) -> void
+        def visit_statements_node(node)
+          node.body.each do |statement|
+            translated = maybe_translate_assertion(statement)
+            visit(statement) unless translated
+          end
+        end
+
+        # @override
+        #: (Prism::IfNode) -> void
+        def visit_if_node(node)
+          if node.if_keyword_loc
+            # We do not translate assertions in ternary expressions to avoid altering the semantic of the code.
+            #
+            # For example:
+            # ```rb
+            # a = T.must(b) ? T.must(c) : T.must(d)
+            # ```
+            #
+            # would become
+            # ```rb
+            # a = T.must(b) ? T.must(c) : d #: !nil
+            # ```
+            #
+            # which does not match the original intent.
+            super
+          end
+        end
+
+        private
+
+        #: (Prism::Node) -> bool
+        def maybe_translate_assertion(node)
+          node = case node
+          when Prism::MultiWriteNode,
+               Prism::ClassVariableWriteNode, Prism::ClassVariableAndWriteNode, Prism::ClassVariableOperatorWriteNode, Prism::ClassVariableOrWriteNode,
+               Prism::ConstantWriteNode, Prism::ConstantAndWriteNode, Prism::ConstantOperatorWriteNode, Prism::ConstantOrWriteNode,
+               Prism::ConstantPathWriteNode, Prism::ConstantPathAndWriteNode, Prism::ConstantPathOperatorWriteNode, Prism::ConstantPathOrWriteNode,
+               Prism::GlobalVariableWriteNode, Prism::GlobalVariableAndWriteNode, Prism::GlobalVariableOperatorWriteNode, Prism::GlobalVariableOrWriteNode,
+               Prism::InstanceVariableWriteNode, Prism::InstanceVariableAndWriteNode, Prism::InstanceVariableOperatorWriteNode, Prism::InstanceVariableOrWriteNode,
+               Prism::LocalVariableWriteNode, Prism::LocalVariableAndWriteNode, Prism::LocalVariableOperatorWriteNode, Prism::LocalVariableOrWriteNode,
+               Prism::CallAndWriteNode, Prism::CallOperatorWriteNode, Prism::CallOrWriteNode
+            node.value
+          when Prism::CallNode
+            node
+          else
+            return false
+          end
+
+          return false unless node.is_a?(Prism::CallNode)
+          return false unless t_annotation?(node)
+          return false unless at_end_of_line?(node)
 
           value = T.must(node.arguments&.arguments&.first)
           rbs_annotation = build_rbs_annotation(node)
 
           start_offset = node.location.start_offset
           end_offset = node.location.end_offset
-          @rewriter << Source::Replace.new(start_offset, end_offset - 1, "#{dedent_value(node, value)} #{rbs_annotation}")
-        end
 
-        private
+          @rewriter << if node.name == :bind
+            Source::Replace.new(start_offset, end_offset - 1, rbs_annotation)
+          else
+            Source::Replace.new(start_offset, end_offset - 1, "#{dedent_value(node, value)} #{rbs_annotation}")
+          end
+
+          true
+        end
 
-        #: (Prism::CallNode) -> void
+        #: (Prism::CallNode) -> String
         def build_rbs_annotation(call)
           case call.name
           when :let
@@ -35,6 +88,10 @@ module Spoom
             srb_type = call.arguments&.arguments&.last #: as !nil
             rbs_type = RBI::Type.parse_node(srb_type).rbs_string
             "#: as #{rbs_type}"
+          when :bind
+            srb_type = call.arguments&.arguments&.last #: as !nil
+            rbs_type = RBI::Type.parse_node(srb_type).rbs_string
+            "#: self as #{rbs_type}"
           when :must
             "#: as !nil"
           when :unsafe
@@ -65,6 +122,8 @@ module Spoom
           case node.name
           when :let, :cast
             return node.arguments&.arguments&.size == 2
+          when :bind
+            return node.arguments&.arguments&.size == 2 && node.arguments&.arguments&.first.is_a?(Prism::SelfNode)
           when :must, :unsafe
             return node.arguments&.arguments&.size == 1
           end

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

@@ -12,9 +12,12 @@ module Spoom
           super(ruby_contents, file: file)
 
           @positional_names = positional_names #: bool
-          @nesting = [] #: Array[Prism::ClassNode | Prism::ModuleNode | Prism::SingletonClassNode]
           @last_sigs = [] #: Array[[Prism::CallNode, RBI::Sig]]
+          @class_annotations = [] #: Array[Prism::CallNode]
           @type_members = [] #: Array[String]
+          @extend_t_helpers = [] #: Array[Prism::CallNode]
+          @extend_t_generics = [] #: Array[Prism::CallNode]
+          @seen_mixes_in_class_methods = false #: bool
         end
 
         # @override
@@ -38,17 +41,18 @@ module Spoom
         # @override
         #: (Prism::DefNode) -> void
         def visit_def_node(node)
-          return if @last_sigs.empty?
-          return if @last_sigs.any? { |_, sig| sig.is_abstract }
+          last_sigs = collect_last_sigs
+          return if last_sigs.empty?
+          return if last_sigs.any? { |_, sig| sig.is_abstract }
 
-          apply_member_annotations(@last_sigs)
+          apply_member_annotations(last_sigs)
 
           # Build the RBI::Method node so we can print the method signature as RBS.
           builder = RBI::Parser::TreeBuilder.new(@ruby_contents, comments: [], file: @file)
           builder.visit(node)
           rbi_node = builder.tree.nodes.first #: as RBI::Method
 
-          @last_sigs.each do |node, sig|
+          last_sigs.each do |node, sig|
             out = StringIO.new
             p = RBI::RBSPrinter.new(out: out, indent: node.location.start_column, positional_names: @positional_names)
             p.print("#: ")
@@ -56,8 +60,6 @@ module Spoom
             p.print("\n")
             @rewriter << Source::Replace.new(node.location.start_offset, node.location.end_offset, out.string)
           end
-
-          @last_sigs.clear
         end
 
         # @override
@@ -71,7 +73,9 @@ module Spoom
           when "extend"
             visit_extend(node)
           when "abstract!", "interface!", "sealed!", "final!", "requires_ancestor"
-            visit_class_annotation(node)
+            @class_annotations << node
+          when "mixes_in_class_methods"
+            @seen_mixes_in_class_methods = true
           else
             super
           end
@@ -97,19 +101,39 @@ module Spoom
 
         #: (Prism::ClassNode | Prism::ModuleNode | Prism::SingletonClassNode) { -> void } -> void
         def visit_scope(node, &block)
-          @nesting << node
+          old_class_annotations = @class_annotations
+          @class_annotations = []
           old_type_members = @type_members
           @type_members = []
+          old_extend_t_helpers = @extend_t_helpers
+          @extend_t_helpers = []
+          old_extend_t_generics = @extend_t_generics
+          @extend_t_generics = []
+          old_seen_mixes_in_class_methods = @seen_mixes_in_class_methods
+          @seen_mixes_in_class_methods = false
 
           yield
 
+          delete_extend_t_generics
+
           if @type_members.any?
             indent = " " * node.location.start_column
             @rewriter << Source::Insert.new(node.location.start_offset, "#: [#{@type_members.join(", ")}]\n#{indent}")
           end
 
+          unless @seen_mixes_in_class_methods
+            delete_extend_t_helpers
+          end
+
+          @class_annotations.each do |call|
+            apply_class_annotation(node, call)
+          end
+
+          @class_annotations = old_class_annotations
           @type_members = old_type_members
-          @nesting.pop
+          @extend_t_helpers = old_extend_t_helpers
+          @extend_t_generics = old_extend_t_generics
+          @seen_mixes_in_class_methods = old_seen_mixes_in_class_methods
         end
 
         #: (Prism::CallNode) -> void
@@ -130,16 +154,17 @@ module Spoom
             raise Error, "Expected attr_reader, attr_writer, or attr_accessor"
           end
 
-          return if @last_sigs.empty?
-          return if @last_sigs.any? { |_, sig| sig.is_abstract }
+          last_sigs = collect_last_sigs
+          return if last_sigs.empty?
+          return if last_sigs.any? { |_, sig| sig.is_abstract }
 
-          apply_member_annotations(@last_sigs)
+          apply_member_annotations(last_sigs)
 
           builder = RBI::Parser::TreeBuilder.new(@ruby_contents, comments: [], file: @file)
           builder.visit(node)
           rbi_node = builder.tree.nodes.first #: as RBI::Attr
 
-          @last_sigs.each do |node, sig|
+          last_sigs.each do |node, sig|
             out = StringIO.new
             p = RBI::RBSPrinter.new(out: out, indent: node.location.start_column, positional_names: @positional_names)
             p.print("#: ")
@@ -147,8 +172,6 @@ module Spoom
             p.print("\n")
             @rewriter << Source::Replace.new(node.location.start_offset, node.location.end_offset, out.string)
           end
-
-          @last_sigs.clear
         end
 
         #: (Prism::CallNode node) -> void
@@ -160,16 +183,17 @@ module Spoom
 
           arg = node.arguments&.arguments&.first
           return unless arg.is_a?(Prism::ConstantPathNode)
-          return unless arg.slice.match?(/^(::)?T::Helpers$/) || arg.slice.match?(/^(::)?T::Generic$/)
 
-          from = adjust_to_line_start(node.location.start_offset)
-          to = adjust_to_line_end(node.location.end_offset)
-          to = adjust_to_new_line(to)
-          @rewriter << Source::Delete.new(from, to)
+          case arg.slice
+          when /^(::)?T::Helpers$/
+            @extend_t_helpers << node
+          when /^(::)?T::Generic$/
+            @extend_t_generics << node
+          end
         end
 
-        #: (Prism::CallNode node) -> void
-        def visit_class_annotation(node)
+        #: (Prism::ClassNode | Prism::ModuleNode | Prism::SingletonClassNode, Prism::CallNode) -> void
+        def apply_class_annotation(parent, node)
           unless node.message == "abstract!" || node.message == "interface!" || node.message == "sealed!" ||
               node.message == "final!" || node.message == "requires_ancestor"
             raise Error, "Expected abstract!, interface!, sealed!, final!, or requires_ancestor"
@@ -178,18 +202,17 @@ module Spoom
           return unless node.receiver.nil? || node.receiver.is_a?(Prism::SelfNode)
           return unless node.arguments.nil?
 
-          klass = @nesting.last #: as Prism::Node
-          indent = " " * klass.location.start_column
+          indent = " " * parent.location.start_column
 
           case node.message
           when "abstract!"
-            @rewriter << Source::Insert.new(klass.location.start_offset, "# @abstract\n#{indent}")
+            @rewriter << Source::Insert.new(parent.location.start_offset, "# @abstract\n#{indent}")
           when "interface!"
-            @rewriter << Source::Insert.new(klass.location.start_offset, "# @interface\n#{indent}")
+            @rewriter << Source::Insert.new(parent.location.start_offset, "# @interface\n#{indent}")
           when "sealed!"
-            @rewriter << Source::Insert.new(klass.location.start_offset, "# @sealed\n#{indent}")
+            @rewriter << Source::Insert.new(parent.location.start_offset, "# @sealed\n#{indent}")
           when "final!"
-            @rewriter << Source::Insert.new(klass.location.start_offset, "# @final\n#{indent}")
+            @rewriter << Source::Insert.new(parent.location.start_offset, "# @final\n#{indent}")
           when "requires_ancestor"
             block = node.block
             return unless block.is_a?(Prism::BlockNode)
@@ -200,7 +223,7 @@ module Spoom
 
             arg = body.body.first #: as Prism::Node
             srb_type = RBI::Type.parse_node(arg)
-            @rewriter << Source::Insert.new(klass.location.start_offset, "# @requires_ancestor: #{srb_type.rbs_string}\n#{indent}")
+            @rewriter << Source::Insert.new(parent.location.start_offset, "# @requires_ancestor: #{srb_type.rbs_string}\n#{indent}")
           end
 
           from = adjust_to_line_start(node.location.start_offset)
@@ -287,6 +310,38 @@ module Spoom
 
           type_member
         end
+
+        #: -> void
+        def delete_extend_t_helpers
+          @extend_t_helpers.each do |helper|
+            from = adjust_to_line_start(helper.location.start_offset)
+            to = adjust_to_line_end(helper.location.end_offset)
+            to = adjust_to_new_line(to)
+            @rewriter << Source::Delete.new(from, to)
+          end
+
+          @extend_t_helpers.clear
+        end
+
+        #: -> void
+        def delete_extend_t_generics
+          @extend_t_generics.each do |generic|
+            from = adjust_to_line_start(generic.location.start_offset)
+            to = adjust_to_line_end(generic.location.end_offset)
+            to = adjust_to_new_line(to)
+            @rewriter << Source::Delete.new(from, to)
+          end
+
+          @extend_t_generics.clear
+        end
+
+        # Collects the last signatures visited and clears the current list
+        #: -> Array[[Prism::CallNode, RBI::Sig]]
+        def collect_last_sigs
+          last_sigs = @last_sigs
+          @last_sigs = []
+          last_sigs
+        end
       end
     end
   end

data/lib/spoom/source/rewriter.rb

@@ -158,7 +158,10 @@ module Spoom
       def rewrite!(bytes)
         # To avoid remapping positions after each edit,
         # we sort the changes by position and apply them in reverse order.
-        @edits.sort_by(&:range).reverse_each do |edit|
+        # When ranges are equal, preserve the original order
+        @edits.each_with_index.sort_by do |(edit, idx)|
+          [edit.range, idx]
+        end.reverse_each do |(edit, _)|
           edit.apply(bytes)
         end
       end

data/lib/spoom/version.rb

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

data/rbi/spoom.rbi

@@ -432,6 +432,12 @@ module Spoom::Context::Sorbet
 end
 
 class Spoom::Counters < ::Hash
+  extend T::Generic
+
+  K = type_member { { fixed: String } }
+  V = type_member { { fixed: Integer } }
+  Elem = type_member { { fixed: [String, Integer] } }
+
   sig { void }
   def initialize; end
 
@@ -645,10 +651,6 @@ class Spoom::Coverage::D3::ColorPalette < ::T::Struct
   prop :true, ::String
   prop :strict, ::String
   prop :strong, ::String
-
-  class << self
-    def inherited(s); end
-  end
 end
 
 class Spoom::Coverage::D3::Pie < ::Spoom::Coverage::D3::Base
@@ -899,8 +901,6 @@ class Spoom::Coverage::Snapshot < ::T::Struct
 
     sig { params(obj: T::Hash[::String, T.untyped]).returns(::Spoom::Coverage::Snapshot) }
     def from_obj(obj); end
-
-    def inherited(s); end
   end
 end
 
@@ -990,10 +990,6 @@ class Spoom::Deadcode::Definition < ::T::Struct
 
   sig { params(args: T.untyped).returns(::String) }
   def to_json(*args); end
-
-  class << self
-    def inherited(s); end
-  end
 end
 
 class Spoom::Deadcode::Definition::Kind < ::T::Enum
@@ -1136,7 +1132,13 @@ class Spoom::Deadcode::Plugins::ActionPack < ::Spoom::Deadcode::Plugins::Base
 end
 
 Spoom::Deadcode::Plugins::ActionPack::CALLBACKS = T.let(T.unsafe(nil), Array)
-class Spoom::Deadcode::Plugins::ActiveJob < ::Spoom::Deadcode::Plugins::Base; end
+
+class Spoom::Deadcode::Plugins::ActiveJob < ::Spoom::Deadcode::Plugins::Base
+  sig { override.params(send: ::Spoom::Deadcode::Send).void }
+  def on_send(send); end
+end
+
+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 }
@@ -1521,10 +1523,6 @@ class Spoom::Deadcode::Send < ::T::Struct
 
   sig { params(block: T.proc.params(key: ::Prism::Node, value: T.nilable(::Prism::Node)).void).void }
   def each_arg_assoc(&block); end
-
-  class << self
-    def inherited(s); end
-  end
 end
 
 class Spoom::Error < ::StandardError; end
@@ -1537,10 +1535,6 @@ class Spoom::ExecResult < ::T::Struct
 
   sig { returns(::String) }
   def to_s; end
-
-  class << self
-    def inherited(s); end
-  end
 end
 
 class Spoom::FileCollector
@@ -1660,10 +1654,6 @@ class Spoom::FileTree::Node < ::T::Struct
 
   sig { returns(::String) }
   def path; end
-
-  class << self
-    def inherited(s); end
-  end
 end
 
 class Spoom::FileTree::Printer < ::Spoom::FileTree::Visitor
@@ -1708,8 +1698,6 @@ class Spoom::Git::Commit < ::T::Struct
   def timestamp; end
 
   class << self
-    def inherited(s); end
-
     sig { params(string: ::String).returns(T.nilable(::Spoom::Git::Commit)) }
     def parse_line(string); end
   end
@@ -1788,8 +1776,6 @@ class Spoom::LSP::Diagnostic < ::T::Struct
   class << self
     sig { params(json: T::Hash[T.untyped, T.untyped]).returns(::Spoom::LSP::Diagnostic) }
     def from_json(json); end
-
-    def inherited(s); end
   end
 end
 
@@ -1815,8 +1801,6 @@ class Spoom::LSP::DocumentSymbol < ::T::Struct
   class << self
     sig { params(json: T::Hash[T.untyped, T.untyped]).returns(::Spoom::LSP::DocumentSymbol) }
     def from_json(json); end
-
-    def inherited(s); end
   end
 end
 
@@ -1856,8 +1840,6 @@ class Spoom::LSP::Hover < ::T::Struct
   class << self
     sig { params(json: T::Hash[T.untyped, T.untyped]).returns(::Spoom::LSP::Hover) }
     def from_json(json); end
-
-    def inherited(s); end
   end
 end
 
@@ -1876,8 +1858,6 @@ class Spoom::LSP::Location < ::T::Struct
   class << self
     sig { params(json: T::Hash[T.untyped, T.untyped]).returns(::Spoom::LSP::Location) }
     def from_json(json); end
-
-    def inherited(s); end
   end
 end
 
@@ -1918,8 +1898,6 @@ class Spoom::LSP::Position < ::T::Struct
   class << self
     sig { params(json: T::Hash[T.untyped, T.untyped]).returns(::Spoom::LSP::Position) }
     def from_json(json); end
-
-    def inherited(s); end
   end
 end
 
@@ -1945,8 +1923,6 @@ class Spoom::LSP::Range < ::T::Struct
   class << self
     sig { params(json: T::Hash[T.untyped, T.untyped]).returns(::Spoom::LSP::Range) }
     def from_json(json); end
-
-    def inherited(s); end
   end
 end
 
@@ -1993,8 +1969,6 @@ class Spoom::LSP::SignatureHelp < ::T::Struct
   class << self
     sig { params(json: T::Hash[T.untyped, T.untyped]).returns(::Spoom::LSP::SignatureHelp) }
     def from_json(json); end
-
-    def inherited(s); end
   end
 end
 
@@ -2291,8 +2265,6 @@ class Spoom::Model::Reference < ::T::Struct
     sig { params(name: ::String, location: ::Spoom::Location).returns(::Spoom::Model::Reference) }
     def constant(name, location); end
 
-    def inherited(s); end
-
     sig { params(name: ::String, location: ::Spoom::Location).returns(::Spoom::Model::Reference) }
     def method(name, location); end
   end
@@ -2465,25 +2437,29 @@ 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: T.untyped).returns(Spoom::Poset::Element[T.untyped]) }
+  sig { params(value: E).returns(Spoom::Poset::Element[E]) }
   def [](value); end
 
-  sig { params(from: T.untyped, to: T.untyped).void }
+  sig { params(from: E, to: E).void }
   def add_direct_edge(from, to); end
 
-  sig { params(value: T.untyped).returns(Spoom::Poset::Element[T.untyped]) }
+  sig { params(value: E).returns(Spoom::Poset::Element[E]) }
   def add_element(value); end
 
-  sig { params(from: T.untyped, to: T.untyped).returns(T::Boolean) }
+  sig { params(from: E, to: E).returns(T::Boolean) }
   def direct_edge?(from, to); end
 
-  sig { params(from: T.untyped, to: T.untyped).returns(T::Boolean) }
+  sig { params(from: E, to: E).returns(T::Boolean) }
   def edge?(from, to); end
 
-  sig { params(value: T.untyped).returns(T::Boolean) }
+  sig { params(value: E).returns(T::Boolean) }
   def element?(value); end
 
   sig { params(direct: T::Boolean, transitive: T::Boolean).void }
@@ -2494,36 +2470,39 @@ class Spoom::Poset
 end
 
 class Spoom::Poset::Element
+  extend T::Generic
   include ::Comparable
 
-  sig { params(value: T.untyped).void }
+  E = type_member { { upper: Object } }
+
+  sig { params(value: E).void }
   def initialize(value); end
 
   sig { params(other: T.untyped).returns(T.nilable(::Integer)) }
   def <=>(other); end
 
-  sig { returns(T::Array[T.untyped]) }
+  sig { returns(T::Array[E]) }
   def ancestors; end
 
-  sig { returns(T::Array[T.untyped]) }
+  sig { returns(T::Array[E]) }
   def children; end
 
-  sig { returns(T::Array[T.untyped]) }
+  sig { returns(T::Array[E]) }
   def descendants; end
 
   def dfroms; end
 
-  sig { returns(T::Set[Spoom::Poset::Element[T.untyped]]) }
+  sig { returns(T::Set[Spoom::Poset::Element[E]]) }
   def dtos; end
 
   def froms; end
 
-  sig { returns(T::Array[T.untyped]) }
+  sig { returns(T::Array[E]) }
   def parents; end
 
   def tos; end
 
-  sig { returns(T.untyped) }
+  sig { returns(E) }
   def value; end
 end
 
@@ -2566,7 +2545,7 @@ class Spoom::Printer
 end
 
 module Spoom::RBS; end
-class Spoom::RBS::Annotations < ::Spoom::RBS::Comment; end
+class Spoom::RBS::Annotation < ::Spoom::RBS::Comment; end
 
 class Spoom::RBS::Comment
   sig { params(string: ::String, location: ::Prism::Location).void }
@@ -2583,12 +2562,18 @@ class Spoom::RBS::Comments
   sig { void }
   def initialize; end
 
-  sig { returns(T::Array[::Spoom::RBS::Annotations]) }
+  sig { returns(T::Array[::Spoom::RBS::Annotation]) }
   def annotations; end
 
+  sig { returns(T::Array[::Spoom::RBS::Annotation]) }
+  def class_annotations; end
+
   sig { returns(T::Boolean) }
   def empty?; end
 
+  sig { returns(T::Array[::Spoom::RBS::Annotation]) }
+  def method_annotations; end
+
   sig { returns(T::Array[::Spoom::RBS::Signature]) }
   def signatures; end
 end
@@ -2758,9 +2743,6 @@ class Spoom::Sorbet::Metrics::CodeMetricsVisitor < ::Spoom::Visitor
   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
 
@@ -2904,7 +2886,7 @@ class Spoom::Sorbet::Translate::RBSCommentsToSorbetSigs < ::Spoom::Sorbet::Trans
   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 }
+  sig { params(annotations: T::Array[::Spoom::RBS::Annotation], sig: ::RBI::Sig).void }
   def apply_member_annotations(annotations, sig); end
 
   sig { params(node: ::Prism::CallNode).void }
@@ -2912,20 +2894,26 @@ class Spoom::Sorbet::Translate::RBSCommentsToSorbetSigs < ::Spoom::Sorbet::Trans
 end
 
 class Spoom::Sorbet::Translate::SorbetAssertionsToRBSComments < ::Spoom::Sorbet::Translate::Translator
-  sig { override.params(node: ::Prism::CallNode).void }
-  def visit_call_node(node); end
+  sig { override.params(node: ::Prism::IfNode).void }
+  def visit_if_node(node); end
+
+  sig { override.params(node: ::Prism::StatementsNode).void }
+  def visit_statements_node(node); end
 
   private
 
   sig { params(node: ::Prism::Node).returns(T::Boolean) }
   def at_end_of_line?(node); end
 
-  sig { params(call: ::Prism::CallNode).void }
+  sig { params(call: ::Prism::CallNode).returns(::String) }
   def build_rbs_annotation(call); end
 
   sig { params(assign: ::Prism::Node, value: ::Prism::Node).returns(::String) }
   def dedent_value(assign, value); end
 
+  sig { params(node: ::Prism::Node).returns(T::Boolean) }
+  def maybe_translate_assertion(node); end
+
   sig { params(node: T.nilable(::Prism::Node)).returns(T::Boolean) }
   def t?(node); end
 
@@ -2959,17 +2947,31 @@ class Spoom::Sorbet::Translate::SorbetSigsToRBSComments < ::Spoom::Sorbet::Trans
 
   private
 
+  sig do
+    params(
+      parent: T.any(::Prism::ClassNode, ::Prism::ModuleNode, ::Prism::SingletonClassNode),
+      node: ::Prism::CallNode
+    ).void
+  end
+  def apply_class_annotation(parent, node); end
+
   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 { returns(T::Array[[::Prism::CallNode, ::RBI::Sig]]) }
+  def collect_last_sigs; end
+
+  sig { void }
+  def delete_extend_t_generics; end
+
+  sig { void }
+  def delete_extend_t_helpers; end
 
   sig { params(node: ::Prism::CallNode).void }
-  def visit_class_annotation(node); end
+  def visit_attr(node); end
 
   sig { params(node: ::Prism::CallNode).void }
   def visit_extend(node); end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: spoom
 version: !ruby/object:Gem::Version
-  version: 1.7.2
+  version: 1.7.3
 platform: ruby
 authors:
 - Alexandre Terrasa
@@ -23,20 +23,6 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: 2.2.10
-- !ruby/object:Gem::Dependency
-  name: minitest
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '5.0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '5.0'
 - !ruby/object:Gem::Dependency
   name: minitest-reporters
   requirement: !ruby/object:Gem::Requirement
@@ -57,14 +43,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 13.2.1
+        version: 13.3.0
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 13.2.1
+        version: 13.3.0
 - !ruby/object:Gem::Dependency
   name: erubi
   requirement: !ruby/object:Gem::Requirement