rubocop-performance 1.18.0 → 1.23.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f4926be80598b4880037ffd36eef32c9025051af7f0398f69a34439c135c9d87
-  data.tar.gz: ba3d738da529cbc70c33e8c5d4baa4c6c8013a5498c834f2e28dc87a8811c15a
+  metadata.gz: 332ca643753a81ff66c4a6050117f7a479bd3aaa3f186c361a596d06b16aa9b5
+  data.tar.gz: 2fb149f85f986d9d0302e6fbe4c7389f312bb93a15a93cec49ffd74495853c78
 SHA512:
-  metadata.gz: 1b9a64379554a660c30bffea5a0fc8a8d36a9e31efef6ccb4576f4df432d2f270d91d76b0e7e7638740e6cf83a50b94b4dfe37d93e5366d0171b8a0f4e5bff50
-  data.tar.gz: d27b9db647eb1a53f3e80b0ec20cd43b37b0244127a28f7fbdacefcf9477205a7f4d373c0a27d882fcb43f902d4ab398ad73ea3f51cdd21e5d422cd419d621e9
+  metadata.gz: e03b8e178f4cde75ef5d82aa7483da512f2816afd82c97b414a4bfcd7afacf589ebb033d6bed40d0968217ec0ff24cb69e2a6c4f28a52ecbdb31cef5599e5386
+  data.tar.gz: 410a72e5e85fe6cdc8002b51c8b185dc4d2a1dea5f3a5889c146364c2a20b5b50256c2a90fef59604137dd75d83f20c17ec65991eac6b8dab15e046184e1f006

data/LICENSE.txt

@@ -1,4 +1,4 @@
-Copyright (c) 2012-23 Bozhidar Batsov
+Copyright (c) 2012-25 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

@@ -1,7 +1,7 @@
 # RuboCop Performance
 
 [![Gem Version](https://badge.fury.io/rb/rubocop-performance.svg)](https://badge.fury.io/rb/rubocop-performance)
-[![CircleCI](https://circleci.com/gh/rubocop/rubocop-performance.svg?style=svg)](https://circleci.com/gh/rubocop/rubocop-performance)
+[![CI](https://github.com/rubocop/rubocop-performance/actions/workflows/test.yml/badge.svg)](https://github.com/rubocop/rubocop-performance/actions/workflows/test.yml)
 [![Discord](https://img.shields.io/badge/chat-on%20discord-7289da.svg?sanitize=true)](https://discord.gg/wJjWvGRDmm)
 
 Performance optimization analysis for your projects, as an extension to [RuboCop](https://github.com/rubocop/rubocop).
@@ -53,6 +53,8 @@ $ rubocop --require rubocop-performance
 ### Rake task
 
 ```ruby
+require 'rubocop/rake_task'
+
 RuboCop::RakeTask.new do |task|
   task.requires << 'rubocop-performance'
 end

data/config/default.yml

@@ -6,7 +6,7 @@ Performance:
 
 Performance/AncestorsInclude:
   Description: 'Use `A <= B` instead of `A.ancestors.include?(B)`.'
-  Reference: 'https://github.com/JuanitoFatas/fast-ruby#ancestorsinclude-vs--code'
+  Reference: 'https://github.com/fastruby/fast-ruby#ancestorsinclude-vs--code'
   Enabled: 'pending'
   Safe: false
   VersionAdded: '1.7'
@@ -32,8 +32,11 @@ Performance/BindCall:
 
 Performance/BlockGivenWithExplicitBlock:
   Description: 'Check block argument explicitly instead of using `block_given?`.'
-  Enabled: pending
+  # This cop was created due to a mistake in microbenchmark.
+  # https://github.com/rubocop/rubocop-performance/issues/385
+  Enabled: false
   VersionAdded: '1.9'
+  VersionChanged: '1.22'
 
 Performance/Caller:
   Description: >-
@@ -54,10 +57,11 @@ Performance/CaseWhenSplat:
 Performance/Casecmp:
   Description: >-
              Use `casecmp` rather than `downcase ==`, `upcase ==`, `== downcase`, or `== upcase`..
-  Reference: 'https://github.com/JuanitoFatas/fast-ruby#stringcasecmp-vs-stringdowncase---code'
-  Enabled: true
+  Reference: 'https://github.com/fastruby/fast-ruby#stringcasecmp-vs--stringcasecmp-vs-stringdowncase---code'
+  Enabled: false
   Safe: false
   VersionAdded: '0.36'
+  VersionChanged: '1.21'
 
 Performance/ChainArrayAllocation:
   Description: >-
@@ -122,7 +126,7 @@ Performance/Detect:
   Description: >-
                   Use `detect` instead of `select.first`, `find_all.first`, `filter.first`,
                   `select.last`, `find_all.last`, and `filter.last`.
-  Reference: 'https://github.com/JuanitoFatas/fast-ruby#enumerabledetect-vs-enumerableselectfirst-code'
+  Reference: 'https://github.com/fastruby/fast-ruby#enumerabledetect-vs-enumerableselectfirst-code'
   # This cop has known compatibility issues with `ActiveRecord` and other
   # frameworks. `ActiveRecord` does not implement a `detect` method and `find`
   # has its own meaning. Correcting `ActiveRecord` methods with this cop
@@ -145,7 +149,7 @@ Performance/DoubleStartEndWith:
 
 Performance/EndWith:
   Description: 'Use `end_with?` instead of a regex match anchored to the end of a string.'
-  Reference: 'https://github.com/JuanitoFatas/fast-ruby#stringmatch-vs-stringstart_withstringend_with-code-start-code-end'
+  Reference: 'https://github.com/fastruby/fast-ruby#stringmatch-vs-stringmatch-vs-stringstart_withstringend_with-code-start-code-end'
   # This will change to a new method call which isn't guaranteed to be on the
   # object. Switching these methods has to be done with knowledge of the types
   # of the variables which rubocop doesn't have.
@@ -165,7 +169,7 @@ Performance/FlatMap:
                   Use `Enumerable#flat_map`
                   instead of `Enumerable#map...Array#flatten(1)`
                   or `Enumerable#collect..Array#flatten(1)`.
-  Reference: 'https://github.com/JuanitoFatas/fast-ruby#enumerablemaparrayflatten-vs-enumerableflat_map-code'
+  Reference: 'https://github.com/fastruby/fast-ruby#enumerablemaparrayflatten-vs-enumerableflat_map-code'
   Enabled: true
   VersionAdded: '0.30'
   EnabledForFlattenWithoutParams: false
@@ -176,7 +180,7 @@ Performance/FlatMap:
 
 Performance/InefficientHashSearch:
   Description: 'Use `key?` or `value?` instead of `keys.include?` or `values.include?`.'
-  Reference: 'https://github.com/JuanitoFatas/fast-ruby#hashkey-instead-of-hashkeysinclude-code'
+  Reference: 'https://github.com/fastruby/fast-ruby#hashkey-instead-of-hashkeysinclude-code'
   Enabled: true
   VersionAdded: '0.56'
   Safe: false
@@ -193,9 +197,15 @@ 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'
+  Reference: 'https://github.com/fastruby/fast-ruby#normal-way-to-apply-method-vs-method-code'
   Enabled: pending
   VersionAdded: '1.9'
 
@@ -207,7 +217,7 @@ Performance/OpenStruct:
 
 Performance/RangeInclude:
   Description: 'Use `Range#cover?` instead of `Range#include?` (or `Range#member?`).'
-  Reference: 'https://github.com/JuanitoFatas/fast-ruby#cover-vs-include-code'
+  Reference: 'https://github.com/fastruby/fast-ruby#cover-vs-include-code'
   Enabled: true
   VersionAdded: '0.36'
   VersionChanged: '1.7'
@@ -215,7 +225,7 @@ Performance/RangeInclude:
 
 Performance/RedundantBlockCall:
   Description: 'Use `yield` instead of `block.call`.'
-  Reference: 'https://github.com/JuanitoFatas/fast-ruby#proccall-and-block-arguments-vs-yieldcode'
+  Reference: 'https://github.com/fastruby/fast-ruby#proccall-and-block-arguments-vs-yieldcode'
   Enabled: true
   VersionAdded: '0.36'
 
@@ -238,7 +248,7 @@ Performance/RedundantMatch:
 
 Performance/RedundantMerge:
   Description: 'Use Hash#[]=, rather than Hash#merge! with a single key-value pair.'
-  Reference: 'https://github.com/JuanitoFatas/fast-ruby#hashmerge-vs-hash-code'
+  Reference: 'https://github.com/fastruby/fast-ruby#hashmerge-vs-hash-code'
   Enabled: true
   Safe: false
   VersionAdded: '0.36'
@@ -265,13 +275,13 @@ Performance/RegexpMatch:
   Description: >-
                   Use `match?` instead of `Regexp#match`, `String#match`, `Symbol#match`,
                   `Regexp#===`, or `=~` when `MatchData` is not used.
-  Reference: 'https://github.com/JuanitoFatas/fast-ruby#regexp-vs-stringmatch-vs-string-vs-stringmatch-code-'
+  Reference: 'https://github.com/fastruby/fast-ruby#regexp-vs-regexpmatch-vs-regexpmatch-vs-stringmatch-vs-string-vs-stringmatch-code-'
   Enabled: true
   VersionAdded: '0.47'
 
 Performance/ReverseEach:
   Description: 'Use `reverse_each` instead of `reverse.each`.'
-  Reference: 'https://github.com/JuanitoFatas/fast-ruby#enumerablereverseeach-vs-enumerablereverse_each-code'
+  Reference: 'https://github.com/fastruby/fast-ruby#enumerablereverseeach-vs-enumerablereverse_each-code'
   Enabled: true
   VersionAdded: '0.30'
 
@@ -289,7 +299,7 @@ Performance/Size:
   Description: >-
                   Use `size` instead of `count` for counting
                   the number of elements in `Array` and `Hash`.
-  Reference: 'https://github.com/JuanitoFatas/fast-ruby#arraylength-vs-arraysize-vs-arraycount-code'
+  Reference: 'https://github.com/fastruby/fast-ruby#arraylength-vs-arraysize-vs-arraycount-code'
   Enabled: true
   VersionAdded: '0.30'
 
@@ -300,13 +310,13 @@ Performance/SortReverse:
 
 Performance/Squeeze:
   Description: "Use `squeeze('a')` instead of `gsub(/a+/, 'a')`."
-  Reference: 'https://github.com/JuanitoFatas/fast-ruby#remove-extra-spaces-or-other-contiguous-characters-code'
+  Reference: 'https://github.com/fastruby/fast-ruby#remove-extra-spaces-or-other-contiguous-characters-code'
   Enabled: 'pending'
   VersionAdded: '1.7'
 
 Performance/StartWith:
   Description: 'Use `start_with?` instead of a regex match anchored to the beginning of a string.'
-  Reference: 'https://github.com/JuanitoFatas/fast-ruby#stringmatch-vs-stringstart_withstringend_with-code-start-code-end'
+  Reference: 'https://github.com/fastruby/fast-ruby#stringmatch-vs-stringmatch-vs-stringstart_withstringend_with-code-start-code-end'
   # This will change to a new method call which isn't guaranteed to be on the
   # object. Switching these methods has to be done with knowledge of the types
   # of the variables which rubocop doesn't have.
@@ -316,6 +326,12 @@ Performance/StartWith:
   VersionAdded: '0.36'
   VersionChanged: '1.10'
 
+Performance/StringBytesize:
+  Description: "Use `String#bytesize` instead of calculating the size of the bytes array."
+  Safe: false
+  Enabled: 'pending'
+  VersionAdded: '1.23'
+
 Performance/StringIdentifierArgument:
   Description: 'Use symbol identifier argument instead of string identifier argument.'
   Enabled: pending
@@ -333,7 +349,7 @@ Performance/StringReplacement:
                   Use `tr` instead of `gsub` when you are replacing the same
                   number of characters. Use `delete` instead of `gsub` when
                   you are deleting characters.
-  Reference: 'https://github.com/JuanitoFatas/fast-ruby#stringgsub-vs-stringtr-code'
+  Reference: 'https://github.com/fastruby/fast-ruby#stringgsub-vs-stringtr-code'
   Enabled: true
   VersionAdded: '0.33'
 

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

@@ -9,14 +9,14 @@ module RuboCop
 
       def_node_matcher :sort_with_block?, <<~PATTERN
         (block
-          $(send _ :sort)
+          $(call _ :sort)
           (args (arg $_a) (arg $_b))
           $send)
       PATTERN
 
       def_node_matcher :sort_with_numblock?, <<~PATTERN
         (numblock
-          $(send _ :sort)
+          $(call _ :sort)
           $_arg_count
           $send)
       PATTERN

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

@@ -39,7 +39,7 @@ module RuboCop
         RESTRICT_ON_SEND = SLICE_METHODS
 
         def_node_matcher :endless_range_slice?, <<~PATTERN
-          (send $_ $%SLICE_METHODS $#endless_range?)
+          (call $!{str dstr xstr} $%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,50 +3,74 @@
 module RuboCop
   module Cop
     module Performance
-      # Identifies places where numeric argument to BigDecimal should be
-      # converted to string. Initializing from String is faster
-      # than from Numeric for BigDecimal.
+      # Identifies places where a float argument to BigDecimal should be converted to a string.
+      # Initializing from String is faster than from Float for BigDecimal.
+      #
+      # Also identifies places where an integer string argument to BigDecimal should be converted to
+      # an integer. Initializing from Integer is faster than from String for BigDecimal.
       #
       # @example
       #   # bad
-      #   BigDecimal(1, 2)
-      #   4.to_d(6)
       #   BigDecimal(1.2, 3, exception: true)
       #   4.5.to_d(6, exception: true)
       #
       #   # good
-      #   BigDecimal('1', 2)
-      #   BigDecimal('4', 6)
       #   BigDecimal('1.2', 3, exception: true)
       #   BigDecimal('4.5', 6, exception: true)
       #
+      #   # bad
+      #   BigDecimal('1', 2)
+      #   BigDecimal('4', 6)
+      #
+      #   # good
+      #   BigDecimal(1, 2)
+      #   4.to_d(6)
+      #
       class BigDecimalWithNumericArgument < Base
         extend AutoCorrector
+        extend TargetRubyVersion
+
+        minimum_target_ruby_version 3.1
 
-        MSG = 'Convert numeric literal to string and pass it to `BigDecimal`.'
+        MSG_FROM_FLOAT_TO_STRING = 'Convert float literal to string and pass it to `BigDecimal`.'
+        MSG_FROM_INTEGER_TO_STRING = 'Convert string literal to integer and pass it to `BigDecimal`.'
         RESTRICT_ON_SEND = %i[BigDecimal to_d].freeze
 
-        def_node_matcher :big_decimal_with_numeric_argument?, <<~PATTERN
-          (send nil? :BigDecimal $numeric_type? ...)
+        def_node_matcher :big_decimal_with_numeric_argument, <<~PATTERN
+          (send nil? :BigDecimal ${float_type? str_type?} ...)
         PATTERN
 
-        def_node_matcher :to_d?, <<~PATTERN
-          (send [!nil? $numeric_type?] :to_d ...)
+        def_node_matcher :to_d, <<~PATTERN
+          (send [!nil? ${float_type? str_type?}] :to_d ...)
         PATTERN
 
+        # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity, Metrics/MethodLength
         def on_send(node)
-          if (numeric = big_decimal_with_numeric_argument?(node))
-            add_offense(numeric.source_range) do |corrector|
-              corrector.wrap(numeric, "'", "'")
+          if (numeric = big_decimal_with_numeric_argument(node))
+            if numeric.numeric_type?
+              add_offense(numeric, message: MSG_FROM_FLOAT_TO_STRING) do |corrector|
+                corrector.wrap(numeric, "'", "'")
+              end
+            elsif numeric.value.match?(/\A\d+\z/)
+              add_offense(numeric, message: MSG_FROM_INTEGER_TO_STRING) do |corrector|
+                corrector.replace(numeric, numeric.value)
+              end
             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(', ')
+          elsif (numeric_to_d = to_d(node))
+            if numeric_to_d.numeric_type?
+              add_offense(numeric_to_d, message: MSG_FROM_FLOAT_TO_STRING) do |corrector|
+                big_decimal_args = node.arguments.map(&:source).unshift("'#{numeric_to_d.source}'").join(', ')
 
-              corrector.replace(node, "BigDecimal(#{big_decimal_args})")
+                corrector.replace(node, "BigDecimal(#{big_decimal_args})")
+              end
+            elsif numeric_to_d.value.match?(/\A\d+\z/)
+              add_offense(numeric_to_d, message: MSG_FROM_INTEGER_TO_STRING) do |corrector|
+                corrector.replace(node, "#{numeric_to_d.value}.to_d")
+              end
             end
           end
         end
+        # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity, Metrics/MethodLength
       end
     end
   end

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

@@ -6,6 +6,9 @@ module RuboCop
       # Identifies unnecessary use of a `block_given?` where explicit check
       # of block argument would suffice.
       #
+      # NOTE: This cop produces code with significantly worse performance when a
+      # block is being passed to the method and as such should not be enabled.
+      #
       # @example
       #   # bad
       #   def method(&block)
@@ -47,6 +50,10 @@ module RuboCop
             corrector.replace(node, block_arg_name)
           end
         end
+
+        def self.autocorrect_incompatible_with
+          [Lint::UnusedMethodArgument]
+        end
       end
     end
   end

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

@@ -6,6 +6,12 @@ module RuboCop
       # Identifies places where a case-insensitive string comparison
       # can better be implemented using `casecmp`.
       #
+      # This cop is disabled by default because `String#casecmp` only works with
+      # ASCII characters. See https://github.com/rubocop/rubocop/issues/9753.
+      #
+      # If you are working only with ASCII characters, then this cop can be
+      # safely enabled.
+      #
       # @safety
       #   This cop is unsafe because `String#casecmp` and `String#casecmp?` behave
       #   differently when using Non-ASCII characters.

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

@@ -19,8 +19,6 @@ module RuboCop
       #   array.map! { |x| x.downcase }
       #   array
       class ChainArrayAllocation < Base
-        include RangeHelp
-
         # These methods return a new array but only sometimes. They must be
         # called with an argument. For example:
         #
@@ -54,7 +52,7 @@ module RuboCop
         def_node_matcher :chain_array_allocation?, <<~PATTERN
           (send {
             (send _ $%RETURN_NEW_ARRAY_WHEN_ARGS {int lvar ivar cvar gvar send})
-            (block (send _ $%ALWAYS_RETURNS_NEW_ARRAY) ...)
+            ({block numblock} (send _ $%ALWAYS_RETURNS_NEW_ARRAY) ...)
             (send _ $%RETURNS_NEW_ARRAY ...)
           } $%HAS_MUTATION_ALTERNATIVE ...)
         PATTERN
@@ -62,12 +60,21 @@ module RuboCop
         def on_send(node)
           chain_array_allocation?(node) do |fm, sm|
             return if node.each_descendant(:send).any? { |descendant| descendant.method?(:lazy) }
+            return if node.method?(:select) && !enumerable_select_method?(node.receiver)
 
-            range = range_between(node.loc.dot.begin_pos, node.source_range.end_pos)
+            range = node.loc.selector.begin.join(node.source_range.end)
 
             add_offense(range, message: format(MSG, method: fm, second_method: sm))
           end
         end
+
+        private
+
+        def enumerable_select_method?(node)
+          # NOTE: `QueryMethods#select` in Rails accepts positional arguments, whereas `Enumerable#select` does not.
+          #        This difference can be utilized to reduce the knowledge requirements related to `select`.
+          (node.block_type? || node.numblock_type?) && node.send_node.arguments.empty?
+        end
       end
     end
   end

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

@@ -9,8 +9,7 @@ module RuboCop
       #
       # @safety
       #   This cop is unsafe because it has known compatibility issues with `ActiveRecord` and other
-      #   frameworks. ActiveRecord's `count` ignores the block that is passed to it.
-      #   `ActiveRecord` will ignore the block that is passed to `count`.
+      #   frameworks. Before Rails 5.1, `ActiveRecord` will ignore the block that is passed to `count`.
       #   Other methods, such as `select`, will convert the association to an
       #   array and then run the block on the array. A simple work around to
       #   make `count` work with a block is to call `to_a.count {...}`.
@@ -19,14 +18,14 @@ module RuboCop
       #
       #   [source,ruby]
       #   ----
-      #   `Model.where(id: [1, 2, 3]).select { |m| m.method == true }.size`
+      #   Model.where(id: [1, 2, 3]).select { |m| m.method == true }.size
       #   ----
       #
       #   becomes:
       #
       #   [source,ruby]
       #   ----
-      #   `Model.where(id: [1, 2, 3]).to_a.count { |m| m.method == true }`
+      #   Model.where(id: [1, 2, 3]).to_a.count { |m| m.method == true }
       #   ----
       #
       # @example
@@ -55,8 +54,8 @@ module RuboCop
 
         def_node_matcher :count_candidate?, <<~PATTERN
           {
-            (send (block $(send _ ${:select :filter :find_all :reject}) ...) ${:count :length :size})
-            (send $(send _ ${:select :filter :find_all :reject} (:block_pass _)) ${:count :length :size})
+            (call (block $(call _ ${:select :filter :find_all :reject}) ...) ${:count :length :size})
+            (call $(call _ ${:select :filter :find_all :reject} (:block_pass _)) ${:count :length :size})
           }
         PATTERN
 
@@ -73,6 +72,7 @@ module RuboCop
             end
           end
         end
+        alias on_csend on_send
 
         private
 
@@ -101,7 +101,7 @@ module RuboCop
         end
 
         def negate_reject(corrector, node)
-          if node.receiver.send_type?
+          if node.receiver.call_type?
             negate_block_pass_reject(corrector, node)
           else
             negate_block_reject(corrector, node)

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

@@ -64,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?
@@ -80,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

@@ -64,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?
@@ -80,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/detect.rb

@@ -40,9 +40,9 @@ module RuboCop
 
         def_node_matcher :detect_candidate?, <<~PATTERN
           {
-            (send $(block (send _ %CANDIDATE_METHODS) ...) ${:first :last} $...)
+            (send $(block (call _ %CANDIDATE_METHODS) ...) ${:first :last} $...)
             (send $(block (send _ %CANDIDATE_METHODS) ...) $:[] (int ${0 -1}))
-            (send $(send _ %CANDIDATE_METHODS ...) ${:first :last} $...)
+            (send $(call _ %CANDIDATE_METHODS ...) ${:first :last} $...)
             (send $(send _ %CANDIDATE_METHODS ...) $:[] (int ${0 -1}))
           }
         PATTERN
@@ -63,6 +63,7 @@ module RuboCop
             register_offense(node, receiver, second_method, index)
           end
         end
+        alias on_csend on_send
 
         private
 

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

@@ -41,7 +41,7 @@ module RuboCop
       class DoubleStartEndWith < Base
         extend AutoCorrector
 
-        MSG = 'Use `%<receiver>s.%<method>s(%<combined_args>s)` instead of `%<original_code>s`.'
+        MSG = 'Use `%<replacement>s` instead of `%<original_code>s`.'
 
         def on_or(node)
           receiver, method, first_call_args, second_call_args = process_source(node)
@@ -50,7 +50,7 @@ module RuboCop
 
           combined_args = combine_args(first_call_args, second_call_args)
 
-          add_offense(node, message: message(node, receiver, method, combined_args)) do |corrector|
+          add_offense(node, message: message(node, receiver, first_call_args, method, combined_args)) do |corrector|
             autocorrect(corrector, first_call_args, second_call_args, combined_args)
           end
         end
@@ -73,10 +73,10 @@ module RuboCop
           end
         end
 
-        def message(node, receiver, method, combined_args)
-          format(
-            MSG, receiver: receiver.source, method: method, combined_args: combined_args, original_code: node.source
-          )
+        def message(node, receiver, first_call_args, method, combined_args)
+          dot = first_call_args.first.parent.send_type? ? '.' : '&.'
+          replacement = "#{receiver.source}#{dot}#{method}(#{combined_args})"
+          format(MSG, replacement: replacement, original_code: node.source)
         end
 
         def combine_args(first_call_args, second_call_args)
@@ -89,16 +89,16 @@ module RuboCop
 
         def_node_matcher :two_start_end_with_calls, <<~PATTERN
           (or
-            (send $_recv [{:start_with? :end_with?} $_method] $...)
-            (send _recv _method $...))
+            (call $_recv [{:start_with? :end_with?} $_method] $...)
+            (call _recv _method $...))
         PATTERN
 
         def_node_matcher :check_with_active_support_aliases, <<~PATTERN
           (or
-            (send $_recv
+            (call $_recv
                     [{:start_with? :starts_with? :end_with? :ends_with?} $_method]
                   $...)
-            (send _recv _method $...))
+            (call _recv _method $...))
         PATTERN
       end
     end

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

@@ -54,9 +54,10 @@ module RuboCop
         RESTRICT_ON_SEND = %i[match =~ match?].freeze
 
         def_node_matcher :redundant_regex?, <<~PATTERN
-          {(send $!nil? {:match :=~ :match?} (regexp (str $#literal_at_end?) (regopt)))
+          {(call $!nil? {:match :=~ :match?} (regexp (str $#literal_at_end?) (regopt)))
            (send (regexp (str $#literal_at_end?) (regopt)) {:match :match?} $_)
-           (match-with-lvasgn (regexp (str $#literal_at_end?) (regopt)) $_)}
+           ({send match-with-lvasgn} (regexp (str $#literal_at_end?) (regopt)) $_)
+           (send (regexp (str $#literal_at_end?) (regopt)) :=~ $_)}
         PATTERN
 
         def on_send(node)
@@ -66,12 +67,14 @@ module RuboCop
             receiver, regex_str = regex_str, receiver if receiver.is_a?(String)
             regex_str = drop_end_metacharacter(regex_str)
             regex_str = interpret_string_escapes(regex_str)
+            dot = node.loc.dot ? node.loc.dot.source : '.'
 
-            new_source = "#{receiver.source}.end_with?(#{to_string_literal(regex_str)})"
+            new_source = "#{receiver.source}#{dot}end_with?(#{to_string_literal(regex_str)})"
 
             corrector.replace(node, new_source)
           end
         end
+        alias on_csend on_send
         alias on_match_with_lvasgn on_send
       end
     end