rubocop-performance 1.14.3 → 1.16.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7716dc36d8facd9d8604d89d117f85db5fed60efcad66ad8354d673492800140
-  data.tar.gz: 59f4dd4e4df5afef36700a8951e8e91e18567ba978506d9aa02884abafc6d639
+  metadata.gz: 7b0361feae763e4c8cbea3bd0160a1e4b0646b2e3b3246fb8dd55a5f21a53acd
+  data.tar.gz: 152d09678555d309441fb809f60b07b69b04289b3949bf1eaca3e9b70b3afe13
 SHA512:
-  metadata.gz: 748977ac053ddab36afda43c709eee6424957a81ce18daf1048cf42399226e0d2d67f9964ba544594a03862d5650eff369a34b407d49892d72957ab3acf2ca11
-  data.tar.gz: 9a785cd79f0e781643720fd19e2454d6b1cac890c215d5a44762e4173d69e9f6ec6adc57fe43646dba7b3e48bf86663842f595f54db1f51c7e251af75113ecee
+  metadata.gz: 9f08bd2f25c0e0e537bf8fa5378e701d6b6b6794a45fe534229e73a0dd4bd623dd415965966655a802cc8e93a3776880d99c89245947aae090ba2c49f0bb183f
+  data.tar.gz: 34f697ee70070d32d17b3684712cec5628e71cbdb393722fec3bb0dbc541cf65af92a762907dbbb0c5e6c3023f8dd4738e06a131a5a28014749dac440e15bc92

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/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'

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/big_decimal_with_numeric_argument.rb

@@ -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/case_when_splat.rb

@@ -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].loc.expression.begin_pos, conditions[-1].loc.expression.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.source_range, 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)..]
+          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/chain_array_allocation.rb

@@ -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

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

@@ -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/constant_regexp.rb

@@ -39,9 +39,7 @@ module RuboCop
         MSG = 'Extract this regexp into a constant, memoize it, or append an `/o` option to its options.'
 
         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

@@ -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.loc.expression.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/detect.rb

@@ -8,9 +8,12 @@ module RuboCop
       # `detect` instead.
       #
       # @safety
-      #   This cop is unsafe because is 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 should be considered unsafe.
+      #   This cop is unsafe because is assumes the class implements the
+      #   `Enumerable` interface, but can't reliably detect this. This creates
+      #   known compatibility issues with `Hash`, `ActiveRecord` and other
+      #   frameworks. `Hash` and `ActiveRecord` do not implement a `detect`
+      #   method and `find` has its own meaning. Correcting `Hash` and
+      #   `ActiveRecord` methods with this cop should be considered unsafe.
       #
       # @example
       #   # bad

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

@@ -41,8 +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 `%<receiver>s.%<method>s(%<combined_args>s)` instead of `%<original_code>s`.'
 
         def on_or(node)
           receiver, method, first_call_args, second_call_args = process_source(node)

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

@@ -50,8 +50,7 @@ module RuboCop
         include RegexpMetacharacter
         extend AutoCorrector
 
-        MSG = 'Use `String#end_with?` instead of a regex match anchored to ' \
-              'the end of the string.'
+        MSG = 'Use `String#end_with?` instead of a regex match anchored to the end of the string.'
         RESTRICT_ON_SEND = %i[match =~ match?].freeze
 
         def_node_matcher :redundant_regex?, <<~PATTERN

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

@@ -83,9 +83,7 @@ module RuboCop
 
         def use_long_method
           preferred_config = config.for_all_cops['Style/PreferredHashMethods']
-          preferred_config &&
-            preferred_config['EnforcedStyle'] == 'long' &&
-            preferred_config['Enabled']
+          preferred_config && preferred_config['EnforcedStyle'] == 'long' && preferred_config['Enabled']
         end
 
         def autocorrect_argument(node)

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

@@ -67,7 +67,7 @@ module RuboCop
         def remove_compact_method(corrector, map_node, compact_node, chained_method)
           compact_method_range = compact_node.loc.selector
 
-          if compact_node.multiline? && chained_method&.loc.respond_to?(:selector) && chained_method.dot? &&
+          if compact_node.multiline? && chained_method&.loc.respond_to?(:selector) && use_dot?(chained_method) &&
              !map_method_and_compact_method_on_same_line?(map_node, compact_node) &&
              !invoke_method_after_map_compact_on_same_line?(compact_node, chained_method)
             compact_method_range = compact_method_with_final_newline_range(compact_method_range)
@@ -78,6 +78,10 @@ module RuboCop
           corrector.remove(compact_method_range)
         end
 
+        def use_dot?(node)
+          node.respond_to?(:dot?) && node.dot?
+        end
+
         def map_method_and_compact_method_on_same_line?(map_node, compact_node)
           compact_node.loc.selector.line == map_node.loc.selector.line
         end

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

@@ -32,8 +32,7 @@ module RuboCop
       #   end
       #
       class OpenStruct < Base
-        MSG = 'Consider using `Struct` over `OpenStruct` ' \
-              'to optimize the performance.'
+        MSG = 'Consider using `Struct` over `OpenStruct` to optimize the performance.'
         RESTRICT_ON_SEND = %i[new].freeze
 
         def_node_matcher :open_struct, <<~PATTERN

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

@@ -20,8 +20,7 @@ module RuboCop
       class RedundantMatch < Base
         extend AutoCorrector
 
-        MSG = 'Use `=~` in places where the `MatchData` returned by ' \
-              '`#match` will not be used.'
+        MSG = 'Use `=~` in places where the `MatchData` returned by `#match` will not be used.'
         RESTRICT_ON_SEND = %i[match].freeze
 
         # 'match' is a fairly generic name, so we don't flag it unless we see
@@ -41,21 +40,23 @@ module RuboCop
                         !(node.parent && node.parent.block_type?)
 
           add_offense(node) do |corrector|
-            autocorrect(corrector, node)
+            autocorrect(corrector, node) if autocorrectable?(node)
           end
         end
 
         private
 
         def autocorrect(corrector, node)
-          # Regexp#match can take a second argument, but this cop doesn't
-          # register an offense in that case
-          return unless node.first_argument.regexp_type?
-
           new_source = "#{node.receiver.source} =~ #{node.first_argument.source}"
 
           corrector.replace(node.source_range, new_source)
         end
+
+        def autocorrectable?(node)
+          # Regexp#match can take a second argument, but this cop doesn't
+          # register an offense in that case
+          node.receiver.regexp_type? || node.first_argument.regexp_type?
+        end
       end
     end
   end

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

@@ -28,6 +28,7 @@ module RuboCop
       #   hash[:a] = 1
       #   hash[:b] = 2
       class RedundantMerge < Base
+        include Alignment
         extend AutoCorrector
 
         AREF_ASGN = '%<receiver>s[%<key>s] = %<value>s'
@@ -99,8 +100,7 @@ module RuboCop
         end
 
         def non_redundant_value_used?(receiver, node)
-          node.value_used? &&
-            !EachWithObjectInspector.new(node, receiver).value_used?
+          node.value_used? && !EachWithObjectInspector.new(node, receiver).value_used?
         end
 
         def correct_multiple_elements(corrector, node, parent, new_source)
@@ -125,14 +125,12 @@ module RuboCop
 
             key = key.sym_type? && pair.colon? ? ":#{key.source}" : key.source
 
-            format(AREF_ASGN, receiver: receiver.source,
-                              key: key,
-                              value: value.source)
+            format(AREF_ASGN, receiver: receiver.source, key: key, value: value.source)
           end
         end
 
         def rewrite_with_modifier(node, parent, new_source)
-          indent = ' ' * indent_width
+          indent = ' ' * configured_indentation_width
           padding = "\n#{indent + leading_spaces(node)}"
           new_source.gsub!(/\n/, padding)
 
@@ -147,10 +145,6 @@ module RuboCop
           node.source_range.source_line[/\A\s*/]
         end
 
-        def indent_width
-          @config.for_cop('Layout/IndentationWidth')['Width'] || 2
-        end
-
         def max_key_value_pairs
           Integer(cop_config['MaxKeyValuePairs'] || 2)
         end

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

@@ -16,25 +16,33 @@ module RuboCop
         include SortBlock
         extend AutoCorrector
 
-        MSG = 'Use `sort` instead of `%<bad_method>s`.'
+        MSG = 'Use `sort` without block.'
 
         def on_block(node)
           return unless (send, var_a, var_b, body = sort_with_block?(node))
 
           replaceable_body?(body, var_a, var_b) do
-            range = sort_range(send, node)
+            register_offense(send, node)
+          end
+        end
+
+        def on_numblock(node)
+          return unless (send, arg_count, body = sort_with_numblock?(node))
+          return unless arg_count == 2
 
-            add_offense(range, message: message(var_a, var_b)) do |corrector|
-              corrector.replace(range, 'sort')
-            end
+          replaceable_body?(body, :_1, :_2) do
+            register_offense(send, node)
           end
         end
 
         private
 
-        def message(var_a, var_b)
-          bad_method = "sort { |#{var_a}, #{var_b}| #{var_a} <=> #{var_b} }"
-          format(MSG, bad_method: bad_method)
+        def register_offense(send, node)
+          range = sort_range(send, node)
+
+          add_offense(range) do |corrector|
+            corrector.replace(range, 'sort')
+          end
         end
       end
     end

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

@@ -9,6 +9,7 @@ module RuboCop
       #   # bad
       #   str.chars[0..2]
       #   str.chars.slice(0..2)
+      #   str.chars.last
       #
       #   # good
       #   str[0..2].chars
@@ -20,6 +21,7 @@ module RuboCop
       #   # good
       #   str[0]
       #   str[0...2].chars
+      #   str[-1]
       #
       #   # bad
       #   str.chars.take(2)
@@ -33,9 +35,8 @@ module RuboCop
       #   str.size
       #   str.empty?
       #
-      #   # For example, if the receiver is a blank string, it will be incompatible.
+      #   # For example, if the receiver is an empty string, it will be incompatible.
       #   # If a negative value is specified for the receiver, `nil` is returned.
-      #   str.chars.last    # Incompatible with `str[-1]`.
       #   str.chars.last(2) # Incompatible with `str[-2..-1].chars`.
       #   str.chars.drop(2) # Incompatible with `str[2..-1].chars`.
       #
@@ -44,7 +45,7 @@ module RuboCop
         extend AutoCorrector
 
         MSG = 'Use `%<good_method>s` instead of `%<bad_method>s`.'
-        RESTRICT_ON_SEND = %i[[] slice first take length size empty?].freeze
+        RESTRICT_ON_SEND = %i[[] slice first last take length size empty?].freeze
 
         def_node_matcher :redundant_chars_call?, <<~PATTERN
           (send $(send _ :chars) $_ $...)
@@ -52,6 +53,7 @@ module RuboCop
 
         def on_send(node)
           return unless (receiver, method, args = redundant_chars_call?(node))
+          return if method == :last && !args.empty?
 
           range = offense_range(receiver, node)
           message = build_message(method, args)
@@ -86,6 +88,8 @@ module RuboCop
             "[#{build_call_args(args)}].chars"
           when :[], :first
             build_good_method_for_brackets_or_first_method(method, args)
+          when :last
+            '[-1]'
           when :take
             "[0...#{args.first.source}].chars"
           else

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

@@ -124,8 +124,8 @@ module RuboCop
 
         def_node_search :last_matches, <<~PATTERN
           {
-            (send (const nil? :Regexp) :last_match)
-            (send (const nil? :Regexp) :last_match _)
+            (send (const {nil? cbase} :Regexp) :last_match)
+            (send (const {nil? cbase} :Regexp) :last_match _)
             ({back_ref nth_ref} _)
             (gvar #match_gvar?)
           }
@@ -217,8 +217,7 @@ module RuboCop
         def find_last_match(body, range, scope_root)
           last_matches(body).find do |ref|
             ref_pos = ref.loc.expression.begin_pos
-            range.cover?(ref_pos) &&
-              scope_root(ref) == scope_root
+            range.cover?(ref_pos) && scope_root(ref) == scope_root
           end
         end
 
@@ -241,14 +240,7 @@ module RuboCop
         end
 
         def match_gvar?(sym)
-          %i[
-            $~
-            $MATCH
-            $PREMATCH
-            $POSTMATCH
-            $LAST_PAREN_MATCH
-            $LAST_MATCH_INFO
-          ].include?(sym)
+          %i[$~ $MATCH $PREMATCH $POSTMATCH $LAST_PAREN_MATCH $LAST_MATCH_INFO].include?(sym)
         end
 
         def correct_operator(corrector, recv, arg, oper = nil)

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

@@ -17,27 +17,36 @@ module RuboCop
         include SortBlock
         extend AutoCorrector
 
-        MSG = 'Use `sort.reverse` instead of `%<bad_method>s`.'
+        MSG = 'Use `sort.reverse` instead.'
 
         def on_block(node)
           sort_with_block?(node) do |send, var_a, var_b, body|
             replaceable_body?(body, var_b, var_a) do
-              range = sort_range(send, node)
+              register_offense(send, node)
+            end
+          end
+        end
 
-              add_offense(range, message: message(var_a, var_b)) do |corrector|
-                replacement = 'sort.reverse'
+        def on_numblock(node)
+          sort_with_numblock?(node) do |send, arg_count, body|
+            next unless arg_count == 2
 
-                corrector.replace(range, replacement)
-              end
+            replaceable_body?(body, :_2, :_1) do
+              register_offense(send, node)
             end
           end
         end
 
         private
 
-        def message(var_a, var_b)
-          bad_method = "sort { |#{var_a}, #{var_b}| #{var_b} <=> #{var_a} }"
-          format(MSG, bad_method: bad_method)
+        def register_offense(send, node)
+          range = sort_range(send, node)
+
+          add_offense(range) do |corrector|
+            replacement = 'sort.reverse'
+
+            corrector.replace(range, replacement)
+          end
         end
       end
     end

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

@@ -24,10 +24,7 @@ module RuboCop
         MSG = 'Use `%<prefer>s` instead of `%<current>s`.'
         RESTRICT_ON_SEND = %i[gsub gsub!].freeze
 
-        PREFERRED_METHODS = {
-          gsub: :squeeze,
-          gsub!: :squeeze!
-        }.freeze
+        PREFERRED_METHODS = { gsub: :squeeze, gsub!: :squeeze! }.freeze
 
         def_node_matcher :squeeze_candidate?, <<~PATTERN
           (send

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

@@ -50,8 +50,7 @@ module RuboCop
         include RegexpMetacharacter
         extend AutoCorrector
 
-        MSG = 'Use `String#start_with?` instead of a regex match anchored to ' \
-              'the beginning of the string.'
+        MSG = 'Use `String#start_with?` instead of a regex match anchored to the beginning of the string.'
         RESTRICT_ON_SEND = %i[match =~ match?].freeze
 
         def_node_matcher :redundant_regex?, <<~PATTERN

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

@@ -6,39 +6,42 @@ module RuboCop
       # Identifies unnecessary use of a regex where `String#include?` would suffice.
       #
       # @safety
-      #   This cop's offenses are not safe to autocorrect if a receiver is nil.
+      #   This cop's offenses are not safe to autocorrect if a receiver is nil or a Symbol.
       #
       # @example
       #   # bad
-      #   'abc'.match?(/ab/)
-      #   /ab/.match?('abc')
-      #   'abc' =~ /ab/
-      #   /ab/ =~ 'abc'
-      #   'abc'.match(/ab/)
-      #   /ab/.match('abc')
+      #   str.match?(/ab/)
+      #   /ab/.match?(str)
+      #   str =~ /ab/
+      #   /ab/ =~ str
+      #   str.match(/ab/)
+      #   /ab/.match(str)
       #
       #   # good
-      #   'abc'.include?('ab')
+      #   str.include?('ab')
       class StringInclude < Base
         extend AutoCorrector
 
-        MSG = 'Use `String#include?` instead of a regex match with literal-only pattern.'
-        RESTRICT_ON_SEND = %i[match =~ match?].freeze
+        MSG = 'Use `%<negation>sString#include?` instead of a regex match with literal-only pattern.'
+        RESTRICT_ON_SEND = %i[match =~ !~ match?].freeze
 
         def_node_matcher :redundant_regex?, <<~PATTERN
-          {(send $!nil? {:match :=~ :match?} (regexp (str $#literal?) (regopt)))
-           (send (regexp (str $#literal?) (regopt)) {:match :match?} $str)
+          {(send $!nil? {:match :=~ :!~ :match?} (regexp (str $#literal?) (regopt)))
+           (send (regexp (str $#literal?) (regopt)) {:match :match?} $_)
            (match-with-lvasgn (regexp (str $#literal?) (regopt)) $_)}
         PATTERN
 
         def on_send(node)
           return unless (receiver, regex_str = redundant_regex?(node))
 
-          add_offense(node) do |corrector|
+          negation = node.send_type? && node.method?(:!~)
+          message = format(MSG, negation: ('!' if negation))
+
+          add_offense(node, message: message) do |corrector|
             receiver, regex_str = regex_str, receiver if receiver.is_a?(String)
             regex_str = interpret_string_escapes(regex_str)
 
-            new_source = "#{receiver.source}.include?(#{to_string_literal(regex_str)})"
+            new_source = "#{'!' if negation}#{receiver.source}.include?(#{to_string_literal(regex_str)})"
 
             corrector.replace(node.source_range, new_source)
           end

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

@@ -86,8 +86,7 @@ module RuboCop
 
           unless first_param.str_type?
             return true if options
-            return true unless first_source.is_a?(String) &&
-                               first_source =~ DETERMINISTIC_REGEX
+            return true unless first_source.is_a?(String) && first_source =~ DETERMINISTIC_REGEX
 
             # This must be done after checking DETERMINISTIC_REGEX
             # Otherwise things like \s will trip us up
@@ -141,8 +140,7 @@ module RuboCop
         end
 
         def message(node, first_source, second_source)
-          replacement_method =
-            replacement_method(node, first_source, second_source)
+          replacement_method = replacement_method(node, first_source, second_source)
 
           format(MSG, prefer: replacement_method, current: node.method_name)
         end
@@ -152,8 +150,7 @@ module RuboCop
         end
 
         def remove_second_param(corrector, node, first_param)
-          end_range = range_between(first_param.source_range.end_pos,
-                                    node.source_range.end_pos)
+          end_range = range_between(first_param.source_range.end_pos, node.source_range.end_pos)
 
           corrector.replace(end_range, method_suffix(node))
         end

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

@@ -70,6 +70,9 @@ module RuboCop
       class Sum < Base
         include RangeHelp
         extend AutoCorrector
+        extend TargetRubyVersion
+
+        minimum_target_ruby_version 2.4
 
         MSG = 'Use `%<good_method>s` instead of `%<bad_method>s`.'
         MSG_IF_NO_INIT_VALUE =

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

@@ -32,8 +32,7 @@ module RuboCop
       class TimesMap < Base
         extend AutoCorrector
 
-        MESSAGE = 'Use `Array.new(%<count>s)` with a block ' \
-                  'instead of `.times.%<map_or_collect>s`'
+        MESSAGE = 'Use `Array.new(%<count>s)` with a block instead of `.times.%<map_or_collect>s`'
         MESSAGE_ONLY_IF = 'only if `%<count>s` is always 0 or more'
         RESTRICT_ON_SEND = %i[map collect].freeze
 
@@ -44,14 +43,14 @@ module RuboCop
         def on_block(node)
           check(node)
         end
+        alias on_numblock on_block
 
         private
 
         def check(node)
           times_map_call(node) do |map_or_collect, count|
             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})"
+              replacement = "Array.new(#{count.source}#{map_or_collect.arguments.map { |arg| ", #{arg.source}" }.join})"
 
               corrector.replace(map_or_collect.loc.expression, replacement)
             end
@@ -68,7 +67,7 @@ module RuboCop
         end
 
         def_node_matcher :times_map_call, <<~PATTERN
-          {(block $(send (send $!nil? :times) {:map :collect}) ...)
+          {({block numblock} $(send (send $!nil? :times) {:map :collect}) ...)
            $(send (send $!nil? :times) {:map :collect} (block_pass ...))}
         PATTERN
       end

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

@@ -15,8 +15,7 @@ module RuboCop
       class UriDefaultParser < Base
         extend AutoCorrector
 
-        MSG = 'Use `%<double_colon>sURI::DEFAULT_PARSER` instead of ' \
-              '`%<double_colon>sURI::Parser.new`.'
+        MSG = 'Use `%<double_colon>sURI::DEFAULT_PARSER` instead of `%<double_colon>sURI::Parser.new`.'
         RESTRICT_ON_SEND = %i[new].freeze
 
         def_node_matcher :uri_parser_new?, <<~PATTERN

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.14.3'
+      STRING = '1.16.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.14.3
+  version: 1.16.0
 platform: ruby
 authors:
 - Bozhidar Batsov
@@ -10,7 +10,7 @@ authors:
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-07-17 00:00:00.000000000 Z
+date: 2023-02-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rubocop
@@ -123,7 +123,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.14/
+  documentation_uri: https://docs.rubocop.org/rubocop-performance/1.16/
   bug_tracker_uri: https://github.com/rubocop/rubocop-performance/issues
   rubygems_mfa_required: 'true'
 post_install_message:
@@ -141,7 +141,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.3.3
+rubygems_version: 3.3.26
 signing_key:
 specification_version: 4
 summary: Automatic performance checking tool for Ruby code.