rubocop 1.53.0 → 1.90.0

data/lib/rubocop/cop/style/redundant_interpolation_unfreeze.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Before Ruby 3.0, interpolated strings followed the frozen string literal
+      # magic comment which sometimes made it necessary to explicitly unfreeze them.
+      # Ruby 3.0 changed interpolated strings to always be unfrozen which makes
+      # unfreezing them redundant.
+      #
+      # @example
+      #   # bad
+      #   +"#{foo} bar"
+      #
+      #   # bad
+      #   "#{foo} bar".dup
+      #
+      #   # bad
+      #   String.new("#{foo} bar")
+      #
+      #   # good
+      #   "#{foo} bar"
+      #
+      class RedundantInterpolationUnfreeze < Base
+        include FrozenStringLiteral
+        extend AutoCorrector
+        extend TargetRubyVersion
+
+        MSG = "Don't unfreeze interpolated strings as they are already unfrozen."
+
+        minimum_target_ruby_version 3.0
+
+        # @!method redundant_unfreeze?(node)
+        def_node_matcher :redundant_unfreeze?, <<~PATTERN
+          {
+            (send dstr_type? {:+@ :dup})
+            (send (const nil? :String) :new dstr_type?)
+          }
+        PATTERN
+
+        def on_dstr(node)
+          return if uninterpolated_string?(node) || uninterpolated_heredoc?(node)
+          return unless redundant_unfreeze?(node.parent)
+
+          add_offense(offense_range(node.parent)) do |corrector|
+            corrector.replace(node.parent, node.source)
+          end
+        end
+
+        private
+
+        def offense_range(node)
+          if node.method?(:new)
+            node.source_range.begin.join(node.loc.selector)
+          else
+            node.loc.selector
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/style/redundant_line_continuation.rb

@@ -3,12 +3,15 @@
 module RuboCop
   module Cop
     module Style
-      # Check for redundant line continuation.
+      # Checks for redundant line continuation.
       #
-      # This cop marks a line continuation as redundant if removing the backslash
-      # does not result in a syntax error.
-      # However, a backslash at the end of a comment or
-      # for string concatenation is not redundant and is not considered an offense.
+      # A line continuation is redundant when removing the backslash does not
+      # change how the program parses: the source is reparsed without the
+      # backslash and the resulting AST is compared to the original. Only
+      # backslashes that are pure noise are reported; backslashes that are
+      # significant — inside strings, for string concatenation, before an
+      # operator or argument that would otherwise start a new statement, and
+      # so on — are left alone, as are backslashes in comments.
       #
       # @example
       #   # bad
@@ -66,116 +69,133 @@ module RuboCop
       #
       class RedundantLineContinuation < Base
         include MatchRange
+        include ReparsedEquivalence
         extend AutoCorrector
 
         MSG = 'Redundant line continuation.'
-        ALLOWED_STRING_TOKENS = %i[tSTRING tSTRING_CONTENT].freeze
-        ARGUMENT_TYPES = %i[
-          kFALSE kNIL kSELF kTRUE tCONSTANT tCVAR tFLOAT tGVAR tIDENTIFIER tINTEGER tIVAR
-          tLBRACK tLCURLY tLPAREN_ARG tSTRING tSTRING_BEG tSYMBOL tXSTRING_BEG
-        ].freeze
+        LINE_CONTINUATION = '\\'
+        LINE_CONTINUATION_PATTERN = /(\\\n)/.freeze
+        STRING_TOKEN_TYPES = %i[tSTRING tSTRING_CONTENT].freeze
+        STRING_LITERAL_ENDING_TOKEN_TYPES = %i[tSTRING tSTRING_END].freeze
+        STRING_LITERAL_BEGINNING_TOKEN_TYPES = %i[tSTRING tSTRING_BEG].freeze
 
         def on_new_investigation
           return unless processed_source.ast
 
-          each_match_range(processed_source.ast.source_range, /(\\\n)/) do |range|
-            next if require_line_continuation?(range)
-            next unless redundant_line_continuation?(range)
-
+          # A backslash is redundant if the source parses to the same AST
+          # without it; verification is the offense logic itself, so oversized
+          # scopes are reparsed regardless of size.
+          verified_by_reparse(line_continuation_candidates, oversized: :verify).each do |range|
             add_offense(range) do |corrector|
               corrector.remove_leading(range, 1)
             end
           end
+
+          inspect_end_of_ruby_code_line_continuation
         end
 
         private
 
-        def require_line_continuation?(range)
-          !ends_with_backslash_without_comment?(range.source_line) ||
-            string_concatenation?(range.source_line) ||
-            start_with_arithmetic_operator?(processed_source[range.line]) ||
-            inside_string_literal_or_method_with_argument?(range)
+        def apply_reparse_correction(corrector, range)
+          corrector.remove_leading(range, 1)
         end
 
-        def ends_with_backslash_without_comment?(source_line)
-          source_line.gsub(/#.+/, '').end_with?('\\')
-        end
+        def line_continuation_candidates
+          candidates = []
 
-        def string_concatenation?(source_line)
-          /["']\s*\\\z/.match?(source_line)
+          each_match_range(processed_source.ast.source_range, LINE_CONTINUATION_PATTERN) do |range|
+            next if within_comment?(range) || implicit_string_concatenation?(range)
+            next if within_string_content?(range)
+            next if leading_dot_method_chain_with_blank_line?(range)
+
+            candidates << range
+          end
+
+          candidates
         end
 
-        def inside_string_literal_or_method_with_argument?(range)
-          processed_source.tokens.each_cons(2).any? do |token, next_token|
-            inside_string_literal?(range, token) || method_with_argument?(token, next_token)
+        def within_comment?(range)
+          processed_source.comments.any? do |comment|
+            comment.source_range.overlaps?(range)
           end
         end
 
-        def redundant_line_continuation?(range)
-          return true unless (node = find_node_for_line(range.line))
-          return false if argument_newline?(node)
+        # A backslash directly joining two string literals is never redundant:
+        # removing it moves the second literal onto its own logical line,
+        # severing the implicit string concatenation. Skipping these up front
+        # avoids reparse verification, which is prohibitively slow on generated
+        # files gluing thousands of string fragments with line continuations.
+        def implicit_string_concatenation?(range)
+          tokens = processed_source.sorted_tokens
 
-          source = node.parent ? node.parent.source : node.source
-          parse(source.gsub("\\\n", "\n")).valid_syntax?
-        end
+          token_before = last_token_before(tokens, range)
+          return false unless string_literal_ending_on_line?(token_before, range.line)
 
-        def inside_string_literal?(range, token)
-          ALLOWED_STRING_TOKENS.include?(token.type) && token.pos.overlaps?(range)
+          string_literal_beginning_on_line?(first_token_after(tokens, range), range.line + 1)
         end
 
-        # A method call without parentheses such as the following cannot remove `\`:
-        #
-        #   do_something \
-        #     argument
-        def method_with_argument?(current_token, next_token)
-          current_token.type == :tIDENTIFIER && ARGUMENT_TYPES.include?(next_token.type)
+        # A backslash in string content is never a redundant line continuation
+        # (removing it changes the string's value, which the reparse check would
+        # detect); skipping it up front just avoids a useless reparse.
+        def within_string_content?(range)
+          @string_content_ranges ||= processed_source.tokens.filter_map do |token|
+            token.pos if STRING_TOKEN_TYPES.include?(token.type)
+          end
+
+          @string_content_ranges.any? { |pos| pos.overlaps?(range) }
         end
 
-        def argument_newline?(node)
-          node = node.children.first if node.root? && node.begin_type?
+        # The `parser` gem, unlike Ruby itself, accepts a leading-dot method
+        # chain continued across a blank line, so the reparse check alone would
+        # deem the backslash redundant even though removing it breaks the code
+        # on MRI. Prism matches Ruby here and does not need this guard.
+        def leading_dot_method_chain_with_blank_line?(range)
+          return false unless range.source_line.strip.start_with?('.', '&.')
 
-          if argument_is_method?(node)
-            argument_newline?(node.first_argument)
-          else
-            return false unless method_call_with_arguments?(node)
+          processed_source[range.line].strip.empty?
+        end
 
-            node.loc.selector.line != node.first_argument.loc.line
-          end
+        def last_token_before(tokens, range)
+          index = tokens.bsearch_index { |token| token.end_pos > range.begin_pos }
+          index&.positive? ? tokens[index - 1] : nil
         end
 
-        def find_node_for_line(line)
-          processed_source.ast.each_node do |node|
-            return node if same_line?(node, line)
-          end
+        def first_token_after(tokens, range)
+          tokens.bsearch { |token| token.begin_pos >= range.end_pos }
         end
 
-        def same_line?(node, line)
-          return false unless (source_range = node.source_range)
+        def string_literal_ending_on_line?(token, line)
+          return false unless token
 
-          if node.is_a?(AST::StrNode)
-            if node.heredoc?
-              (node.loc.heredoc_body.line..node.loc.heredoc_body.last_line).cover?(line)
-            else
-              (source_range.line..source_range.last_line).cover?(line)
-            end
-          else
-            source_range.line == line
-          end
+          STRING_LITERAL_ENDING_TOKEN_TYPES.include?(token.type) && token.pos.last_line == line
         end
 
-        def argument_is_method?(node)
-          return false unless node.send_type?
-          return false unless (first_argument = node.first_argument)
+        def string_literal_beginning_on_line?(token, line)
+          return false unless token
 
-          method_call_with_arguments?(first_argument)
+          STRING_LITERAL_BEGINNING_TOKEN_TYPES.include?(token.type) && token.line == line
         end
 
-        def method_call_with_arguments?(node)
-          node.call_type? && !node.arguments.empty?
+        def inspect_end_of_ruby_code_line_continuation
+          last_line_number = processed_source.ast.last_line
+          last_line = processed_source.lines[last_line_number - 1]
+          return unless last_line&.end_with?(LINE_CONTINUATION)
+
+          range = trailing_line_continuation_range(last_line_number)
+          return if within_comment?(range)
+          return if verified_by_reparse([range], oversized: :verify).empty?
+
+          add_offense(range) do |corrector|
+            corrector.remove_trailing(range, 1)
+          end
         end
 
-        def start_with_arithmetic_operator?(source_line)
-          %r{\A\s*[+\-*/%]}.match?(source_line)
+        # The backslash is the last character of the line; locate it by the line's
+        # position in the buffer rather than treating the column as an absolute offset
+        # (which corrupts an earlier line in multi-line files).
+        def trailing_line_continuation_range(line_number)
+          line_range = processed_source.buffer.line_range(line_number)
+          range_between(line_range.end_pos - 1, line_range.end_pos)
         end
       end
     end

data/lib/rubocop/cop/style/redundant_min_max_by.rb

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Identifies places where `max_by { ... }`, `min_by { ... }`, or
+      # `minmax_by { ... }` can be replaced by `max`, `min`, or `minmax`.
+      #
+      # @example
+      #   # bad
+      #   array.max_by { |x| x }
+      #   array.min_by { |x| x }
+      #   array.minmax_by { |x| x }
+      #
+      #   # good
+      #   array.max
+      #   array.min
+      #   array.minmax
+      class RedundantMinMaxBy < Base
+        include RangeHelp
+        extend AutoCorrector
+
+        MSG_BLOCK = 'Use `%<replacement>s` instead of `%<original>s { |%<var>s| %<var>s }`.'
+        MSG_NUMBLOCK = 'Use `%<replacement>s` instead of `%<original>s { _1 }`.'
+        MSG_ITBLOCK = 'Use `%<replacement>s` instead of `%<original>s { it }`.'
+
+        REPLACEMENTS = { max_by: 'max', min_by: 'min', minmax_by: 'minmax' }.freeze
+
+        def on_block(node)
+          redundant_minmax_by_block(node) do |send, var_name|
+            register_offense(send, node, message_block(send, var_name))
+          end
+        end
+
+        def on_numblock(node)
+          redundant_minmax_by_numblock(node) do |send|
+            register_offense(send, node, message_numblock(send))
+          end
+        end
+
+        def on_itblock(node)
+          redundant_minmax_by_itblock(node) do |send|
+            register_offense(send, node, message_itblock(send))
+          end
+        end
+
+        private
+
+        # @!method redundant_minmax_by_block(node)
+        def_node_matcher :redundant_minmax_by_block, <<~PATTERN
+          (block $(call _ {:max_by :min_by :minmax_by}) (args (arg $_x)) (lvar _x))
+        PATTERN
+
+        # @!method redundant_minmax_by_numblock(node)
+        def_node_matcher :redundant_minmax_by_numblock, <<~PATTERN
+          (numblock $(call _ {:max_by :min_by :minmax_by}) 1 (lvar :_1))
+        PATTERN
+
+        # @!method redundant_minmax_by_itblock(node)
+        def_node_matcher :redundant_minmax_by_itblock, <<~PATTERN
+          (itblock $(call _ {:max_by :min_by :minmax_by}) _ (lvar :it))
+        PATTERN
+
+        def register_offense(send, node, message)
+          range = offense_range(send, node)
+
+          add_offense(range, message: message) do |corrector|
+            corrector.replace(range, REPLACEMENTS[send.method_name])
+          end
+        end
+
+        def offense_range(send, node)
+          range_between(send.loc.selector.begin_pos, node.loc.end.end_pos)
+        end
+
+        def message_block(send, var_name)
+          method = send.method_name
+          format(MSG_BLOCK, replacement: REPLACEMENTS[method], original: method, var: var_name)
+        end
+
+        def message_numblock(send)
+          method = send.method_name
+          format(MSG_NUMBLOCK, replacement: REPLACEMENTS[method], original: method)
+        end
+
+        def message_itblock(send)
+          method = send.method_name
+          format(MSG_ITBLOCK, replacement: REPLACEMENTS[method], original: method)
+        end
+      end
+    end
+  end
+end