rubocop-performance 1.13.3 → 1.19.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: cc8de809f0aa167f08fd75ed2f7047fabc37b06b12a0c59e4647530b18fb6d99
-  data.tar.gz: df849a7c117eb44d8851969031cda6d5927e2f271ad41bc3689212bad6b9e2e1
+  metadata.gz: 06f3e8346dc7f9be72a1f18c62a25dc02aeac41debcfe3c58df68e2a6904df43
+  data.tar.gz: f01facdb92a3056d05990e2ed2b6b1920de0501edf53a08e95e08620651c8557
 SHA512:
-  metadata.gz: 24c72e01dfa6cfe35b3c93e1c83d63aaa0362dff7bc4ed234b8b6f8c1a434927a945b077273ec84c95be86d70e050f28e18dad27ffc9c72350f49c7ff3477b4a
-  data.tar.gz: 3340644f87ea108d8f7022756ff5cdf442b0d2951cd9ea351bb0a4012c2d0721dc921b1402e8b5f952899015b51c402cdbcab5e785d764f4655aa068c71be6b3
+  metadata.gz: 07eb541698b6ccf2985ef62392bd78703bf6607e2877ef3865ab1762d62910c4c346fbb7e9bc48af7b7d98b0e1ad22e8c79ea2425555fbe75c2a5e614837eaa7
+  data.tar.gz: 60fc9f900906cca518d0da62170f71ae6e5f5ffd44f4c1cbe75af83f9a1fef252b6bab95d3af4f49f328d4a856cd17c7f47621ee62575ab282eacfd26dc09841

data/LICENSE.txt

@@ -1,4 +1,4 @@
-Copyright (c) 2012-22 Bozhidar Batsov
+Copyright (c) 2012-23 Bozhidar Batsov
 
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the

data/README.md

@@ -11,7 +11,7 @@ Performance optimization analysis for your projects, as an extension to [RuboCop
 Just install the `rubocop-performance` gem
 
 ```sh
-gem install rubocop-performance
+$ gem install rubocop-performance
 ```
 
 or if you use bundler put this in your `Gemfile`
@@ -47,7 +47,7 @@ cops together with the standard cops.
 ### Command line
 
 ```sh
-rubocop --require rubocop-performance
+$ rubocop --require rubocop-performance
 ```
 
 ### Rake task

data/config/default.yml

@@ -1,5 +1,9 @@
 # This is the default configuration file.
 
+Performance:
+  Enabled: true
+  DocumentationBaseURL: https://docs.rubocop.org/rubocop-performance
+
 Performance/AncestorsInclude:
   Description: 'Use `A <= B` instead of `A.ancestors.include?(B)`.'
   Reference: 'https://github.com/JuanitoFatas/fast-ruby#ancestorsinclude-vs--code'
@@ -160,7 +164,7 @@ Performance/FlatMap:
   Description: >-
                   Use `Enumerable#flat_map`
                   instead of `Enumerable#map...Array#flatten(1)`
-                  or `Enumberable#collect..Array#flatten(1)`.
+                  or `Enumerable#collect..Array#flatten(1)`.
   Reference: 'https://github.com/JuanitoFatas/fast-ruby#enumerablemaparrayflatten-vs-enumerableflat_map-code'
   Enabled: true
   VersionAdded: '0.30'
@@ -189,6 +193,12 @@ Performance/MapCompact:
   SafeAutoCorrect: false
   VersionAdded: '1.11'
 
+Performance/MapMethodChain:
+  Description: 'Checks if the `map` method is used in a chain.'
+  Enabled: pending
+  Safe: false
+  VersionAdded: '1.19'
+
 Performance/MethodObjectAsBlock:
   Description: 'Use block explicitly instead of block-passing a method object.'
   Reference: 'https://github.com/JuanitoFatas/fast-ruby#normal-way-to-apply-method-vs-method-code'
@@ -222,6 +232,7 @@ Performance/RedundantEqualityComparisonBlock:
   Reference: 'https://github.com/rails/rails/pull/41363'
   Enabled: pending
   Safe: false
+  AllowRegexpMatch: true
   VersionAdded: '1.10'
 
 Performance/RedundantMatch:
@@ -247,7 +258,7 @@ Performance/RedundantSortBlock:
   VersionAdded: '1.7'
 
 Performance/RedundantSplitRegexpArgument:
-  Description: 'This cop identifies places where `split` argument can be replaced from a deterministic regexp to a string.'
+  Description: 'Identifies places where `split` argument can be replaced from a deterministic regexp to a string.'
   Enabled: pending
   VersionAdded: '1.10'
 

data/lib/rubocop/cop/mixin/regexp_metacharacter.rb

@@ -54,9 +54,9 @@ module RuboCop
 
       def drop_start_metacharacter(regexp_string)
         if regexp_string.start_with?('\\A')
-          regexp_string[2..-1] # drop `\A` anchor
+          regexp_string[2..] # drop `\A` anchor
         else
-          regexp_string[1..-1] # drop `^` anchor
+          regexp_string[1..] # drop `^` anchor
         end
       end
 

data/lib/rubocop/cop/mixin/sort_block.rb

@@ -14,6 +14,13 @@ module RuboCop
           $send)
       PATTERN
 
+      def_node_matcher :sort_with_numblock?, <<~PATTERN
+        (numblock
+          $(send _ :sort)
+          $_arg_count
+          $send)
+      PATTERN
+
       def_node_matcher :replaceable_body?, <<~PATTERN
         (send (lvar %1) :<=> (lvar %2))
       PATTERN

data/lib/rubocop/cop/performance/ancestors_include.rb

@@ -3,8 +3,7 @@
 module RuboCop
   module Cop
     module Performance
-      # This cop is used to identify usages of `ancestors.include?` and
-      # change them to use `<=` instead.
+      # Identifies usages of `ancestors.include?` and change them to use `<=` instead.
       #
       # @safety
       #   This cop is unsafe because it can't tell whether the receiver is a class or an object.

data/lib/rubocop/cop/performance/array_semi_infinite_range_slice.rb

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Performance
-      # This cop identifies places where slicing arrays with semi-infinite ranges
+      # Identifies places where slicing arrays with semi-infinite ranges
       # can be replaced by `Array#take` and `Array#drop`.
       # This cop was created due to a mistake in microbenchmark and hence is disabled by default.
       # Refer https://github.com/rubocop/rubocop-performance/pull/175#issuecomment-731892717
@@ -39,7 +39,7 @@ module RuboCop
         RESTRICT_ON_SEND = SLICE_METHODS
 
         def_node_matcher :endless_range_slice?, <<~PATTERN
-          (send $_ $%SLICE_METHODS $#endless_range?)
+          (call $_ $%SLICE_METHODS $#endless_range?)
         PATTERN
 
         def_node_matcher :endless_range?, <<~PATTERN
@@ -59,6 +59,7 @@ module RuboCop
             end
           end
         end
+        alias on_csend on_send
 
         private
 

data/lib/rubocop/cop/performance/big_decimal_with_numeric_argument.rb

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Performance
-      # This cop identifies places where numeric argument to BigDecimal should be
+      # Identifies places where numeric argument to BigDecimal should be
       # converted to string. Initializing from String is faster
       # than from Numeric for BigDecimal.
       #
@@ -41,11 +41,7 @@ module RuboCop
             end
           elsif (numeric_to_d = to_d?(node))
             add_offense(numeric_to_d.source_range) do |corrector|
-              big_decimal_args = node
-                                 .arguments
-                                 .map(&:source)
-                                 .unshift("'#{numeric_to_d.source}'")
-                                 .join(', ')
+              big_decimal_args = node.arguments.map(&:source).unshift("'#{numeric_to_d.source}'").join(', ')
 
               corrector.replace(node, "BigDecimal(#{big_decimal_args})")
             end

data/lib/rubocop/cop/performance/bind_call.rb

@@ -26,8 +26,7 @@ module RuboCop
 
         minimum_target_ruby_version 2.7
 
-        MSG = 'Use `bind_call(%<bind_arg>s%<comma>s%<call_args>s)` ' \
-              'instead of `bind(%<bind_arg>s).call(%<call_args>s)`.'
+        MSG = 'Use `bind_call(%<bind_arg>s%<comma>s%<call_args>s)` instead of `bind(%<bind_arg>s).call(%<call_args>s)`.'
         RESTRICT_ON_SEND = %i[call].freeze
 
         def_node_matcher :bind_with_call_method?, <<~PATTERN

data/lib/rubocop/cop/performance/block_given_with_explicit_block.rb

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Performance
-      # This cop identifies unnecessary use of a `block_given?` where explicit check
+      # Identifies unnecessary use of a `block_given?` where explicit check
       # of block argument would suffice.
       #
       # @example

data/lib/rubocop/cop/performance/caller.rb

@@ -3,8 +3,7 @@
 module RuboCop
   module Cop
     module Performance
-      # This cop identifies places where `caller[n]`
-      # can be replaced by `caller(n..n).first`.
+      # Identifies places where `caller[n]` can be replaced by `caller(n..n).first`.
       #
       # @example
       #   # bad

data/lib/rubocop/cop/performance/case_when_splat.rb

@@ -18,7 +18,7 @@ module RuboCop
       # that is inside of the splat expansion.
       #
       # @safety
-      #   This cop is not unsafe auto-correction because it is not a guaranteed
+      #   This cop is not unsafe autocorrection because it is not a guaranteed
       #   performance improvement. If the data being processed by the `case` condition is
       #   normalized in a manner that favors hitting a condition in the splat expansion,
       #   it is possible that moving the splat condition to the end will use more memory,
@@ -99,8 +99,7 @@ module RuboCop
 
         def inline_fix_branch(corrector, when_node)
           conditions = when_node.conditions
-          range = range_between(conditions[0].loc.expression.begin_pos,
-                                conditions[-1].loc.expression.end_pos)
+          range = range_between(conditions[0].source_range.begin_pos, conditions[-1].source_range.end_pos)
 
           corrector.replace(range, replacement(conditions))
         end
@@ -111,8 +110,7 @@ module RuboCop
           return if when_branches.one?
 
           corrector.remove(when_branch_range(when_node))
-          corrector.insert_after(when_branches.last.source_range,
-                                 reordering_correction(when_node))
+          corrector.insert_after(when_branches.last, reordering_correction(when_node))
         end
 
         def reordering_correction(when_node)
@@ -126,11 +124,9 @@ module RuboCop
         end
 
         def when_branch_range(when_node)
-          next_branch =
-            when_node.parent.when_branches[when_node.branch_index + 1]
+          next_branch = when_node.parent.when_branches[when_node.branch_index + 1]
 
-          range_between(when_node.source_range.begin_pos,
-                        next_branch.source_range.begin_pos)
+          range_between(when_node.source_range.begin_pos, next_branch.source_range.begin_pos)
         end
 
         def new_condition_with_then(node, new_condition)
@@ -162,13 +158,11 @@ module RuboCop
         def non_splat?(condition)
           variable, = *condition
 
-          (condition.splat_type? && variable.array_type?) ||
-            !condition.splat_type?
+          (condition.splat_type? && variable.array_type?) || !condition.splat_type?
         end
 
         def needs_reorder?(when_node)
-          following_branches =
-            when_node.parent.when_branches[(when_node.branch_index + 1)..-1]
+          following_branches = when_node.parent.when_branches[(when_node.branch_index + 1)..]
 
           following_branches.any? do |when_branch|
             when_branch.conditions.any? do |condition|

data/lib/rubocop/cop/performance/casecmp.rb

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Performance
-      # This cop identifies places where a case-insensitive string comparison
+      # Identifies places where a case-insensitive string comparison
       # can better be implemented using `casecmp`.
       #
       # @safety
@@ -54,11 +54,11 @@ module RuboCop
           return unless (parts = take_method_apart(node))
 
           _receiver, method, arg, variable = parts
-          good_method = build_good_method(arg, variable)
+          good_method = build_good_method(method, arg, variable)
 
           message = format(MSG, good: good_method, bad: node.source)
           add_offense(node, message: message) do |corrector|
-            correction(corrector, node, method, arg, variable)
+            autocorrect(corrector, node, good_method)
           end
         end
 
@@ -81,22 +81,20 @@ module RuboCop
           [receiver, method, arg, variable]
         end
 
-        def correction(corrector, node, method, arg, variable)
-          corrector.insert_before(node.loc.expression, '!') if method == :!=
-
-          replacement = build_good_method(arg, variable)
-
-          corrector.replace(node.loc.expression, replacement)
+        def autocorrect(corrector, node, replacement)
+          corrector.replace(node, replacement)
         end
 
-        def build_good_method(arg, variable)
+        def build_good_method(method, arg, variable)
+          bang = method == :!= ? '!' : ''
+
           # We want resulting call to be parenthesized
           # if arg already includes one or more sets of parens, don't add more
           # or if method call already used parens, again, don't add more
           if arg.send_type? || !parentheses?(arg)
-            "#{variable.source}.casecmp(#{arg.source}).zero?"
+            "#{bang}#{variable.source}.casecmp(#{arg.source}).zero?"
           else
-            "#{variable.source}.casecmp#{arg.source}.zero?"
+            "#{bang}#{variable.source}.casecmp#{arg.source}.zero?"
           end
         end
       end

data/lib/rubocop/cop/performance/chain_array_allocation.rb

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Performance
-      # This cop is used to identify usages of `array.compact.flatten.map { |x| x.downcase }`.
+      # Identifies usages of `array.compact.flatten.map { |x| x.downcase }`.
       # Each of these methods (`compact`, `flatten`, `map`) will generate a new intermediate array
       # that is promptly thrown away. Instead it is faster to mutate when we know it's safe.
       #
@@ -33,7 +33,7 @@ module RuboCop
         RETURNS_NEW_ARRAY_WHEN_NO_BLOCK = %i[zip product].to_set.freeze
 
         # These methods ALWAYS return a new array
-        # after they're called it's safe to mutate the the resulting array
+        # after they're called it's safe to mutate the resulting array
         ALWAYS_RETURNS_NEW_ARRAY = %i[* + - collect compact drop
                                       drop_while flatten map reject
                                       reverse rotate select shuffle sort
@@ -47,13 +47,13 @@ module RuboCop
 
         RETURNS_NEW_ARRAY = (ALWAYS_RETURNS_NEW_ARRAY + RETURNS_NEW_ARRAY_WHEN_NO_BLOCK).freeze
 
-        MSG = 'Use unchained `%<method>s` and `%<second_method>s!` '\
-              '(followed by `return array` if required) instead of chaining '\
+        MSG = 'Use unchained `%<method>s` and `%<second_method>s!` ' \
+              '(followed by `return array` if required) instead of chaining ' \
               '`%<method>s...%<second_method>s`.'
 
         def_node_matcher :chain_array_allocation?, <<~PATTERN
           (send {
-            (send _ $%RETURN_NEW_ARRAY_WHEN_ARGS {int lvar ivar cvar gvar})
+            (send _ $%RETURN_NEW_ARRAY_WHEN_ARGS {int lvar ivar cvar gvar send})
             (block (send _ $%ALWAYS_RETURNS_NEW_ARRAY) ...)
             (send _ $%RETURNS_NEW_ARRAY ...)
           } $%HAS_MUTATION_ALTERNATIVE ...)

data/lib/rubocop/cop/performance/collection_literal_in_loop.rb

@@ -5,8 +5,8 @@ require 'set'
 module RuboCop
   module Cop
     module Performance
-      # This cop identifies places where Array and Hash literals are used
-      # within loops. It is better to extract them into a local variable or constant
+      # Identifies places where Array and Hash literals are used within loops.
+      # It is better to extract them into a local variable or constant
       # to avoid unnecessary allocations on each iteration.
       #
       # You can set the minimum number of elements to consider
@@ -32,7 +32,7 @@ module RuboCop
       #   end
       #
       class CollectionLiteralInLoop < Base
-        MSG = 'Avoid immutable %<literal_class>s literals in loops. '\
+        MSG = 'Avoid immutable %<literal_class>s literals in loops. ' \
               'It is better to extract it into a local variable or a constant.'
 
         POST_CONDITION_LOOP_TYPES = %i[while_post until_post].freeze
@@ -104,9 +104,7 @@ module RuboCop
         end
 
         def loop?(ancestor, node)
-          keyword_loop?(ancestor.type) ||
-            kernel_loop?(ancestor) ||
-            node_within_enumerable_loop?(node, ancestor)
+          keyword_loop?(ancestor.type) || kernel_loop?(ancestor) || node_within_enumerable_loop?(node, ancestor)
         end
 
         def keyword_loop?(type)

data/lib/rubocop/cop/performance/compare_with_block.rb

@@ -3,37 +3,44 @@
 module RuboCop
   module Cop
     module Performance
-      # This cop identifies places where `sort { |a, b| a.foo <=> b.foo }`
+      # Identifies places where `sort { |a, b| a.foo <=> b.foo }`
       # can be replaced by `sort_by(&:foo)`.
-      # This cop also checks `max` and `min` methods.
+      # This cop also checks `sort!`, `min`, `max` and `minmax` methods.
       #
       # @example
       #   # bad
-      #   array.sort { |a, b| a.foo <=> b.foo }
-      #   array.max { |a, b| a.foo <=> b.foo }
-      #   array.min { |a, b| a.foo <=> b.foo }
-      #   array.sort { |a, b| a[:foo] <=> b[:foo] }
+      #   array.sort   { |a, b| a.foo <=> b.foo }
+      #   array.sort!  { |a, b| a.foo <=> b.foo }
+      #   array.max    { |a, b| a.foo <=> b.foo }
+      #   array.min    { |a, b| a.foo <=> b.foo }
+      #   array.minmax { |a, b| a.foo <=> b.foo }
+      #   array.sort   { |a, b| a[:foo] <=> b[:foo] }
       #
       #   # good
       #   array.sort_by(&:foo)
+      #   array.sort_by!(&:foo)
       #   array.sort_by { |v| v.foo }
       #   array.sort_by do |var|
       #     var.foo
       #   end
       #   array.max_by(&:foo)
       #   array.min_by(&:foo)
+      #   array.minmax_by(&:foo)
       #   array.sort_by { |a| a[:foo] }
       class CompareWithBlock < Base
         include RangeHelp
         extend AutoCorrector
 
-        MSG = 'Use `%<compare_method>s_by%<instead>s` instead of ' \
+        MSG = 'Use `%<replacement_method>s%<instead>s` instead of ' \
               '`%<compare_method>s { |%<var_a>s, %<var_b>s| %<str_a>s ' \
               '<=> %<str_b>s }`.'
 
+        REPLACEMENT = { sort: :sort_by, sort!: :sort_by!, min: :min_by, max: :max_by, minmax: :minmax_by }.freeze
+        private_constant :REPLACEMENT
+
         def_node_matcher :compare?, <<~PATTERN
           (block
-            $(send _ {:sort :min :max})
+            $(send _ {:sort :sort! :min :max :minmax})
             (args (arg $_a) (arg $_b))
             $send)
         PATTERN
@@ -54,9 +61,9 @@ module RuboCop
 
               add_offense(range, message: message(send, method, var_a, var_b, args_a)) do |corrector|
                 replacement = if method == :[]
-                                "#{send.method_name}_by { |a| a[#{args_a.first.source}] }"
+                                "#{REPLACEMENT[send.method_name]} { |a| a[#{args_a.first.source}] }"
                               else
-                                "#{send.method_name}_by(&:#{method})"
+                                "#{REPLACEMENT[send.method_name]}(&:#{method})"
                               end
                 corrector.replace(range, replacement)
               end
@@ -82,7 +89,8 @@ module RuboCop
 
         # rubocop:disable Metrics/MethodLength
         def message(send, method, var_a, var_b, args)
-          compare_method = send.method_name
+          compare_method     = send.method_name
+          replacement_method = REPLACEMENT[compare_method]
           if method == :[]
             key = args.first
             instead = " { |a| a[#{key.source}] }"
@@ -94,6 +102,7 @@ module RuboCop
             str_b = "#{var_b}.#{method}"
           end
           format(MSG, compare_method: compare_method,
+                      replacement_method: replacement_method,
                       instead: instead,
                       var_a: var_a,
                       var_b: var_b,

data/lib/rubocop/cop/performance/concurrent_monotonic_time.rb

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Performance
-      # This cop identifies places where `Concurrent.monotonic_time`
+      # Identifies places where `Concurrent.monotonic_time`
       # can be replaced by `Process.clock_gettime(Process::CLOCK_MONOTONIC)`.
       #
       # @example

data/lib/rubocop/cop/performance/constant_regexp.rb

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Performance
-      # This cop finds regular expressions with dynamic components that are all constants.
+      # Finds regular expressions with dynamic components that are all constants.
       #
       # Ruby allocates a new Regexp object every time it executes a code containing such
       # a regular expression. It is more efficient to extract it into a constant,
@@ -38,10 +38,12 @@ module RuboCop
 
         MSG = 'Extract this regexp into a constant, memoize it, or append an `/o` option to its options.'
 
+        def self.autocorrect_incompatible_with
+          [RegexpMatch]
+        end
+
         def on_regexp(node)
-          return if within_allowed_assignment?(node) ||
-                    !include_interpolated_const?(node) ||
-                    node.single_interpolation?
+          return if within_allowed_assignment?(node) || !include_interpolated_const?(node) || node.single_interpolation?
 
           add_offense(node) do |corrector|
             corrector.insert_after(node, 'o')

data/lib/rubocop/cop/performance/count.rb

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Performance
-      # This cop is used to identify usages of `count` on an `Enumerable` that
+      # Identifies usages of `count` on an `Enumerable` that
       # follow calls to `select`, `find_all`, `filter` or `reject`. Querying logic can instead be
       # passed to the `count` call.
       #
@@ -79,12 +79,11 @@ module RuboCop
         def autocorrect(corrector, node, selector_node, selector)
           selector_loc = selector_node.loc.selector
 
-          return if selector == :reject
-
           range = source_starting_at(node) { |n| n.loc.dot.begin_pos }
 
           corrector.remove(range)
           corrector.replace(selector_loc, 'count')
+          negate_reject(corrector, node) if selector == :reject
         end
 
         def eligible_node?(node)
@@ -100,6 +99,43 @@ module RuboCop
 
           range_between(begin_pos, node.source_range.end_pos)
         end
+
+        def negate_reject(corrector, node)
+          if node.receiver.send_type?
+            negate_block_pass_reject(corrector, node)
+          else
+            negate_block_reject(corrector, node)
+          end
+        end
+
+        def negate_block_pass_reject(corrector, node)
+          corrector.replace(
+            node.receiver.source_range.with(begin_pos: node.receiver.loc.begin.begin_pos),
+            negate_block_pass_as_inline_block(node.receiver)
+          )
+        end
+
+        def negate_block_reject(corrector, node)
+          target =
+            if node.receiver.body.begin_type?
+              node.receiver.body.children.last
+            else
+              node.receiver.body
+            end
+          corrector.replace(target, negate_expression(target))
+        end
+
+        def negate_expression(node)
+          "!(#{node.source})"
+        end
+
+        def negate_block_pass_as_inline_block(node)
+          if node.last_argument.children.first.sym_type?
+            " { |element| !element.#{node.last_argument.children.first.value} }"
+          else
+            " { !#{node.last_argument.children.first.source}.call }"
+          end
+        end
       end
     end
   end

data/lib/rubocop/cop/performance/delete_prefix.rb

@@ -49,6 +49,9 @@ module RuboCop
       class DeletePrefix < Base
         include RegexpMetacharacter
         extend AutoCorrector
+        extend TargetRubyVersion
+
+        minimum_target_ruby_version 2.5
 
         MSG = 'Use `%<prefer>s` instead of `%<current>s`.'
         RESTRICT_ON_SEND = %i[gsub gsub! sub sub!].freeze
@@ -61,9 +64,10 @@ module RuboCop
         }.freeze
 
         def_node_matcher :delete_prefix_candidate?, <<~PATTERN
-          (send $!nil? ${:gsub :gsub! :sub :sub!} (regexp (str $#literal_at_start?) (regopt)) (str $_))
+          (call $!nil? ${:gsub :gsub! :sub :sub!} (regexp (str $#literal_at_start?) (regopt)) (str $_))
         PATTERN
 
+        # rubocop:disable Metrics/AbcSize
         def on_send(node)
           return unless (receiver, bad_method, regexp_str, replace_string = delete_prefix_candidate?(node))
           return unless replace_string.empty?
@@ -77,11 +81,13 @@ module RuboCop
             regexp_str = interpret_string_escapes(regexp_str)
             string_literal = to_string_literal(regexp_str)
 
-            new_code = "#{receiver.source}.#{good_method}(#{string_literal})"
+            new_code = "#{receiver.source}#{node.loc.dot.source}#{good_method}(#{string_literal})"
 
             corrector.replace(node, new_code)
           end
         end
+        # rubocop:enable Metrics/AbcSize
+        alias on_csend on_send
       end
     end
   end

data/lib/rubocop/cop/performance/delete_suffix.rb

@@ -49,6 +49,9 @@ module RuboCop
       class DeleteSuffix < Base
         include RegexpMetacharacter
         extend AutoCorrector
+        extend TargetRubyVersion
+
+        minimum_target_ruby_version 2.5
 
         MSG = 'Use `%<prefer>s` instead of `%<current>s`.'
         RESTRICT_ON_SEND = %i[gsub gsub! sub sub!].freeze
@@ -61,9 +64,10 @@ module RuboCop
         }.freeze
 
         def_node_matcher :delete_suffix_candidate?, <<~PATTERN
-          (send $!nil? ${:gsub :gsub! :sub :sub!} (regexp (str $#literal_at_end?) (regopt)) (str $_))
+          (call $!nil? ${:gsub :gsub! :sub :sub!} (regexp (str $#literal_at_end?) (regopt)) (str $_))
         PATTERN
 
+        # rubocop:disable Metrics/AbcSize
         def on_send(node)
           return unless (receiver, bad_method, regexp_str, replace_string = delete_suffix_candidate?(node))
           return unless replace_string.empty?
@@ -77,11 +81,13 @@ module RuboCop
             regexp_str = interpret_string_escapes(regexp_str)
             string_literal = to_string_literal(regexp_str)
 
-            new_code = "#{receiver.source}.#{good_method}(#{string_literal})"
+            new_code = "#{receiver.source}#{node.loc.dot.source}#{good_method}(#{string_literal})"
 
             corrector.replace(node, new_code)
           end
         end
+        # rubocop:enable Metrics/AbcSize
+        alias on_csend on_send
       end
     end
   end