rubocop-performance 1.11.2 → 1.12.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a26b6360b5df05f3a7a8dfe957e5ecad0922105024a2e49dae8c39a566f10d88
-  data.tar.gz: 7591fd4d805f4d6dad68b83c8fbffff8e563bfa27bd58030efa48f332c392b2f
+  metadata.gz: c98065b3a22d03c0e9290990288d6b8a82a87d956bdf4165d94d3cd326ae7bf5
+  data.tar.gz: a9ee1493235e6584ad381941423c0cac234bfc36fb4a2417433e667a16bec054
 SHA512:
-  metadata.gz: c8fb234710212fd000d0d695da71a1b1a36687550cf3738ce987264dad85f015d2f1f1da9b0f511c2147532ff7d6d444b35efb472b399646171bbb35e0ff79ad
-  data.tar.gz: 8447f79bb69e546ff684ece819b626fbfc68db8f7154b1b839c22167c87dbbf58821f1abe626a2b6d486ccfc81601e0844e416a312703ce0be7bc5552f1160ab
+  metadata.gz: 35f36bff7bfe1b19496bfea773e7d0f7892731e57b06bb523ac192324a817f401207750abab20892ea58ec54595d1bdfd454bf250a4a00baf6ef0f4ac3f7b030
+  data.tar.gz: 84a6ebc3e13d7c24aa6f1219443ce2c6cf6cd6c6253d4f09c78056fb3906f08bcb44db5365b03231aae55170a653e504b4a3433b4ed4a4dea1ee21b23d7a1387

data/config/default.yml

@@ -76,6 +76,12 @@ Performance/CompareWithBlock:
   Enabled: true
   VersionAdded: '0.46'
 
+Performance/ConcurrentMonotonicTime:
+  Description: 'Use `Process.clock_gettime(Process::CLOCK_MONOTONIC)` instead of `Concurrent.monotonic_time`.'
+  Reference: 'https://github.com/rails/rails/pull/43502'
+  Enabled: pending
+  VersionAdded: '1.12'
+
 Performance/ConstantRegexp:
   Description: 'Finds regular expressions with dynamic components that are all constants.'
   Enabled: pending
@@ -96,14 +102,18 @@ Performance/Count:
 Performance/DeletePrefix:
   Description: 'Use `delete_prefix` instead of `gsub`.'
   Enabled: true
+  Safe: false
   SafeMultiline: true
   VersionAdded: '1.6'
+  VersionChanged: '1.11'
 
 Performance/DeleteSuffix:
   Description: 'Use `delete_suffix` instead of `gsub`.'
   Enabled: true
+  Safe: false
   SafeMultiline: true
   VersionAdded: '1.6'
+  VersionChanged: '1.11'
 
 Performance/Detect:
   Description: >-
@@ -305,9 +315,9 @@ Performance/StartWith:
 Performance/StringInclude:
   Description: 'Use `String#include?` instead of a regex match with literal-only pattern.'
   Enabled: 'pending'
-  AutoCorrect: false
   SafeAutoCorrect: false
   VersionAdded: '1.7'
+  VersionChanged: '1.12'
 
 Performance/StringReplacement:
   Description: >-

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

@@ -6,6 +6,10 @@ module RuboCop
       # This cop is used to identify usages of `ancestors.include?` and
       # change them to use `<=` instead.
       #
+      # @safety
+      #   This cop is unsafe because it can't tell whether the receiver is a class or an object.
+      #   e.g. the false positive was for `Nokogiri::XML::Node#ancestors`.
+      #
       # @example
       #   # bad
       #   A.ancestors.include?(B)

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

@@ -7,15 +7,17 @@ module RuboCop
       # can be replaced by `Array#take` and `Array#drop`.
       # This cop was created due to a mistake in microbenchmark and hence is disabled by default.
       # Refer https://github.com/rubocop/rubocop-performance/pull/175#issuecomment-731892717
-      # This cop is also unsafe for string slices because strings do not have `#take` and `#drop` methods.
+      #
+      # @safety
+      #   This cop is unsafe for string slices because strings do not have `#take` and `#drop` methods.
       #
       # @example
       #   # bad
-      #   # array[..2]
-      #   # array[...2]
-      #   # array[2..]
-      #   # array[2...]
-      #   # array.slice(..2)
+      #   array[..2]
+      #   array[...2]
+      #   array[2..]
+      #   array[2...]
+      #   array.slice(..2)
       #
       #   # good
       #   array.take(3)

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

@@ -17,11 +17,13 @@ module RuboCop
       # this defining a higher level when condition to override a condition
       # that is inside of the splat expansion.
       #
-      # This is not a guaranteed performance improvement. If the data being
-      # processed by the `case` condition is normalized in a manner that favors
-      # hitting a condition in the splat expansion, it is possible that
-      # moving the splat condition to the end will use more memory,
-      # and run slightly slower.
+      # @safety
+      #   This cop is not unsafe auto-correction because it is not a guaranteed
+      #   performance improvement. If the data being processed by the `case` condition is
+      #   normalized in a manner that favors hitting a condition in the splat expansion,
+      #   it is possible that moving the splat condition to the end will use more memory,
+      #   and run slightly slower.
+      #   See for more details: https://github.com/rubocop/rubocop/pull/6163
       #
       # @example
       #   # bad
@@ -58,10 +60,8 @@ module RuboCop
         include RangeHelp
         extend AutoCorrector
 
-        MSG = 'Reordering `when` conditions with a splat to the end ' \
-          'of the `when` branches can improve performance.'
-        ARRAY_MSG = 'Pass the contents of array literals ' \
-          'directly to `when` conditions.'
+        MSG = 'Reordering `when` conditions with a splat to the end of the `when` branches can improve performance.'
+        ARRAY_MSG = 'Pass the contents of array literals directly to `when` conditions.'
 
         def on_case(case_node)
           when_conditions = case_node.when_branches.flat_map(&:conditions)
@@ -134,13 +134,11 @@ module RuboCop
         end
 
         def new_condition_with_then(node, new_condition)
-          "\n#{indent_for(node)}when " \
-          "#{new_condition} then #{node.body.source}"
+          "\n#{indent_for(node)}when #{new_condition} then #{node.body.source}"
         end
 
         def new_branch_without_then(node, new_condition)
-          "\n#{indent_for(node)}when #{new_condition}" \
-          "\n#{indent_for(node.body)}#{node.body.source}"
+          "\n#{indent_for(node)}when #{new_condition}\n#{indent_for(node.body)}#{node.body.source}"
         end
 
         def indent_for(node)

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

@@ -5,8 +5,10 @@ module RuboCop
     module Performance
       # This cop identifies places where a case-insensitive string comparison
       # can better be implemented using `casecmp`.
-      # This cop is unsafe because `String#casecmp` and `String#casecmp?` behave
-      # differently when using Non-ASCII characters.
+      #
+      # @safety
+      #   This cop is unsafe because `String#casecmp` and `String#casecmp?` behave
+      #   differently when using Non-ASCII characters.
       #
       # @example
       #   # bad

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

@@ -33,7 +33,7 @@ module RuboCop
       #
       class CollectionLiteralInLoop < Base
         MSG = 'Avoid immutable %<literal_class>s literals in loops. '\
-          'It is better to extract it into a local variable or a constant.'
+              'It is better to extract it into a local variable or a constant.'
 
         POST_CONDITION_LOOP_TYPES = %i[while_post until_post].freeze
         LOOP_TYPES = (POST_CONDITION_LOOP_TYPES + %i[while until for]).freeze

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

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Performance
+      # This cop identifies places where `Concurrent.monotonic_time`
+      # can be replaced by `Process.clock_gettime(Process::CLOCK_MONOTONIC)`.
+      #
+      # @example
+      #
+      #   # bad
+      #   Concurrent.monotonic_time
+      #
+      #   # good
+      #   Process.clock_gettime(Process::CLOCK_MONOTONIC)
+      #
+      class ConcurrentMonotonicTime < Base
+        extend AutoCorrector
+
+        MSG = 'Use `%<prefer>s` instead of `%<current>s`.'
+        RESTRICT_ON_SEND = %i[monotonic_time].freeze
+
+        def_node_matcher :concurrent_monotonic_time?, <<~PATTERN
+          (send
+            (const {nil? cbase} :Concurrent) :monotonic_time ...)
+        PATTERN
+
+        def on_send(node)
+          return unless concurrent_monotonic_time?(node)
+
+          optional_unit_parameter = ", #{node.first_argument.source}" if node.first_argument
+          prefer = "Process.clock_gettime(Process::CLOCK_MONOTONIC#{optional_unit_parameter})"
+          message = format(MSG, prefer: prefer, current: node.source)
+
+          add_offense(node, message: message) do |corrector|
+            corrector.replace(node, prefer)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -7,6 +7,28 @@ module RuboCop
       # follow calls to `select`, `find_all`, `filter` or `reject`. Querying logic can instead be
       # passed to the `count` call.
       #
+      # @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`.
+      #   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 {...}`.
+      #
+      #   For example:
+      #
+      #   [source,ruby]
+      #   ----
+      #   `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 }`
+      #   ----
+      #
       # @example
       #   # bad
       #   [1, 2, 3].select { |e| e > 2 }.size
@@ -24,19 +46,6 @@ module RuboCop
       #   [1, 2, 3].count { |e| e < 2 && e.even? }
       #   Model.select('field AS field_one').count
       #   Model.select(:value).count
-      #
-      # `ActiveRecord` compatibility:
-      # `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 {...}`.
-      #
-      # Example:
-      #   `Model.where(id: [1, 2, 3]).select { |m| m.method == true }.size`
-      #
-      #   becomes:
-      #
-      #   `Model.where(id: [1, 2, 3]).to_a.count { |m| m.method == true }`
       class Count < Base
         include RangeHelp
         extend AutoCorrector

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

@@ -14,6 +14,9 @@ module RuboCop
       #
       # The `delete_prefix('prefix')` method is faster than `gsub(/\Aprefix/, '')`.
       #
+      # @safety
+      #   This cop is unsafe because `Pathname` has `sub` but not `delete_prefix`.
+      #
       # @example
       #
       #   # bad
@@ -46,9 +49,6 @@ module RuboCop
       class DeletePrefix < Base
         include RegexpMetacharacter
         extend AutoCorrector
-        extend TargetRubyVersion
-
-        minimum_target_ruby_version 2.5
 
         MSG = 'Use `%<prefer>s` instead of `%<current>s`.'
         RESTRICT_ON_SEND = %i[gsub gsub! sub sub!].freeze
@@ -66,7 +66,7 @@ module RuboCop
 
         def on_send(node)
           return unless (receiver, bad_method, regexp_str, replace_string = delete_prefix_candidate?(node))
-          return unless replace_string.blank?
+          return unless replace_string.empty?
 
           good_method = PREFERRED_METHODS[bad_method]
 

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

@@ -14,6 +14,9 @@ module RuboCop
       #
       # The `delete_suffix('suffix')` method is faster than `gsub(/suffix\z/, '')`.
       #
+      # @safety
+      #   This cop is unsafe because `Pathname` has `sub` but not `delete_suffix`.
+      #
       # @example
       #
       #   # bad
@@ -46,9 +49,6 @@ module RuboCop
       class DeleteSuffix < Base
         include RegexpMetacharacter
         extend AutoCorrector
-        extend TargetRubyVersion
-
-        minimum_target_ruby_version 2.5
 
         MSG = 'Use `%<prefer>s` instead of `%<current>s`.'
         RESTRICT_ON_SEND = %i[gsub gsub! sub sub!].freeze
@@ -66,7 +66,7 @@ module RuboCop
 
         def on_send(node)
           return unless (receiver, bad_method, regexp_str, replace_string = delete_suffix_candidate?(node))
-          return unless replace_string.blank?
+          return unless replace_string.empty?
 
           good_method = PREFERRED_METHODS[bad_method]
 

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

@@ -7,6 +7,11 @@ module RuboCop
       # chained to `select`, `find_all` or `filter` and change them to use
       # `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.
+      #
       # @example
       #   # bad
       #   [].select { |item| true }.first
@@ -31,14 +36,10 @@ module RuboCop
 
         CANDIDATE_METHODS = Set[:select, :find_all, :filter].freeze
 
-        MSG = 'Use `%<prefer>s` instead of ' \
-              '`%<first_method>s.%<second_method>s`.'
-        REVERSE_MSG = 'Use `reverse.%<prefer>s` instead of ' \
-                      '`%<first_method>s.%<second_method>s`.'
-        INDEX_MSG = 'Use `%<prefer>s` instead of ' \
-              '`%<first_method>s[%<index>i]`.'
-        INDEX_REVERSE_MSG = 'Use `reverse.%<prefer>s` instead of ' \
-              '`%<first_method>s[%<index>i]`.'
+        MSG = 'Use `%<prefer>s` instead of `%<first_method>s.%<second_method>s`.'
+        REVERSE_MSG = 'Use `reverse.%<prefer>s` instead of `%<first_method>s.%<second_method>s`.'
+        INDEX_MSG = 'Use `%<prefer>s` instead of `%<first_method>s[%<index>i]`.'
+        INDEX_REVERSE_MSG = 'Use `reverse.%<prefer>s` instead of `%<first_method>s[%<index>i]`.'
         RESTRICT_ON_SEND = %i[first last []].freeze
 
         def_node_matcher :detect_candidate?, <<~PATTERN
@@ -94,7 +95,7 @@ module RuboCop
         end
 
         def replacement(method, index)
-          if method == :last || method == :[] && index == -1
+          if method == :last || (method == :[] && index == -1)
             "reverse.#{preferred_method}"
           else
             preferred_method

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

@@ -9,6 +9,11 @@ module RuboCop
       # `end$` is unsafe as it will behave incompatible with `end_with?`
       # for receiver is multiline string.
       #
+      # @safety
+      #   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.
+      #
       # @example
       #   # bad
       #   'abc'.match?(/bc\Z/)

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

@@ -15,6 +15,9 @@ module RuboCop
       # both perform an O(n) search through all of the values, calling `values`
       # allocates a new array while using `value?` does not.
       #
+      # @safety
+      #   This cop is unsafe because it can't tell whether the receiver is a hash object.
+      #
       # @example
       #   # bad
       #   { a: 1, b: 2 }.keys.include?(:a)

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

@@ -6,8 +6,10 @@ module RuboCop
       # In Ruby 2.7, `Enumerable#filter_map` has been added.
       #
       # This cop identifies places where `map { ... }.compact` can be replaced by `filter_map`.
-      # It is marked as unsafe auto-correction by default because `map { ... }.compact`
-      # that is not compatible with `filter_map`.
+      #
+      # @safety
+      #   This cop's autocorrection is unsafe because `map { ... }.compact` that is not
+      #   compatible with `filter_map`.
       #
       # [source,ruby]
       # ----
@@ -23,6 +25,7 @@ module RuboCop
       #   # good
       #   ary.filter_map(&:foo)
       #   ary.map(&:foo).compact!
+      #   ary.compact.map(&:foo)
       #
       class MapCompact < Base
         include RangeHelp
@@ -55,23 +58,24 @@ module RuboCop
 
           add_offense(range) do |corrector|
             corrector.replace(map_node.loc.selector, 'filter_map')
-            corrector.remove(compact_loc.dot)
-            corrector.remove(compact_method_range(node))
+            remove_compact_method(corrector, node)
           end
         end
 
         private
 
-        def compact_method_range(compact_node)
+        def remove_compact_method(corrector, compact_node)
           chained_method = compact_node.parent
           compact_method_range = compact_node.loc.selector
 
-          if compact_node.multiline? &&
-             chained_method && !invoke_method_after_map_compact_on_same_line?(compact_node, chained_method)
-            range_by_whole_lines(compact_method_range, include_final_newline: true)
+          if compact_node.multiline? && chained_method&.loc.respond_to?(:selector) && chained_method.dot? &&
+             !invoke_method_after_map_compact_on_same_line?(compact_node, chained_method)
+            compact_method_range = range_by_whole_lines(compact_method_range, include_final_newline: true)
           else
-            compact_method_range
+            corrector.remove(compact_node.loc.dot)
           end
+
+          corrector.remove(compact_method_range)
         end
 
         def invoke_method_after_map_compact_on_same_line?(compact_node, chained_method)

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

@@ -11,6 +11,10 @@ module RuboCop
       # especially in case of single-threaded
       # applications with multiple `OpenStruct` instantiations.
       #
+      # @safety
+      #   This cop is unsafe because `OpenStruct.new` and `Struct.new`
+      #   are not equivalent.
+      #
       # @example
       #   # bad
       #   class MyClass

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

@@ -9,8 +9,9 @@ module RuboCop
       # end points of the `Range`. In a great majority of cases, this is what
       # is wanted.
       #
-      # This cop is `Safe: false` by default because `Range#include?` (or `Range#member?`) and
-      # `Range#cover?` are not equivalent behaviour.
+      # @safety
+      #   This cop is unsafe because `Range#include?` (or `Range#member?`) and `Range#cover?`
+      #   are not equivalent behaviour.
       #
       # @example
       #   # bad

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

@@ -55,6 +55,7 @@ module RuboCop
             end
           end
         end
+        alias on_defs on_def
 
         private
 

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

@@ -9,8 +9,9 @@ module RuboCop
       # By default, `Object#===` behaves the same as `Object#==`, but this
       # behavior is appropriately overridden in subclass. For example,
       # `Range#===` returns `true` when argument is within the range.
-      # Therefore, It is marked as unsafe by default because `===` and `==`
-      # do not always behave the same.
+      #
+      # @safety
+      #   This cop is unsafe because `===` and `==` do not always behave the same.
       #
       # @example
       #   # bad
@@ -24,9 +25,6 @@ module RuboCop
       #
       class RedundantEqualityComparisonBlock < Base
         extend AutoCorrector
-        extend TargetRubyVersion
-
-        minimum_target_ruby_version 2.5
 
         MSG = 'Use `%<prefer>s` instead of block.'
 
@@ -74,12 +72,27 @@ module RuboCop
 
         def new_argument(block_argument, block_body)
           if block_argument.source == block_body.receiver.source
-            block_body.first_argument.source
+            rhs = block_body.first_argument
+            return if use_block_argument_in_method_argument_of_operand?(block_argument, rhs)
+
+            rhs.source
           elsif block_argument.source == block_body.first_argument.source
-            block_body.receiver.source
+            lhs = block_body.receiver
+            return if use_block_argument_in_method_argument_of_operand?(block_argument, lhs)
+
+            lhs.source
           end
         end
 
+        def use_block_argument_in_method_argument_of_operand?(block_argument, operand)
+          return false unless operand.send_type?
+
+          arguments = operand.arguments
+          arguments.inject(arguments.map(&:source)) do |operand_sources, argument|
+            operand_sources + argument.each_descendant(:lvar).map(&:source)
+          end.any?(block_argument.source)
+        end
+
         def offense_range(node)
           node.send_node.loc.selector.join(node.source_range.end)
         end

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

@@ -8,8 +8,9 @@ module RuboCop
       # You can set the maximum number of key-value pairs to consider
       # an offense with `MaxKeyValuePairs`.
       #
-      # This cop is marked as unsafe because RuboCop cannot determine if the
-      # receiver of `merge!` is actually a hash or not.
+      # @safety
+      #   This cop is unsafe because RuboCop cannot determine if the
+      #   receiver of `merge!` is actually a hash or not.
       #
       # @example
       #   # bad
@@ -91,7 +92,7 @@ module RuboCop
         end
 
         def non_redundant_pairs?(receiver, pairs)
-          pairs.size > 1 && !receiver.pure? || pairs.size > max_key_value_pairs
+          (pairs.size > 1 && !receiver.pure?) || pairs.size > max_key_value_pairs
         end
 
         def kwsplat_used?(pairs)

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

@@ -16,35 +16,35 @@ module RuboCop
       #   # bad
       #   str.chars.first
       #   str.chars.first(2)
-      #   str.chars.last
-      #   str.chars.last(2)
       #
       #   # good
       #   str[0]
       #   str[0...2].chars
-      #   str[-1]
-      #   str[-2..-1].chars
       #
       #   # bad
       #   str.chars.take(2)
-      #   str.chars.drop(2)
       #   str.chars.length
       #   str.chars.size
       #   str.chars.empty?
       #
       #   # good
       #   str[0...2].chars
-      #   str[2..-1].chars
       #   str.length
       #   str.size
       #   str.empty?
       #
+      #   # For example, if the receiver is a blank 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`.
+      #
       class RedundantStringChars < Base
         include RangeHelp
         extend AutoCorrector
 
         MSG = 'Use `%<good_method>s` instead of `%<bad_method>s`.'
-        RESTRICT_ON_SEND = %i[[] slice first last take drop length size empty?].freeze
+        RESTRICT_ON_SEND = %i[[] slice first take length size empty?].freeze
 
         def_node_matcher :redundant_chars_call?, <<~PATTERN
           (send $(send _ :chars) $_ $...)
@@ -80,7 +80,6 @@ module RuboCop
           format(MSG, good_method: good_method, bad_method: bad_method)
         end
 
-        # rubocop:disable Metrics/CyclomaticComplexity, Metrics/MethodLength
         def build_good_method(method, args)
           case method
           when :[], :slice
@@ -91,21 +90,12 @@ module RuboCop
             else
               '[0]'
             end
-          when :last
-            if args.any?
-              "[-#{args.first.source}..-1].chars"
-            else
-              '[-1]'
-            end
           when :take
             "[0...#{args.first.source}].chars"
-          when :drop
-            "[#{args.first.source}..-1].chars"
           else
             ".#{method}"
           end
         end
-        # rubocop:enable Metrics/CyclomaticComplexity, Metrics/MethodLength
 
         def build_bad_method(method, args)
           case method

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

@@ -78,8 +78,7 @@ module RuboCop
         # Constants are included in this list because it is unlikely that
         # someone will store `nil` as a constant and then use it for comparison
         TYPES_IMPLEMENTING_MATCH = %i[const regexp str sym].freeze
-        MSG = 'Use `match?` instead of `%<current>s` when `MatchData` ' \
-          'is not used.'
+        MSG = 'Use `match?` instead of `%<current>s` when `MatchData` is not used.'
 
         def_node_matcher :match_method?, <<~PATTERN
           {

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

@@ -9,6 +9,11 @@ module RuboCop
       # `^start` is unsafe as it will behave incompatible with `start_with?`
       # for receiver is multiline string.
       #
+      # @safety
+      #   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.
+      #
       # @example
       #   # bad
       #   'abc'.match?(/\Aab/)

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

@@ -6,7 +6,8 @@ module RuboCop
       # This cop identifies unnecessary use of a regex where
       # `String#include?` would suffice.
       #
-      # This cop's offenses are not safe to auto-correct if a receiver is nil.
+      # @safety
+      #   This cop's offenses are not safe to auto-correct if a receiver is nil.
       #
       # @example
       #   # bad

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

@@ -156,7 +156,7 @@ module RuboCop
         end
 
         def sum_method_range(node)
-          range_between(node.loc.selector.begin_pos, node.loc.end.end_pos)
+          range_between(node.loc.selector.begin_pos, node.loc.expression.end_pos)
         end
 
         def sum_map_range(map, sum)

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

@@ -7,6 +7,18 @@ module RuboCop
       # In most cases such calls can be replaced
       # with an explicit array creation.
       #
+      # @safety
+      #   This cop's autocorrection is unsafe because `Integer#times` does nothing if receiver is 0
+      #   or less. However, `Array.new` raises an error if argument is less than 0.
+      #
+      #   For example:
+      #
+      #   [source,ruby]
+      #   ----
+      #   -1.times{}    # does nothing
+      #   Array.new(-1) # ArgumentError: negative array size
+      #   ----
+      #
       # @example
       #   # bad
       #   9.times.map do |i|

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

@@ -7,11 +7,11 @@ module RuboCop
       # literal instead of `String#dup` and `String.new`.
       # Unary plus operator is faster than `String#dup`.
       #
-      # NOTE: `String.new` (without operator) is not exactly the same as `+''`.
-      # These differ in encoding. `String.new.encoding` is always `ASCII-8BIT`.
-      # However, `(+'').encoding` is the same as script encoding(e.g. `UTF-8`).
-      # Therefore, auto-correction is unsafe.
-      # So, if you expect `ASCII-8BIT` encoding, disable this cop.
+      # @safety
+      #   This cop's autocorrection is unsafe because `String.new` (without operator) is not
+      #   exactly the same as `+''`. These differ in encoding. `String.new.encoding` is always
+      #   `ASCII-8BIT`. However, `(+'').encoding` is the same as script encoding(e.g. `UTF-8`).
+      #   if you expect `ASCII-8BIT` encoding, disable this cop.
       #
       # @example
       #   # bad
@@ -45,7 +45,10 @@ module RuboCop
           return unless dup_string?(node) || string_new?(node)
 
           add_offense(node) do |corrector|
-            corrector.replace(node, "+#{string_value(node)}")
+            string_value = "+#{string_value(node)}"
+            string_value = "(#{string_value})" if node.parent&.send_type?
+
+            corrector.replace(node, string_value)
           end
         end
 

data/lib/rubocop/cop/performance_cops.rb

@@ -13,6 +13,7 @@ require_relative 'performance/case_when_splat'
 require_relative 'performance/casecmp'
 require_relative 'performance/collection_literal_in_loop'
 require_relative 'performance/compare_with_block'
+require_relative 'performance/concurrent_monotonic_time'
 require_relative 'performance/constant_regexp'
 require_relative 'performance/count'
 require_relative 'performance/delete_prefix'

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.11.2'
+      STRING = '1.12.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.11.2
+  version: 1.12.0
 platform: ruby
 authors:
 - Bozhidar Batsov
@@ -10,7 +10,7 @@ authors:
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2021-05-05 00:00:00.000000000 Z
+date: 2021-10-31 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rubocop
@@ -74,6 +74,7 @@ files:
 - lib/rubocop/cop/performance/chain_array_allocation.rb
 - lib/rubocop/cop/performance/collection_literal_in_loop.rb
 - lib/rubocop/cop/performance/compare_with_block.rb
+- lib/rubocop/cop/performance/concurrent_monotonic_time.rb
 - lib/rubocop/cop/performance/constant_regexp.rb
 - lib/rubocop/cop/performance/count.rb
 - lib/rubocop/cop/performance/delete_prefix.rb
@@ -121,7 +122,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.11/
+  documentation_uri: https://docs.rubocop.org/rubocop-performance/1.12/
   bug_tracker_uri: https://github.com/rubocop/rubocop-performance/issues
 post_install_message:
 rdoc_options: []
@@ -138,7 +139,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.2.12
+rubygems_version: 3.3.0.dev
 signing_key:
 specification_version: 4
 summary: Automatic performance checking tool for Ruby code.