rubocop-performance 1.19.1 → 1.21.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1fa48a119a4c26e989f4d73366c0cbac4bbe854453a702e49f0af9348b1cf798
-  data.tar.gz: e63e391f5f6e2ab2500033cd83df591b9d48254e7f295ce69bbb352e5242c67a
+  metadata.gz: c00ee718f283199f3c4f53b54071998b356f7239edcd3c84015bac94ad1b05dc
+  data.tar.gz: a5e7d011cd090fd5d30eb0ef9e12acabb93a993cc3acb46129da46c37294e1ba
 SHA512:
-  metadata.gz: 98939001b2b61212c3b4bab44c8b9f9ae8bd906eeb873e2a9516b075f896679fbd513c23c874555982a14d390d265fe01451c218860249ff18376d89f1f59709
-  data.tar.gz: ce73767335d2fe19418afa72ca4a8c5c15632960a2d77282b1042c002c65ec1d744af929fc3b612ba5f7c7e7a5cbaa35aab978fcc8a57e7dde02b114c8fc873b
+  metadata.gz: 711efd2eae8c54dc1b567e198360038fb16eee00c2e6a61db7dbcfb063f219618e36809ac5679cc531e8fe84245ea1f66e6e8eb9fbed5cbb9dcc22f57c10dab6
+  data.tar.gz: 5618f678392ffb6f93b34388e3ef060c017f7e70b53d992ebe48d2bb49b7ec5570adc7b21f5f22f0511cddc4fb1dead044904d7bcf40949191ee6ed8b884565f

data/README.md

@@ -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'
@@ -54,10 +54,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 +123,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 +146,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 +166,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 +177,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
@@ -201,7 +202,7 @@ Performance/MapMethodChain:
 
 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'
 
@@ -213,7 +214,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'
@@ -221,7 +222,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'
 
@@ -244,7 +245,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'
@@ -271,13 +272,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'
 
@@ -295,7 +296,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'
 
@@ -306,13 +307,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.
@@ -339,7 +340,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/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 {...}`.
@@ -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/end_with.rb

@@ -56,7 +56,8 @@ module RuboCop
         def_node_matcher :redundant_regex?, <<~PATTERN
           {(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)

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

@@ -50,7 +50,7 @@ module RuboCop
         RESTRICT_ON_SEND = %i[count length size].freeze
 
         def_node_matcher :counter, <<~MATCHER
-          (send ${array hash str sym} {:count :length :size} $...)
+          (call ${array hash str sym} {:count :length :size} $...)
         MATCHER
 
         def on_send(node)
@@ -62,6 +62,7 @@ module RuboCop
             add_offense(node)
           end
         end
+        alias on_csend on_send
 
         private
 

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

@@ -26,10 +26,10 @@ module RuboCop
                                   'multiple levels.'
 
         def_node_matcher :flat_map_candidate?, <<~PATTERN
-          (send
+          (call
             {
-              $(block (send _ ${:collect :map}) ...)
-              $(send _ ${:collect :map} (block_pass _))
+              $(block (call _ ${:collect :map}) ...)
+              $(call _ ${:collect :map} (block_pass _))
             }
             ${:flatten :flatten!}
             $...
@@ -46,6 +46,7 @@ module RuboCop
             end
           end
         end
+        alias on_csend on_send
 
         private
 

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

@@ -45,7 +45,7 @@ module RuboCop
         RESTRICT_ON_SEND = %i[include?].freeze
 
         def_node_matcher :inefficient_include?, <<~PATTERN
-          (send (call $_ {:keys :values}) :include? _)
+          (call (call $_ {:keys :values}) :include? _)
         PATTERN
 
         def on_send(node)
@@ -89,7 +89,7 @@ module RuboCop
         end
 
         def correct_argument(node)
-          node.arguments.first.source
+          node.first_argument.source
         end
 
         def correct_hash_expression(node)

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

@@ -39,11 +39,11 @@ module RuboCop
 
         def_node_matcher :map_compact, <<~PATTERN
           {
-            (send
+            (call
               $(call _ {:map :collect}
                 (block_pass
                   (sym _))) _)
-            (send
+            (call
               (block
                 $(call _ {:map :collect})
                   (args ...) _) _)

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

@@ -68,6 +68,7 @@ module RuboCop
 
         private
 
+        # rubocop:disable Metrics/CyclomaticComplexity
         def find_begin_of_chained_map_method(node, map_args)
           return unless (chained_map_method = node.receiver)
           return if !chained_map_method.call_type? || !RESTRICT_ON_SEND.include?(chained_map_method.method_name)
@@ -77,10 +78,11 @@ module RuboCop
 
           receiver = chained_map_method.receiver
 
-          return chained_map_method unless receiver.call_type? && block_pass_with_symbol_arg?(receiver.first_argument)
+          return chained_map_method unless receiver&.call_type? && block_pass_with_symbol_arg?(receiver.first_argument)
 
           find_begin_of_chained_map_method(chained_map_method, map_args)
         end
+        # rubocop:enable Metrics/CyclomaticComplexity
       end
     end
   end

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

@@ -38,7 +38,7 @@ module RuboCop
         # (We don't even catch it if the Range is in double parens)
 
         def_node_matcher :range_include, <<~PATTERN
-          (send {irange erange (begin {irange erange})} ${:include? :member?} ...)
+          (call {irange erange (begin {irange erange})} ${:include? :member?} ...)
         PATTERN
 
         def on_send(node)
@@ -50,6 +50,7 @@ module RuboCop
             end
           end
         end
+        alias on_csend on_send
       end
     end
   end

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

@@ -49,6 +49,8 @@ module RuboCop
             next unless body
 
             calls_to_report(argname, body).each do |blockcall|
+              next if blockcall.block_literal?
+
               add_offense(blockcall, message: format(MSG, argname: argname)) do |corrector|
                 autocorrect(corrector, blockcall)
               end

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

@@ -63,7 +63,7 @@ module RuboCop
           return unless TARGET_METHODS.include?(node.method_name)
           return unless one_block_argument?(node.arguments)
 
-          block_argument = node.arguments.first
+          block_argument = node.first_argument
           block_body = node.body
           return unless use_equality_comparison_block?(block_body)
           return if same_block_argument_and_is_a_argument?(block_body, block_argument)

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

@@ -130,7 +130,9 @@ module RuboCop
         end
 
         def rewrite_with_modifier(node, parent, new_source)
-          indent = ' ' * configured_indentation_width
+          # FIXME: `|| 2` can be removed when support is limited to RuboCop 1.44 or higher.
+          # https://github.com/rubocop/rubocop/commit/02d1e5b
+          indent = ' ' * (configured_indentation_width || 2)
           padding = "\n#{indent + leading_spaces(node)}"
           new_source.gsub!("\n", padding)
 

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

@@ -248,7 +248,7 @@ module RuboCop
         end
 
         def correct_operator(corrector, recv, arg, oper = nil)
-          op_range = correction_range(recv, arg)
+          op_range = recv.source_range.end.join(arg.source_range.begin)
 
           replace_with_match_predicate_method(corrector, recv, arg, op_range)
 
@@ -271,13 +271,6 @@ module RuboCop
           corrector.replace(recv, arg.source)
           corrector.replace(arg, recv.source)
         end
-
-        def correction_range(recv, arg)
-          buffer = processed_source.buffer
-          op_begin_pos = recv.source_range.end_pos
-          op_end_pos = arg.source_range.begin_pos
-          Parser::Source::Range.new(buffer, op_begin_pos, op_end_pos)
-        end
       end
     end
   end

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

@@ -27,7 +27,7 @@ module RuboCop
         RESTRICT_ON_SEND = %i[each].freeze
 
         def_node_matcher :reverse_each?, <<~MATCHER
-          (send (call _ :reverse) :each)
+          (call (call _ :reverse) :each)
         MATCHER
 
         def on_send(node)

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

@@ -24,13 +24,13 @@ module RuboCop
         RESTRICT_ON_SEND = %i[first].freeze
 
         def_node_matcher :reverse_first_candidate?, <<~PATTERN
-          (send $(call _ :reverse) :first (int _)?)
+          (call $(call _ :reverse) :first (int _)?)
         PATTERN
 
         def on_send(node)
           reverse_first_candidate?(node) do |receiver|
             range = correction_range(receiver, node)
-            message = build_message(node)
+            message = build_message(node, range)
 
             add_offense(range, message: message) do |corrector|
               replacement = build_good_method(node)
@@ -47,27 +47,19 @@ module RuboCop
           range_between(receiver.loc.selector.begin_pos, node.source_range.end_pos)
         end
 
-        def build_message(node)
+        def build_message(node, range)
           good_method = build_good_method(node)
-          bad_method = build_bad_method(node)
+          bad_method = range.source
           format(MSG, good_method: good_method, bad_method: bad_method)
         end
 
         def build_good_method(node)
           if node.arguments?
-            "last(#{node.arguments.first.source}).reverse"
+            "last(#{node.first_argument.source})#{node.loc.dot.source}reverse"
           else
             'last'
           end
         end
-
-        def build_bad_method(node)
-          if node.arguments?
-            "reverse.first(#{node.arguments.first.source})"
-          else
-            'reverse.first'
-          end
-        end
       end
     end
   end

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

@@ -24,10 +24,6 @@ module RuboCop
         MSG = 'Use `filter_map` instead of `%<method_name>s.map`.'
         RESTRICT_ON_SEND = %i[select filter].freeze
 
-        def_node_matcher :bad_method?, <<~PATTERN
-          (send nil? :bad_method ...)
-        PATTERN
-
         def on_send(node)
           return if (first_argument = node.first_argument) && !first_argument.block_pass_type?
           return unless (send_node = map_method_candidate(node))
@@ -45,9 +41,9 @@ module RuboCop
         def map_method_candidate(node)
           return unless (parent = node.parent)
 
-          if parent.block_type? && parent.parent&.send_type?
+          if parent.block_type? && parent.parent&.call_type?
             parent.parent
-          elsif parent.send_type?
+          elsif parent.call_type?
             parent
           end
         end

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

@@ -43,7 +43,7 @@ module RuboCop
         def_node_matcher :array?, <<~PATTERN
           {
             [!nil? array_type?]
-            (send _ :to_a)
+            (call _ :to_a)
             (send (const nil? :Array) :[] _)
             (send nil? :Array _)
           }
@@ -52,14 +52,14 @@ module RuboCop
         def_node_matcher :hash?, <<~PATTERN
           {
             [!nil? hash_type?]
-            (send _ :to_h)
+            (call _ :to_h)
             (send (const nil? :Hash) :[] _)
             (send nil? :Hash _)
           }
         PATTERN
 
         def_node_matcher :count?, <<~PATTERN
-          (send {#array? #hash?} :count)
+          (call {#array? #hash?} :count)
         PATTERN
 
         def on_send(node)
@@ -69,6 +69,7 @@ module RuboCop
             corrector.replace(node.loc.selector, 'size')
           end
         end
+        alias on_csend on_send
       end
     end
   end

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

@@ -17,7 +17,7 @@ module RuboCop
         include SortBlock
         extend AutoCorrector
 
-        MSG = 'Use `sort.reverse` instead.'
+        MSG = 'Use `%<prefer>s` instead.'
 
         def on_block(node)
           sort_with_block?(node) do |send, var_a, var_b, body|
@@ -41,11 +41,12 @@ module RuboCop
 
         def register_offense(send, node)
           range = sort_range(send, node)
+          prefer = "sort#{send.loc.dot.source}reverse"
 
-          add_offense(range) do |corrector|
-            replacement = 'sort.reverse'
+          message = format(MSG, prefer: prefer)
 
-            corrector.replace(range, replacement)
+          add_offense(range, message: message) do |corrector|
+            corrector.replace(range, prefer)
           end
         end
       end

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

@@ -56,7 +56,8 @@ module RuboCop
         def_node_matcher :redundant_regex?, <<~PATTERN
           {(call $!nil? {:match :=~ :match?} (regexp (str $#literal_at_start?) (regopt)))
            (send (regexp (str $#literal_at_start?) (regopt)) {:match :match?} $_)
-           (match-with-lvasgn (regexp (str $#literal_at_start?) (regopt)) $_)}
+           (match-with-lvasgn (regexp (str $#literal_at_start?) (regopt)) $_)
+           (send (regexp (str $#literal_at_start?) (regopt)) :=~ $_)}
         PATTERN
 
         def on_send(node)

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

@@ -16,11 +16,19 @@ module RuboCop
       #   send('do_something')
       #   attr_accessor 'do_something'
       #   instance_variable_get('@ivar')
+      #   respond_to?("string_#{interpolation}")
       #
       #   # good
       #   send(:do_something)
       #   attr_accessor :do_something
       #   instance_variable_get(:@ivar)
+      #   respond_to?(:"string_#{interpolation}")
+      #
+      #   # good - these methods don't support namespaced symbols
+      #   const_get("#{module_path}::Base")
+      #   const_source_location("#{module_path}::Base")
+      #   const_defined?("#{module_path}::Base")
+      #
       #
       class StringIdentifierArgument < Base
         extend AutoCorrector
@@ -32,33 +40,73 @@ module RuboCop
           protected public public_constant module_function
         ].freeze
 
+        INTERPOLATION_IGNORE_METHODS = %i[const_get const_source_location const_defined?].freeze
+
+        TWO_ARGUMENTS_METHOD = :alias_method
+        MULTIPLE_ARGUMENTS_METHODS = %i[
+          attr_accessor attr_reader attr_writer private private_constant
+          protected public public_constant module_function
+        ].freeze
+
         # NOTE: `attr` method is not included in this list as it can cause false positives in Nokogiri API.
         # And `attr` may not be used because `Style/Attr` registers an offense.
         # https://github.com/rubocop/rubocop-performance/issues/278
         RESTRICT_ON_SEND = (%i[
-          class_variable_defined? const_defined? const_get const_set const_source_location
+          class_variable_defined? const_set
           define_method instance_method method_defined? private_class_method? private_method_defined?
           protected_method_defined? public_class_method public_instance_method public_method_defined?
           remove_class_variable remove_method undef_method class_variable_get class_variable_set
           deprecate_constant remove_const ruby2_keywords define_singleton_method instance_variable_defined?
           instance_variable_get instance_variable_set method public_method public_send remove_instance_variable
           respond_to? send singleton_method __send__
-        ] + COMMAND_METHODS).freeze
+        ] + COMMAND_METHODS + INTERPOLATION_IGNORE_METHODS).freeze
 
         def on_send(node)
           return if COMMAND_METHODS.include?(node.method_name) && node.receiver
-          return unless (first_argument = node.first_argument)
-          return unless first_argument.str_type?
 
-          first_argument_value = first_argument.value
-          return if first_argument_value.include?(' ') || first_argument_value.include?('::')
+          string_arguments(node).each do |string_argument|
+            string_argument_value = string_argument.value
+            next if string_argument_value.include?(' ') || string_argument_value.include?('::')
+
+            register_offense(string_argument, string_argument_value)
+          end
+        end
+
+        private
 
-          replacement = first_argument_value.to_sym.inspect
+        def string_arguments(node)
+          arguments = if node.method?(TWO_ARGUMENTS_METHOD)
+                        [node.first_argument, node.arguments[1]]
+                      elsif MULTIPLE_ARGUMENTS_METHODS.include?(node.method_name)
+                        node.arguments
+                      else
+                        [node.first_argument]
+                      end
 
-          message = format(MSG, symbol_arg: replacement, string_arg: first_argument.source)
+          arguments.compact.filter { |argument| string_argument_compatible?(argument, node) }
+        end
+
+        def string_argument_compatible?(argument, node)
+          return true if argument.str_type?
+
+          argument.dstr_type? && INTERPOLATION_IGNORE_METHODS.none? { |method| node.method?(method) }
+        end
+
+        def register_offense(argument, argument_value)
+          replacement = argument_replacement(argument, argument_value)
+
+          message = format(MSG, symbol_arg: replacement, string_arg: argument.source)
+
+          add_offense(argument, message: message) do |corrector|
+            corrector.replace(argument, replacement)
+          end
+        end
 
-          add_offense(first_argument, message: message) do |corrector|
-            corrector.replace(first_argument, replacement)
+        def argument_replacement(node, value)
+          if node.str_type?
+            value.to_sym.inspect
+          else
+            ":\"#{value.to_sym}\""
           end
         end
       end

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

@@ -16,6 +16,7 @@ module RuboCop
       #   /ab/ =~ str
       #   str.match(/ab/)
       #   /ab/.match(str)
+      #   /ab/ === str
       #
       #   # good
       #   str.include?('ab')
@@ -23,12 +24,13 @@ module RuboCop
         extend AutoCorrector
 
         MSG = 'Use `%<negation>sString#include?` instead of a regex match with literal-only pattern.'
-        RESTRICT_ON_SEND = %i[match =~ !~ match?].freeze
+        RESTRICT_ON_SEND = %i[match =~ !~ match? ===].freeze
 
         def_node_matcher :redundant_regex?, <<~PATTERN
           {(call $!nil? {:match :=~ :!~ :match?} (regexp (str $#literal?) (regopt)))
-           (send (regexp (str $#literal?) (regopt)) {:match :match?} $_)
-           (match-with-lvasgn (regexp (str $#literal?) (regopt)) $_)}
+           (send (regexp (str $#literal?) (regopt)) {:match :match? :===} $_)
+           (match-with-lvasgn (regexp (str $#literal?) (regopt)) $_)
+           (send (regexp (str $#literal?) (regopt)) :=~ $_)}
         PATTERN
 
         # rubocop:disable Metrics/AbcSize

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

@@ -80,21 +80,21 @@ module RuboCop
         RESTRICT_ON_SEND = %i[inject reduce sum].freeze
 
         def_node_matcher :sum_candidate?, <<~PATTERN
-          (send _ ${:inject :reduce} $_init ? ${(sym :+) (block_pass (sym :+))})
+          (call _ ${:inject :reduce} $_init ? ${(sym :+) (block_pass (sym :+))})
         PATTERN
 
         def_node_matcher :sum_map_candidate?, <<~PATTERN
-          (send
+          (call
             {
-              (block $(send _ {:map :collect}) ...)
-              $(send _ {:map :collect} (block_pass _))
+              (block $(call _ {:map :collect}) ...)
+              $(call _ {:map :collect} (block_pass _))
             }
           :sum $_init ?)
         PATTERN
 
         def_node_matcher :sum_with_block_candidate?, <<~PATTERN
           (block
-            $(send _ {:inject :reduce} $_init ?)
+            $(call _ {:inject :reduce} $_init ?)
             (args (arg $_acc) (arg $_elem))
             $send)
         PATTERN
@@ -110,6 +110,7 @@ module RuboCop
           handle_sum_candidate(node)
           handle_sum_map_candidate(node)
         end
+        alias on_csend on_send
 
         def on_block(node)
           sum_with_block_candidate?(node) do |send, init, var_acc, var_elem, body|
@@ -143,7 +144,7 @@ module RuboCop
           sum_map_candidate?(node) do |map, init|
             next if node.block_literal? || node.block_argument?
 
-            message = build_sum_map_message(map.method_name, init)
+            message = build_sum_map_message(map, init)
 
             add_offense(sum_map_range(map, node), message: message) do |corrector|
               autocorrect_sum_map(corrector, node, map, init)
@@ -178,7 +179,7 @@ module RuboCop
 
           corrector.remove(sum_range)
 
-          dot = '.' if map.receiver
+          dot = map.loc.dot&.source || ''
           corrector.replace(map_range, "#{dot}#{replacement}")
         end
 
@@ -205,10 +206,11 @@ module RuboCop
           format(msg, good_method: good_method, bad_method: bad_method)
         end
 
-        def build_sum_map_message(method, init)
+        def build_sum_map_message(send_node, init)
           sum_method = build_good_method(init)
           good_method = "#{sum_method} { ... }"
-          bad_method = "#{method} { ... }.#{sum_method}"
+          dot = send_node.loc.dot&.source || '.'
+          bad_method = "#{send_node.method_name} { ... }#{dot}#{sum_method}"
           format(MSG, good_method: good_method, bad_method: bad_method)
         end
 

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

@@ -39,6 +39,7 @@ module RuboCop
         def on_send(node)
           check(node)
         end
+        alias on_csend on_send
 
         def on_block(node)
           check(node)
@@ -49,6 +50,8 @@ module RuboCop
 
         def check(node)
           times_map_call(node) do |map_or_collect, count|
+            next unless handleable_receiver?(node)
+
             add_offense(node, message: message(map_or_collect, count)) do |corrector|
               replacement = "Array.new(#{count.source}#{map_or_collect.arguments.map { |arg| ", #{arg.source}" }.join})"
 
@@ -57,6 +60,13 @@ module RuboCop
           end
         end
 
+        def handleable_receiver?(node)
+          receiver = node.receiver.receiver
+          return true if receiver.literal? && (receiver.int_type? || receiver.float_type?)
+
+          node.receiver.dot?
+        end
+
         def message(map_or_collect, count)
           template = if count.literal?
                        "#{MESSAGE}."
@@ -67,8 +77,10 @@ module RuboCop
         end
 
         def_node_matcher :times_map_call, <<~PATTERN
-          {({block numblock} $(send (send $!nil? :times) {:map :collect}) ...)
-           $(send (send $!nil? :times) {:map :collect} (block_pass ...))}
+          {
+            ({block numblock} $(call (call $!nil? :times) {:map :collect}) ...)
+            $(call (call $!nil? :times) {:map :collect} (block_pass ...))
+          }
         PATTERN
       end
     end

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

@@ -15,8 +15,8 @@ module RuboCop
       #
       # @example
       #   # bad
-      #   ''.dup
-      #   "something".dup
+      #   ''.dup          # when Ruby 3.2 or lower
+      #   "something".dup # when Ruby 3.2 or lower
       #   String.new
       #   String.new('')
       #   String.new('something')
@@ -45,7 +45,7 @@ module RuboCop
         PATTERN
 
         def on_send(node)
-          return unless dup_string?(node) || string_new?(node)
+          return unless (dup_string?(node) && target_ruby_version <= 3.2) || string_new?(node)
 
           add_offense(node) do |corrector|
             string_value = "+#{string_value(node)}"

data/lib/rubocop/performance/version.rb

@@ -4,7 +4,7 @@ module RuboCop
   module Performance
     # This module holds the RuboCop Performance version information.
     module Version
-      STRING = '1.19.1'
+      STRING = '1.21.0'
 
       def self.document_version
         STRING.match('\d+\.\d+').to_s

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rubocop-performance
 version: !ruby/object:Gem::Version
-  version: 1.19.1
+  version: 1.21.0
 platform: ruby
 authors:
 - Bozhidar Batsov
@@ -10,7 +10,7 @@ authors:
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-09-17 00:00:00.000000000 Z
+date: 2024-03-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rubocop
@@ -18,7 +18,7 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 1.7.0
+        version: 1.48.1
     - - "<"
       - !ruby/object:Gem::Version
         version: '2.0'
@@ -28,7 +28,7 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 1.7.0
+        version: 1.48.1
     - - "<"
       - !ruby/object:Gem::Version
         version: '2.0'
@@ -38,14 +38,20 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.4.0
+        version: 1.31.1
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '2.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.4.0
+        version: 1.31.1
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '2.0'
 description: |
   A collection of RuboCop cops to check for performance optimizations
   in Ruby code.
@@ -124,7 +130,7 @@ metadata:
   homepage_uri: https://docs.rubocop.org/rubocop-performance/
   changelog_uri: https://github.com/rubocop/rubocop-performance/blob/master/CHANGELOG.md
   source_code_uri: https://github.com/rubocop/rubocop-performance/
-  documentation_uri: https://docs.rubocop.org/rubocop-performance/1.19/
+  documentation_uri: https://docs.rubocop.org/rubocop-performance/1.21/
   bug_tracker_uri: https://github.com/rubocop/rubocop-performance/issues
   rubygems_mfa_required: 'true'
 post_install_message:
@@ -142,7 +148,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.5.0.dev
+rubygems_version: 3.5.3
 signing_key:
 specification_version: 4
 summary: Automatic performance checking tool for Ruby code.