spoom 1.8.3 → 1.8.5

data/lib/spoom/backtrace_filter/minitest.rb

@@ -12,7 +12,7 @@ module Spoom
       #: (Array[String]? bt) -> Array[String]
       def filter(bt)
         super.select do |line|
-          SORBET_PATHS.none? { |path| line.include?(path) }
+          !SORBET_PATHS.intersect?(line)
         end
       end
     end

data/lib/spoom/cli/srb/bump.rb

@@ -135,6 +135,10 @@ module Spoom
           end
 
           if result.status
+            parse_result = Sorbet::Errors::Parser.parse_result(result.err, error_url_base: error_url_base)
+            parse_result.warnings.each do |warning|
+              say_error(warning, status: nil, nl: false)
+            end
             Sorbet::Sigils.change_sigil_in_files(files_to_bump, to) unless dry
             print_changes(files_to_bump, command: cmd, from: from, to: to, dry: dry, path: exec_path)
             exit(files_to_bump.empty?)
@@ -147,7 +151,11 @@ module Spoom
             exit(1)
           end
 
-          errors = Sorbet::Errors::Parser.parse_string(result.err, error_url_base: error_url_base)
+          parse_result = Sorbet::Errors::Parser.parse_result(result.err, error_url_base: error_url_base)
+          parse_result.warnings.each do |warning|
+            say_error(warning, status: nil, nl: false)
+          end
+          errors = parse_result.errors
 
           all_files = errors.flat_map do |err|
             [err.file, *err.files_from_error_sections]

data/lib/spoom/cli/srb/sigs.rb

@@ -17,11 +17,19 @@ module Spoom
           aliases: :p,
           desc: "Use positional names when translating from RBI to RBS",
           default: true
+        option :preserve_multiline_signatures,
+          type: :boolean,
+          desc: "Preserve multiline sig formatting when translating from RBI to RBS",
+          default: true
         option :include_rbi_files, type: :boolean, desc: "Include RBI files", default: false
         option :max_line_length, type: :numeric, desc: "Max line length (pass 0 to disable)", default: 120
         option :translate_generics, type: :boolean, desc: "Translate generics", default: false
         option :translate_helpers, type: :boolean, desc: "Translate helpers", default: false
         option :translate_abstract_methods, type: :boolean, desc: "Translate abstract methods", default: false
+        option :erase_generic_types,
+          type: :boolean,
+          desc: "Drop generic types when translating from RBS to RBI",
+          default: false
         def translate(*paths)
           from = options[:from]
           to = options[:to]
@@ -53,6 +61,7 @@ module Spoom
                 contents,
                 file: file,
                 positional_names: options[:positional_names],
+                preserve_multiline_signatures: options[:preserve_multiline_signatures],
                 max_line_length: max_line_length,
                 translate_generics: options[:translate_generics],
                 translate_helpers: options[:translate_helpers],
@@ -65,6 +74,7 @@ module Spoom
                 contents,
                 file: file,
                 max_line_length: max_line_length,
+                erase_generic_types: options[:erase_generic_types],
               )
             end
           end

data/lib/spoom/cli/srb/tc.rb

@@ -73,7 +73,11 @@ module Spoom
             exit(1)
           end
 
-          errors = Spoom::Sorbet::Errors::Parser.parse_string(result.err, error_url_base: error_url_base)
+          parse_result = Spoom::Sorbet::Errors::Parser.parse_result(result.err, error_url_base: error_url_base)
+          parse_result.warnings.each do |warning|
+            say_error(warning, status: nil, nl: false)
+          end
+          errors = parse_result.errors
           errors_count = errors.size
 
           errors = errors.select { |e| e.code == code } if code

data/lib/spoom/deadcode/erb.rb

@@ -40,6 +40,15 @@ module Spoom
         super
       end
 
+      #: -> String
+      def wrapped_src
+        <<~RUBY
+          def __spoom_deadcode_erb_template__
+            #{src}
+          end
+        RUBY
+      end
+
       private
 
       # @override
@@ -50,32 +59,34 @@ module Spoom
         if text == "\n"
           @newline_pending += 1
         else
-          src << bufvar << ".safe_append='"
-          src << "\n" * @newline_pending if @newline_pending > 0
-          src << text.gsub(/['\\]/, '\\\\\&')
-          src << "'.freeze;"
-
+          with_buffer do
+            src << ".safe_append='"
+            src << "\n" * @newline_pending if @newline_pending > 0
+            src << text.gsub(/['\\]/, '\\\\\&') << @text_end
+          end
           @newline_pending = 0
         end
       end
 
-      BLOCK_EXPR = /\s*((\s+|\))do|\{)(\s*\|[^|]*\|)?\s*\Z/
+      BLOCK_EXPR = /((\s|\))do|\{)(\s*\|[^|]*\|)?\s*\Z/
 
       # @override
       #: (untyped indicator, untyped code) -> void
       def add_expression(indicator, code)
         flush_newline_if_pending(src)
 
-        src << bufvar << if (indicator == "==") || @escape
-          ".safe_expr_append="
-        else
-          ".append="
-        end
+        with_buffer do
+          src << if (indicator == "==") || @escape
+            ".safe_expr_append="
+          else
+            ".append="
+          end
 
-        if BLOCK_EXPR.match?(code)
-          src << " " << code
-        else
-          src << "(" << code << ");"
+          if BLOCK_EXPR.match?(code)
+            src << " " << code
+          else
+            src << "(" << code << ")"
+          end
         end
       end
 
@@ -96,7 +107,7 @@ module Spoom
       #: (untyped src) -> void
       def flush_newline_if_pending(src)
         if @newline_pending > 0
-          src << bufvar << ".safe_append='#{"\n" * @newline_pending}'.freeze;"
+          with_buffer { src << ".safe_append='#{"\n" * @newline_pending}" << @text_end }
           @newline_pending = 0
         end
       end

data/lib/spoom/deadcode/index.rb

@@ -44,7 +44,7 @@ module Spoom
 
       #: (String erb, file: String, ?plugins: Array[Plugins::Base]) -> void
       def index_erb(erb, file:, plugins: [])
-        index_ruby(Deadcode::ERB.new(erb).src, file: file, plugins: plugins)
+        index_ruby(Deadcode::ERB.new(erb).wrapped_src, file: file, plugins: plugins)
       end
 
       #: (String rb, file: String, ?plugins: Array[Plugins::Base]) -> void
@@ -55,6 +55,11 @@ module Spoom
         model_builder = Model::Builder.new(@model, file)
         model_builder.visit(node)
 
+        # Ignore the special synthetic method generated by the ERB engine
+        if (spoom_erb_wrapper = @model.symbols["__spoom_deadcode_erb_template__"])
+          @ignored.merge(spoom_erb_wrapper.definitions)
+        end
+
         # Index references
         refs_visitor = Model::ReferencesVisitor.new(file)
         refs_visitor.visit(node)

data/lib/spoom/deadcode/remover.rb

@@ -117,6 +117,7 @@ module Spoom
                Prism::ConstantPathAndWriteNode, Prism::ConstantPathOrWriteNode
             # Nesting node is an assign, it means only one constant is assigned on the line
             # so we can remove the whole assign
+            remove_constant_visibility_call(context)
             delete_node_and_comments_and_sigs(context)
             return
           end
@@ -127,6 +128,7 @@ module Spoom
           if parent_node.is_a?(Prism::ConstantWriteNode)
             # Nesting node is an assign, it means only one constant is assigned on the line
             # so we can remove the whole assign
+            remove_constant_visibility_call(parent_context)
             delete_node_and_comments_and_sigs(parent_context)
             return
           elsif parent_node.is_a?(Prism::MultiWriteNode) && parent_node.lefts.size == 1
@@ -190,6 +192,64 @@ module Spoom
           end
         end
 
+        # A dead constant is often followed by a `private_constant`/`public_constant` call naming it.
+        # That call references the now-removed constant (a load-time `NameError` if left behind), so
+        # remove the reference too: delete the whole call when the constant is its only argument, or
+        # drop just that symbol when the call lists several constants.
+        #: (NodeContext context) -> void
+        def remove_constant_visibility_call(context)
+          node = context.node
+          return unless node.is_a?(Prism::ConstantWriteNode)
+
+          name = node.name
+          call = context.next_nodes.find { |sibling| constant_visibility_call?(sibling, name) }
+          return unless call.is_a?(Prism::CallNode)
+
+          call_context = NodeContext.new(@old_source, @node_context.comments, call, context.nesting)
+          arguments = call.arguments&.arguments #: Array[Prism::Node]?
+          if arguments && arguments.size > 1
+            delete_symbol_argument(call_context, name)
+          else
+            delete_node_and_comments_and_sigs(call_context)
+          end
+        end
+
+        # Whether `node` is a bare `private_constant`/`public_constant` call listing `name`.
+        #: (Prism::Node node, Symbol name) -> bool
+        def constant_visibility_call?(node, name)
+          return false unless node.is_a?(Prism::CallNode)
+          return false unless node.receiver.nil?
+          return false unless node.name == :private_constant || node.name == :public_constant
+
+          arguments = node.arguments&.arguments
+          return false unless arguments
+
+          arguments.any? { |argument| argument.is_a?(Prism::SymbolNode) && argument.value == name.to_s }
+        end
+
+        # Drop the `:name` symbol from a `private_constant`/`public_constant` call that lists several
+        # constants, keeping the call and the other names intact.
+        #: (NodeContext context, Symbol name) -> void
+        def delete_symbol_argument(context, name)
+          arguments = T.cast(context.node, Prism::CallNode).arguments&.arguments
+          return unless arguments
+
+          index = arguments.index { |argument| argument.is_a?(Prism::SymbolNode) && argument.value == name.to_s }
+          return unless index
+
+          argument = arguments.fetch(index)
+          prev_argument = arguments[index - 1] if index.positive?
+          next_argument = arguments[index + 1]
+
+          if prev_argument && next_argument
+            replace_chars(prev_argument.location.end_offset, next_argument.location.start_offset, ", ")
+          elsif prev_argument
+            delete_chars(prev_argument.location.end_offset, argument.location.end_offset)
+          elsif next_argument
+            delete_chars(argument.location.start_offset, next_argument.location.start_offset)
+          end
+        end
+
         #: (NodeContext context) -> void
         def delete_attr_accessor(context)
           args_context = context.parent_context

data/lib/spoom/sorbet/errors.rb

@@ -56,22 +56,35 @@ module Spoom
         ] #: Array[String]
 
         class << self
+          # Used when only Sorbet errors are needed and leading stderr warnings can be ignored.
           #: (String output, ?error_url_base: String) -> Array[Error]
           def parse_string(output, error_url_base: DEFAULT_ERROR_URL_BASE)
+            parse_result(output, error_url_base: error_url_base).errors
+          end
+
+          # Used when callers need both parsed Sorbet errors and leading stderr warnings.
+          #: (String output, ?error_url_base: String) -> ParseResult
+          def parse_result(output, error_url_base: DEFAULT_ERROR_URL_BASE)
             parser = Spoom::Sorbet::Errors::Parser.new(error_url_base: error_url_base)
-            parser.parse(output)
+            parser.parse_result(output)
           end
         end
 
         #: (?error_url_base: String) -> void
         def initialize(error_url_base: DEFAULT_ERROR_URL_BASE)
           @errors = [] #: Array[Error]
+          @warnings = [] #: Array[String]
           @error_line_match_regex = error_line_match_regexp(error_url_base) #: Regexp
           @current_error = nil #: Error?
         end
 
         #: (String output) -> Array[Error]
         def parse(output)
+          parse_result(output).errors
+        end
+
+        #: (String output) -> ParseResult
+        def parse_result(output)
           output.each_line do |line|
             break if /^No errors! Great job\./.match?(line)
             break if /^Errors: /.match?(line)
@@ -85,10 +98,14 @@ module Spoom
               next
             end
 
-            append_error(line) if @current_error
+            if @current_error
+              append_error(line)
+            else
+              append_warning(line)
+            end
           end
           close_error if @current_error
-          @errors
+          ParseResult.new(@errors, @warnings)
         end
 
         private
@@ -144,6 +161,11 @@ module Spoom
           end
           @current_error.more << line
         end
+
+        #: (String warning) -> void
+        def append_warning(warning)
+          @warnings << warning
+        end
       end
 
       class Error
@@ -214,6 +236,20 @@ module Spoom
           testcase_element
         end
       end
+
+      class ParseResult
+        #: Array[Error]
+        attr_reader :errors
+
+        #: Array[String]
+        attr_reader :warnings
+
+        #: (Array[Error] errors, Array[String] warnings) -> void
+        def initialize(errors, warnings)
+          @errors = errors
+          @warnings = warnings
+        end
+      end
     end
   end
 end

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

@@ -26,7 +26,8 @@ module Spoom
 
             @overloads_strategy = options.overloads_strategy #: Symbol
             @translate_abstract_methods = options.translate_abstract_methods #: bool
-            @type_translator = RBI::RBS::TypeTranslator.new #: RBI::RBS::TypeTranslator
+            @options = options #: Options
+            @type_translator = RBI::RBS::TypeTranslator.new(options: options.rbi_options) #: RBI::RBS::TypeTranslator
           end
 
           # @override
@@ -163,7 +164,7 @@ module Spoom
                 next
               end
 
-              translator = RBI::RBS::MethodTypeTranslator.new(rbi_node)
+              translator = RBI::RBS::MethodTypeTranslator.new(rbi_node, options: @options.rbi_options)
 
               begin
                 translator.visit(method_type)
@@ -273,6 +274,18 @@ module Spoom
                 rewrite_type_params_signature(signature, type_params:)
                 next if type_params.empty?
 
+                if @options.erase_generic_types
+                  type_params.each do |type_param|
+                    insert_type_member(
+                      "#{type_param.name} = ::T.type_alias { ::T.anything }",
+                      parent_node: node,
+                      insert_pos:,
+                    )
+                  end
+
+                  next
+                end
+
                 unless already_extends?(node, /^(::)?T::Generic$/)
                   extend_with("T::Generic", into: node, at: insert_pos)
                 end
@@ -462,7 +475,7 @@ module Spoom
               )
 
               @rewriter << Source::Delete.new(from, to)
-              content = "#{indent}#{alias_name} = T.type_alias { #{sorbet_type.to_rbi} }\n"
+              content = "#{indent}#{alias_name} = ::T.type_alias { #{sorbet_type.to_rbi} }\n"
               content = pad_out_line_count(of: content, to_height_of: type_alias)
               @rewriter << Source::Insert.new(insert_pos, content)
             rescue ::RBS::ParsingError, ::RBI::Error

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

@@ -44,6 +44,12 @@ module Spoom
 
           ALLOWED_OVERLOAD_STRATEGIES = [:translate_all, :translate_last, :raise].freeze
 
+          #: bool
+          attr_reader :erase_generic_types
+
+          #: RBI::RBS::MethodTypeTranslator::Options
+          attr_reader :rbi_options
+
           #: BaseRBIFormat
           attr_reader :output_format
 
@@ -52,11 +58,13 @@ module Spoom
 
           #: (
           #|   ?overloads_strategy: Symbol,
+          #|   ?erase_generic_types: bool,
           #|   ?output_format: BaseRBIFormat,
           #|   ?translate_abstract_methods: bool,
           #| ) -> void
           def initialize(
             overloads_strategy: :translate_all,
+            erase_generic_types: false,
             output_format: HumanReadableRBIFormat.default,
             translate_abstract_methods: true
           )
@@ -66,6 +74,8 @@ module Spoom
             end
 
             @overloads_strategy = overloads_strategy
+            @erase_generic_types = erase_generic_types
+            @rbi_options = RBI::RBS::MethodTypeTranslator::Options.new(erase_generic_types:) #: RBI::RBS::MethodTypeTranslator::Options
             @output_format = output_format
             @translate_abstract_methods = translate_abstract_methods
 

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

@@ -28,17 +28,20 @@ module Spoom
           #|   String ruby_contents,
           #|   file: String,
           #|   ?max_line_length: Integer?,
-          #|   ?overloads_strategy: Symbol) -> String
+          #|   ?overloads_strategy: Symbol,
+          #|   ?erase_generic_types: bool) -> String
           def rewrite_if_needed(
             ruby_contents,
             file:,
             max_line_length: nil,
-            overloads_strategy: :translate_all
+            overloads_strategy: :translate_all,
+            erase_generic_types: false
           )
             return ruby_contents unless contains_rbs_syntax?(ruby_contents)
 
             options = Options.new(
               overloads_strategy:,
+              erase_generic_types:,
               output_format: HumanReadableRBIFormat.new(
                 max_line_length:,
               ),

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

@@ -11,6 +11,7 @@ module Spoom
         #|   String,
         #|   file: String,
         #|   positional_names: bool,
+        #|   ?preserve_multiline_signatures: bool,
         #|   ?max_line_length: Integer?,
         #|   ?translate_generics: bool,
         #|   ?translate_helpers: bool,
@@ -20,6 +21,7 @@ module Spoom
           ruby_contents,
           file:,
           positional_names:,
+          preserve_multiline_signatures: true,
           max_line_length: nil,
           translate_generics: true,
           translate_helpers: true,
@@ -34,6 +36,8 @@ module Spoom
           @extend_t_helpers = [] #: Array[Prism::CallNode]
           @extend_t_generics = [] #: Array[Prism::CallNode]
           @seen_mixes_in_class_methods = false #: bool
+
+          @preserve_multiline_signatures = preserve_multiline_signatures
           @max_line_length = max_line_length #: Integer?
 
           @translate_generics = translate_generics #: bool
@@ -75,7 +79,12 @@ module Spoom
           last_sigs.each do |node, sig|
             next if sig.is_abstract && !@translate_abstract_methods
 
-            out = rbs_print(node.location.start_column) do |printer|
+            preserve_multiline_signatures = !!(@preserve_multiline_signatures && sig.loc&.multiline?)
+
+            out = rbs_print(
+              node.location.start_column,
+              preserve_multiline_signatures: preserve_multiline_signatures,
+            ) do |printer|
               printer.print_method_sig(rbi_node, sig)
             end
             @rewriter << Source::Replace.new(node.location.start_offset, node.location.end_offset, out)
@@ -180,7 +189,7 @@ module Spoom
           return unless sorbet_sig?(node)
 
           builder = RBI::Parser::SigBuilder.new(@ruby_contents, file: @file)
-          builder.current.loc = node.location
+          builder.current.loc = RBI::Loc.from_prism(@file, node.location)
           builder.visit_call_node(node)
           builder.current.comments = []
 
@@ -204,7 +213,7 @@ module Spoom
           rbi_node = builder.tree.nodes.first #: as RBI::Attr
 
           last_sigs.each do |node, sig|
-            out = rbs_print(node.location.start_column) do |printer|
+            out = rbs_print(node.location.start_column, preserve_multiline_signatures: false) do |printer|
               printer.print_attr_sig(rbi_node, sig)
             end
             @rewriter << Source::Replace.new(node.location.start_offset, node.location.end_offset, out)
@@ -387,10 +396,16 @@ module Spoom
           last_sigs
         end
 
-        #: (Integer) { (RBI::RBSPrinter) -> void } -> String
-        def rbs_print(indent, &block)
+        #: (Integer, preserve_multiline_signatures: bool) { (RBI::RBSPrinter) -> void } -> String
+        def rbs_print(indent, preserve_multiline_signatures:, &block)
           out = StringIO.new
-          p = RBI::RBSPrinter.new(out: out, positional_names: @positional_names, max_line_length: @max_line_length)
+
+          p = RBI::RBSPrinter.new(
+            out: out,
+            positional_names: @positional_names,
+            max_line_length: @max_line_length,
+            force_multiline_signatures: preserve_multiline_signatures,
+          )
           block.call(p)
           string = out.string
 

data/lib/spoom/sorbet/translate.rb

@@ -30,13 +30,17 @@ module Spoom
         #|   String,
         #|   file: String,
         #|   ?positional_names: bool,
+        #|   ?preserve_multiline_signatures: bool,
         #|   ?max_line_length: Integer?,
         #|   ?translate_generics: bool,
         #|   ?translate_helpers: bool,
         #|   ?translate_abstract_methods: bool
         #| ) -> String
         def sorbet_sigs_to_rbs_comments(
-          ruby_contents, file:, positional_names: true, max_line_length: nil,
+          ruby_contents, file:,
+          positional_names: true,
+          preserve_multiline_signatures: true,
+          max_line_length: nil,
           translate_generics: true,
           translate_helpers: true,
           translate_abstract_methods: true
@@ -45,6 +49,7 @@ module Spoom
             ruby_contents,
             file: file,
             positional_names: positional_names,
+            preserve_multiline_signatures: preserve_multiline_signatures,
             max_line_length: max_line_length,
             translate_generics: translate_generics,
             translate_helpers: translate_helpers,
@@ -54,13 +59,16 @@ 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?, ?overloads_strategy: Symbol) -> String
-        def rbs_comments_to_sorbet_sigs(ruby_contents, file:, max_line_length: nil, overloads_strategy: :translate_all)
+        #: (String ruby_contents, file: String, ?max_line_length: Integer?,
+        #| ?overloads_strategy: Symbol, ?erase_generic_types: bool) -> String
+        def rbs_comments_to_sorbet_sigs(ruby_contents, file:, max_line_length: nil, overloads_strategy: :translate_all,
+          erase_generic_types: false)
           RBSCommentsToSorbetSigs.rewrite_if_needed(
             ruby_contents,
             file: file,
             max_line_length: max_line_length,
             overloads_strategy: overloads_strategy,
+            erase_generic_types: erase_generic_types,
           )
         end
 

data/lib/spoom/version.rb

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