rubocop-performance 1.8.1 → 1.9.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f1f4841e8542a1f77f21d30ffe7c26019b9f2fb7308a985780506f1920146045
-  data.tar.gz: ed95379cd20af662ce6ce9ce4e64721ca156a6d7b62e511774df9d6abe3c9bae
+  metadata.gz: 9b44c147120a9f64f16a0bf21782f1dbe0a51c64170c3a5c217e548eded4e106
+  data.tar.gz: 7b4e6e464ee3631071f3bd3f447acde2a59763d326a86658412f4ec9527850a6
 SHA512:
-  metadata.gz: 10a1e89448abd75234807bbdd9be67b10e4b9a837d2d2d711adeb0a0d105b921d722dfcac0c46e30f55f278afc2960f888407959543097d81df4f1aa3667fac6
-  data.tar.gz: 668784bfe08775a1e8917806ef9f34d7dcb3f7581a9080ea14a44a54b43cf7e6516db4f5c4e015718824c32a8b045f43b429c8e1d3864960f41ead8684fbb5f5
+  metadata.gz: e450740a348bd17e276af8393f4e8225521afc4c9fac5816c9a3bbd9883d16a15f28a1044e24b89c9037593f4d2931cf3dc900385d42d7ad035dbb1dd461a306
+  data.tar.gz: feef1ae1d9735d3abadf17799ecfb4840ce359fa932902387633e67dc15e1eeb62573ae0a2832c050a8722e004f614c109483a9d8857143f28c866dbd65bc5bf

data/README.md

@@ -76,6 +76,14 @@ Performance/Size:
 
 You can read a lot more about RuboCop Performance in its [official docs](https://docs.rubocop.org/rubocop-performance/).
 
+## Compatibility
+
+RuboCop Performance complies with the RuboCop core compatibility.
+
+See the [compatibility documentation](https://docs.rubocop.org/rubocop/compatibility.html) for further details.
+
+**Note:** Performance cops are all MRI focused and are highly dependent of the version of MRI you're using.
+
 ## Contributing
 
 Checkout the [contribution guidelines](CONTRIBUTING.md).

data/config/default.yml

@@ -7,6 +7,11 @@ Performance/AncestorsInclude:
   Safe: false
   VersionAdded: '1.7'
 
+Performance/ArraySemiInfiniteRangeSlice:
+  Description: 'Identifies places where slicing arrays with semi-infinite ranges can be replaced by `Array#take` and `Array#drop`.'
+  Enabled: pending
+  VersionAdded: '1.9'
+
 Performance/BigDecimalWithNumericArgument:
   Description: 'Convert numeric argument to string before passing to BigDecimal.'
   Enabled: 'pending'
@@ -17,11 +22,17 @@ Performance/BindCall:
   Enabled: true
   VersionAdded: '1.6'
 
+Performance/BlockGivenWithExplicitBlock:
+  Description: 'Check block argument explicitly instead of using `block_given?`.'
+  Enabled: pending
+  VersionAdded: '1.9'
+
 Performance/Caller:
   Description: >-
              Use `caller(n..n)` instead of `caller`.
   Enabled: true
   VersionAdded: '0.49'
+  VersionChanged: '1.9'
 
 Performance/CaseWhenSplat:
   Description: >-
@@ -51,7 +62,7 @@ Performance/ChainArrayAllocation:
 
 Performance/CollectionLiteralInLoop:
   Description: 'Extract Array and Hash literals outside of loops into local variables or constants.'
-  Enabled: true
+  Enabled: 'pending'
   VersionAdded: '1.8'
   # Min number of elements to consider an offense
   MinSize: 1
@@ -61,6 +72,11 @@ Performance/CompareWithBlock:
   Enabled: true
   VersionAdded: '0.46'
 
+Performance/ConstantRegexp:
+  Description: 'Finds regular expressions with dynamic components that are all constants.'
+  Enabled: pending
+  VersionAdded: '1.9'
+
 Performance/Count:
   Description: >-
                   Use `count` instead of `{select,find_all,filter,reject}...{size,count,length}`.
@@ -154,6 +170,12 @@ Performance/IoReadlines:
   Enabled: false
   VersionAdded: '1.7'
 
+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'
+  Enabled: pending
+  VersionAdded: '1.9'
+
 Performance/OpenStruct:
   Description: 'Use `Struct` instead of `OpenStruct`.'
   Enabled: false
@@ -283,7 +305,9 @@ Performance/TimesMap:
 Performance/UnfreezeString:
   Description: 'Use unary plus to get an unfrozen string literal.'
   Enabled: true
+  SafeAutoCorrect: false
   VersionAdded: '0.50'
+  VersionChanged: '1.9'
 
 Performance/UriDefaultParser:
   Description: 'Use `URI::DEFAULT_PARSER` instead of `URI::Parser.new`.'

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

@@ -25,7 +25,7 @@ module RuboCop
         # (tricky: \s, \d, and so on are metacharacters, but other characters
         #  escaped with a slash are just literals. LITERAL_REGEX takes all
         #  that into account.)
-        /\A\\A(?:#{Util::LITERAL_REGEX})+\z/.match?(regex_str)
+        /\A\\A(?:#{Util::LITERAL_REGEX})+\z/o.match?(regex_str)
       end
 
       def literal_at_start_with_caret?(regex_str)
@@ -35,21 +35,21 @@ module RuboCop
         # (tricky: \s, \d, and so on are metacharacters, but other characters
         #  escaped with a slash are just literals. LITERAL_REGEX takes all
         #  that into account.)
-        /\A\^(?:#{Util::LITERAL_REGEX})+\z/.match?(regex_str)
+        /\A\^(?:#{Util::LITERAL_REGEX})+\z/o.match?(regex_str)
       end
 
       def literal_at_end_with_backslash_z?(regex_str)
         # is this regexp 'literal' in the sense of only matching literal
         # chars, rather than using metachars like . and * and so on?
         # also, is it anchored at the end of the string?
-        /\A(?:#{Util::LITERAL_REGEX})+\\z\z/.match?(regex_str)
+        /\A(?:#{Util::LITERAL_REGEX})+\\z\z/o.match?(regex_str)
       end
 
       def literal_at_end_with_dollar?(regex_str)
         # is this regexp 'literal' in the sense of only matching literal
         # chars, rather than using metachars like . and * and so on?
         # also, is it anchored at the end of the string?
-        /\A(?:#{Util::LITERAL_REGEX})+\$\z/.match?(regex_str)
+        /\A(?:#{Util::LITERAL_REGEX})+\$\z/o.match?(regex_str)
       end
 
       def drop_start_metacharacter(regexp_string)

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

@@ -18,6 +18,7 @@ module RuboCop
         extend AutoCorrector
 
         MSG = 'Use `<=` instead of `ancestors.include?`.'
+        RESTRICT_ON_SEND = %i[include?].freeze
 
         def_node_matcher :ancestors_include_candidate?, <<~PATTERN
           (send (send $_subclass :ancestors) :include? $_superclass)

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

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Performance
+      # This cop identifies places where slicing arrays with semi-infinite ranges
+      # can be replaced by `Array#take` and `Array#drop`.
+      #
+      # @example
+      #   # bad
+      #   # array[..2]
+      #   # array[...2]
+      #   # array[2..]
+      #   # array[2...]
+      #   # array.slice(..2)
+      #
+      #   # good
+      #   array.take(3)
+      #   array.take(2)
+      #   array.drop(2)
+      #   array.drop(2)
+      #   array.take(3)
+      #
+      class ArraySemiInfiniteRangeSlice < Base
+        include RangeHelp
+        extend AutoCorrector
+        extend TargetRubyVersion
+
+        minimum_target_ruby_version 2.7
+
+        MSG = 'Use `%<prefer>s` instead of `%<current>s` with semi-infinite range.'
+
+        SLICE_METHODS = Set[:[], :slice].freeze
+        RESTRICT_ON_SEND = SLICE_METHODS
+
+        def_node_matcher :endless_range_slice?, <<~PATTERN
+          (send $_ $%SLICE_METHODS $#endless_range?)
+        PATTERN
+
+        def_node_matcher :endless_range?, <<~PATTERN
+          {
+            ({irange erange} nil? (int positive?))
+            ({irange erange} (int positive?) nil?)
+          }
+        PATTERN
+
+        def on_send(node)
+          endless_range_slice?(node) do |receiver, method_name, range_node|
+            prefer = range_node.begin ? :drop : :take
+            message = format(MSG, prefer: prefer, current: method_name)
+
+            add_offense(node, message: message) do |corrector|
+              corrector.replace(node, correction(receiver, range_node))
+            end
+          end
+        end
+
+        private
+
+        def correction(receiver, range_node)
+          method_call = if range_node.begin
+                          "drop(#{range_node.begin.value})"
+                        elsif range_node.irange_type?
+                          "take(#{range_node.end.value + 1})"
+                        else
+                          "take(#{range_node.end.value})"
+                        end
+
+          "#{receiver.source}.#{method_call}"
+        end
+      end
+    end
+  end
+end

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

@@ -20,6 +20,7 @@ module RuboCop
         extend AutoCorrector
 
         MSG = 'Convert numeric argument to string before passing to `BigDecimal`.'
+        RESTRICT_ON_SEND = %i[BigDecimal].freeze
 
         def_node_matcher :big_decimal_with_numeric_argument?, <<~PATTERN
           (send nil? :BigDecimal $numeric_type? ...)

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

@@ -28,6 +28,7 @@ module RuboCop
 
         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
           (send

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

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Performance
+      # This cop identifies unnecessary use of a `block_given?` where explicit check
+      # of block argument would suffice.
+      #
+      # @example
+      #   # bad
+      #   def method(&block)
+      #     do_something if block_given?
+      #   end
+      #
+      #   # good
+      #   def method(&block)
+      #     do_something if block
+      #   end
+      #
+      #   # good - block is reassigned
+      #   def method(&block)
+      #     block ||= -> { do_something }
+      #     warn "Using default ..." unless block_given?
+      #     # ...
+      #   end
+      #
+      class BlockGivenWithExplicitBlock < Base
+        extend AutoCorrector
+
+        RESTRICT_ON_SEND = %i[block_given?].freeze
+        MSG = 'Check block argument explicitly instead of using `block_given?`.'
+
+        def_node_matcher :reassigns_block_arg?, '`(lvasgn %1 ...)'
+
+        def on_send(node)
+          def_node = node.each_ancestor(:def, :defs).first
+          return unless def_node
+
+          block_arg = def_node.arguments.find(&:blockarg_type?)
+          return unless block_arg
+
+          block_arg_name = block_arg.loc.name.source.to_sym
+          return if reassigns_block_arg?(def_node, block_arg_name)
+
+          add_offense(node) do |corrector|
+            corrector.replace(node, block_arg_name)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -19,10 +19,10 @@ module RuboCop
       #   caller_locations(2..2).first
       #   caller_locations(1..1).first
       class Caller < Base
-        MSG_BRACE = 'Use `%<method>s(%<n>d..%<n>d).first`' \
-                    ' instead of `%<method>s[%<m>d]`.'
-        MSG_FIRST = 'Use `%<method>s(%<n>d..%<n>d).first`' \
-                    ' instead of `%<method>s.first`.'
+        extend AutoCorrector
+
+        MSG = 'Use `%<preferred_method>s` instead of `%<current_method>s`.'
+        RESTRICT_ON_SEND = %i[first []].freeze
 
         def_node_matcher :slow_caller?, <<~PATTERN
           {
@@ -41,26 +41,24 @@ module RuboCop
         def on_send(node)
           return unless caller_with_scope_method?(node)
 
-          message = message(node)
-          add_offense(node, message: message)
-        end
-
-        private
-
-        def message(node)
           method_name = node.receiver.method_name
           caller_arg = node.receiver.first_argument
           n = caller_arg ? int_value(caller_arg) : 1
-
           if node.method?(:[])
             m = int_value(node.first_argument)
             n += m
-            format(MSG_BRACE, n: n, m: m, method: method_name)
-          else
-            format(MSG_FIRST, n: n, method: method_name)
+          end
+
+          preferred_method = "#{method_name}(#{n}..#{n}).first"
+
+          message = format(MSG, preferred_method: preferred_method, current_method: node.source)
+          add_offense(node, message: message) do |corrector|
+            corrector.replace(node, preferred_method)
           end
         end
 
+        private
+
         def int_value(node)
           node.children[0]
         end

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

@@ -23,6 +23,7 @@ module RuboCop
         extend AutoCorrector
 
         MSG = 'Use `%<good>s` instead of `%<bad>s`.'
+        RESTRICT_ON_SEND = %i[== eql? !=].freeze
         CASE_METHODS = %i[downcase upcase].freeze
 
         def_node_matcher :downcase_eq, <<~PATTERN

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

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Performance
+      # This cop finds regular expressions with dynamic components that are all constants.
+      #
+      # Ruby allocates a new Regexp object every time it executes a code containing such
+      # a regular expression. It is more efficient to extract it into a constant
+      # or add an `/o` option to perform `#{}` interpolation only once and reuse that
+      # Regexp object.
+      #
+      # @example
+      #
+      #   # bad
+      #   def tokens(pattern)
+      #     pattern.scan(TOKEN).reject { |token| token.match?(/\A#{SEPARATORS}\Z/) }
+      #   end
+      #
+      #   # good
+      #   ALL_SEPARATORS = /\A#{SEPARATORS}\Z/
+      #   def tokens(pattern)
+      #     pattern.scan(TOKEN).reject { |token| token.match?(ALL_SEPARATORS) }
+      #   end
+      #
+      #   # good
+      #   def tokens(pattern)
+      #     pattern.scan(TOKEN).reject { |token| token.match?(/\A#{SEPARATORS}\Z/o) }
+      #   end
+      #
+      class ConstantRegexp < Base
+        extend AutoCorrector
+
+        MSG = 'Extract this regexp into a constant or append an `/o` option to its options.'
+
+        def on_regexp(node)
+          return if within_const_assignment?(node) ||
+                    !include_interpolated_const?(node) ||
+                    node.single_interpolation?
+
+          add_offense(node) do |corrector|
+            corrector.insert_after(node, 'o')
+          end
+        end
+
+        private
+
+        def within_const_assignment?(node)
+          node.each_ancestor(:casgn).any?
+        end
+
+        def_node_matcher :regexp_escape?, <<~PATTERN
+          (send
+            (const nil? :Regexp) :escape const_type?)
+        PATTERN
+
+        def include_interpolated_const?(node)
+          return false unless node.interpolation?
+
+          node.each_child_node(:begin).all? do |begin_node|
+            inner_node = begin_node.children.first
+            inner_node && (inner_node.const_type? || regexp_escape?(inner_node))
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -42,6 +42,7 @@ module RuboCop
         extend AutoCorrector
 
         MSG = 'Use `count` instead of `%<selector>s...%<counter>s`.'
+        RESTRICT_ON_SEND = %i[count length size].freeze
 
         def_node_matcher :count_candidate?, <<~PATTERN
           {

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

@@ -51,6 +51,7 @@ module RuboCop
         minimum_target_ruby_version 2.5
 
         MSG = 'Use `%<prefer>s` instead of `%<current>s`.'
+        RESTRICT_ON_SEND = %i[gsub gsub! sub sub!].freeze
 
         PREFERRED_METHODS = {
           gsub: :delete_prefix,

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

@@ -51,6 +51,7 @@ module RuboCop
         minimum_target_ruby_version 2.5
 
         MSG = 'Use `%<prefer>s` instead of `%<current>s`.'
+        RESTRICT_ON_SEND = %i[gsub gsub! sub sub!].freeze
 
         PREFERRED_METHODS = {
           gsub: :delete_suffix,

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

@@ -4,8 +4,8 @@ module RuboCop
   module Cop
     module Performance
       # This cop is used to identify usages of `first`, `last`, `[0]` or `[-1]`
-      # chained to `select`, `find_all`, or `find_all`
-      # and change them to use `detect` instead.
+      # chained to `select`, `find_all` or `filter` and change them to use
+      # `detect` instead.
       #
       # @example
       #   # bad
@@ -39,6 +39,7 @@ module RuboCop
               '`%<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
           {

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

@@ -47,6 +47,7 @@ module RuboCop
 
         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
           {(send $!nil? {:match :=~ :match?} (regexp (str $#literal_at_end?) (regopt)))

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

@@ -47,6 +47,7 @@ module RuboCop
       #
       class FixedSize < Base
         MSG = 'Do not compute the size of statically sized objects.'
+        RESTRICT_ON_SEND = %i[count length size].freeze
 
         def_node_matcher :counter, <<~MATCHER
           (send ${array hash str sym} {:count :length :size} $...)

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

@@ -19,6 +19,7 @@ module RuboCop
         extend AutoCorrector
 
         MSG = 'Use `flat_map` instead of `%<method>s...%<flatten>s`.'
+        RESTRICT_ON_SEND = %i[flatten flatten!].freeze
         FLATTEN_MULTIPLE_LEVELS = ' Beware, `flat_map` only flattens 1 level ' \
                                   'and `flatten` can be used to flatten ' \
                                   'multiple levels.'

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

@@ -39,6 +39,8 @@ module RuboCop
       class InefficientHashSearch < Base
         extend AutoCorrector
 
+        RESTRICT_ON_SEND = %i[include?].freeze
+
         def_node_matcher :inefficient_include?, <<~PATTERN
           (send (send $_ {:keys :values}) :include? _)
         PATTERN

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

@@ -29,14 +29,14 @@ module RuboCop
         extend AutoCorrector
 
         MSG = 'Use `%<good>s` instead of `%<bad>s`.'
-        ENUMERABLE_METHODS = (Enumerable.instance_methods + [:each]).freeze
+        RESTRICT_ON_SEND = (Enumerable.instance_methods + [:each]).freeze
 
         def_node_matcher :readlines_on_class?, <<~PATTERN
-          $(send $(send (const nil? {:IO :File}) :readlines ...) #enumerable_method?)
+          $(send $(send (const nil? {:IO :File}) :readlines ...) _)
         PATTERN
 
         def_node_matcher :readlines_on_instance?, <<~PATTERN
-          $(send $(send ${nil? !const_type?} :readlines ...) #enumerable_method? ...)
+          $(send $(send ${nil? !const_type?} :readlines ...) _ ...)
         PATTERN
 
         def on_send(node)
@@ -55,10 +55,6 @@ module RuboCop
 
         private
 
-        def enumerable_method?(node)
-          ENUMERABLE_METHODS.include?(node.to_sym)
-        end
-
         def autocorrect(corrector, enumerable_call, readlines_call, receiver)
           # We cannot safely correct `.readlines` method called on IO/File classes
           # due to its signature and we are not sure with implicit receiver

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

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Performance
+      # This cop identifies places where methods are converted to blocks, with the
+      # use of `&method`, and passed as arguments to method calls.
+      # It is faster to replace those with explicit blocks, calling those methods inside.
+      #
+      # @example
+      #   # bad
+      #   array.map(&method(:do_something))
+      #   [1, 2, 3].each(&out.method(:puts))
+      #
+      #   # good
+      #   array.map { |x| do_something(x) }
+      #   [1, 2, 3].each { |x| out.puts(x) }
+      #
+      class MethodObjectAsBlock < Base
+        MSG = 'Use block explicitly instead of block-passing a method object.'
+
+        def_node_matcher :method_object_as_argument?, <<~PATTERN
+          (^send (send _ :method sym))
+        PATTERN
+
+        def on_block_pass(node)
+          add_offense(node) if method_object_as_argument?(node)
+        end
+      end
+    end
+  end
+end

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

@@ -30,6 +30,7 @@ module RuboCop
       class OpenStruct < Base
         MSG = 'Consider using `Struct` over `OpenStruct` ' \
               'to optimize the performance.'
+        RESTRICT_ON_SEND = %i[new].freeze
 
         def_node_matcher :open_struct, <<~PATTERN
           (send (const {nil? cbase} :OpenStruct) :new ...)

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

@@ -28,6 +28,7 @@ module RuboCop
         extend AutoCorrector
 
         MSG = 'Use `Range#cover?` instead of `Range#%<bad_method>s`.'
+        RESTRICT_ON_SEND = %i[include? member?].freeze
 
         # TODO: If we traced out assignments of variables to their uses, we
         # might pick up on a few more instances of this issue

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

@@ -80,11 +80,11 @@ module RuboCop
         def calls_to_report(argname, body)
           return [] if blockarg_assigned?(body, argname)
 
-          calls = to_enum(:blockarg_calls, body, argname)
+          blockarg_calls(body, argname).map do |call|
+            return [] if args_include_block_pass?(call)
 
-          return [] if calls.any? { |call| args_include_block_pass?(call) }
-
-          calls
+            call
+          end
         end
 
         def args_include_block_pass?(blockcall)

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

@@ -22,6 +22,7 @@ module RuboCop
 
         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
         # a string or regexp literal on one side or the other

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

@@ -29,6 +29,7 @@ module RuboCop
 
         AREF_ASGN = '%<receiver>s[%<key>s] = %<value>s'
         MSG = 'Use `%<prefer>s` instead of `%<current>s`.'
+        RESTRICT_ON_SEND = %i[merge!].freeze
 
         WITH_MODIFIER_CORRECTION = <<~RUBY
           %<keyword>s %<condition>s

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

@@ -44,10 +44,10 @@ module RuboCop
         extend AutoCorrector
 
         MSG = 'Use `%<good_method>s` instead of `%<bad_method>s`.'
-        REPLACEABLE_METHODS = %i[[] slice first last take drop length size empty?].freeze
+        RESTRICT_ON_SEND = %i[[] slice first last take drop length size empty?].freeze
 
         def_node_matcher :redundant_chars_call?, <<~PATTERN
-          (send $(send _ :chars) $#replaceable_method? $...)
+          (send $(send _ :chars) $_ $...)
         PATTERN
 
         def on_send(node)
@@ -66,10 +66,6 @@ module RuboCop
 
         private
 
-        def replaceable_method?(method_name)
-          REPLACEABLE_METHODS.include?(method_name)
-        end
-
         def offense_range(receiver, node)
           range_between(receiver.loc.selector.begin_pos, node.loc.expression.end_pos)
         end

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

@@ -17,6 +17,7 @@ module RuboCop
         extend AutoCorrector
 
         MSG = 'Use `reverse_each` instead of `reverse.each`.'
+        RESTRICT_ON_SEND = %i[each].freeze
         UNDERSCORE = '_'
 
         def_node_matcher :reverse_each?, <<~MATCHER

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

@@ -21,6 +21,7 @@ module RuboCop
         extend AutoCorrector
 
         MSG = 'Use `%<good_method>s` instead of `%<bad_method>s`.'
+        RESTRICT_ON_SEND = %i[first].freeze
 
         def_node_matcher :reverse_first_candidate?, <<~PATTERN
           (send $(send _ :reverse) :first (int _)?)

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

@@ -39,6 +39,7 @@ module RuboCop
         extend AutoCorrector
 
         MSG = 'Use `size` instead of `count`.'
+        RESTRICT_ON_SEND = %i[count].freeze
 
         def_node_matcher :array?, <<~PATTERN
           {

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

@@ -22,6 +22,7 @@ module RuboCop
         extend AutoCorrector
 
         MSG = 'Use `%<prefer>s` instead of `%<current>s`.'
+        RESTRICT_ON_SEND = %i[gsub gsub!].freeze
 
         PREFERRED_METHODS = {
           gsub: :squeeze,
@@ -58,7 +59,7 @@ module RuboCop
         private
 
         def repeating_literal?(regex_str)
-          regex_str.match?(/\A(?:#{Util::LITERAL_REGEX})\+\z/)
+          regex_str.match?(/\A(?:#{Util::LITERAL_REGEX})\+\z/o)
         end
       end
     end

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

@@ -47,6 +47,7 @@ module RuboCop
 
         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
           {(send $!nil? {:match :=~ :match?} (regexp (str $#literal_at_start?) (regopt)))

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

@@ -23,6 +23,7 @@ module RuboCop
         extend AutoCorrector
 
         MSG = 'Use `String#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)))
@@ -47,7 +48,7 @@ module RuboCop
         private
 
         def literal?(regex_str)
-          regex_str.match?(/\A#{Util::LITERAL_REGEX}+\z/)
+          regex_str.match?(/\A#{Util::LITERAL_REGEX}+\z/o)
         end
       end
     end

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

@@ -23,6 +23,7 @@ module RuboCop
         extend AutoCorrector
 
         MSG = 'Use `%<prefer>s` instead of `%<current>s`.'
+        RESTRICT_ON_SEND = %i[gsub gsub!].freeze
         DETERMINISTIC_REGEX = /\A(?:#{LITERAL_REGEX})+\Z/.freeze
         DELETE = 'delete'
         TR = 'tr'

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

@@ -6,28 +6,67 @@ module RuboCop
       # This cop identifies places where custom code finding the sum of elements
       # in some Enumerable object can be replaced by `Enumerable#sum` method.
       #
+      # This cop can change auto-correction scope depending on the value of
+      # `SafeAutoCorrect`.
+      # Its auto-correction is marked as safe by default (`SafeAutoCorrect: true`)
+      # to prevent `TypeError` in auto-correced code when initial value is not
+      # specified as shown below:
+      #
+      # [source,ruby]
+      # ----
+      # ['a', 'b'].sum # => (String can't be coerced into Integer)
+      # ----
+      #
+      # Therefore if initial value is not specified, unsafe auto-corrected will not occur.
+      #
+      # If you always want to enable auto-correction, you can set `SafeAutoCorrect: false`.
+      #
+      # [source,yaml]
+      # ----
+      # Performance/Sum:
+      #   SafeAutoCorrect: false
+      # ----
+      #
+      # Please note that the auto-correction command line option will be changed from
+      # `rubocop -a` to `rubocop -A`, which includes unsafe auto-correction.
+      #
       # @example
       #   # bad
-      #   [1, 2, 3].inject(:+)
+      #   [1, 2, 3].inject(:+)                        # These bad cases with no initial value are unsafe and
+      #   [1, 2, 3].inject(&:+)                       # will not be auto-correced by default. If you want to
+      #   [1, 2, 3].reduce { |acc, elem| acc + elem } # auto-corrected, you can set `SafeAutoCorrect: false`.
       #   [1, 2, 3].reduce(10, :+)
-      #   [1, 2, 3].inject(&:+)
-      #   [1, 2, 3].reduce { |acc, elem| acc + elem }
+      #   [1, 2, 3].map { |elem| elem ** 2 }.sum
+      #   [1, 2, 3].collect(&:count).sum(10)
       #
       #   # good
       #   [1, 2, 3].sum
       #   [1, 2, 3].sum(10)
-      #   [1, 2, 3].sum
+      #   [1, 2, 3].sum { |elem| elem ** 2 }
+      #   [1, 2, 3].sum(10, &:count)
       #
       class Sum < Base
         include RangeHelp
         extend AutoCorrector
 
         MSG = 'Use `%<good_method>s` instead of `%<bad_method>s`.'
+        MSG_IF_NO_INIT_VALUE =
+          'Use `%<good_method>s` instead of `%<bad_method>s`, unless calling `%<bad_method>s` on an empty array.'
+        RESTRICT_ON_SEND = %i[inject reduce sum].freeze
 
         def_node_matcher :sum_candidate?, <<~PATTERN
           (send _ ${:inject :reduce} $_init ? ${(sym :+) (block_pass (sym :+))})
         PATTERN
 
+        def_node_matcher :sum_map_candidate?, <<~PATTERN
+          (send
+            {
+              (block $(send _ {:map :collect}) ...)
+              $(send _ {:map :collect} (block_pass _))
+            }
+          :sum $_init ?)
+        PATTERN
+
         def_node_matcher :sum_with_block_candidate?, <<~PATTERN
           (block
             $(send _ {:inject :reduce} $_init ?)
@@ -41,14 +80,10 @@ module RuboCop
         alias elem_plus_acc? acc_plus_elem?
 
         def on_send(node)
-          sum_candidate?(node) do |method, init, operation|
-            range = sum_method_range(node)
-            message = build_method_message(method, init, operation)
+          return if empty_array_literal?(node)
 
-            add_offense(range, message: message) do |corrector|
-              autocorrect(corrector, init, range)
-            end
-          end
+          handle_sum_candidate(node)
+          handle_sum_map_candidate(node)
         end
 
         def on_block(node)
@@ -66,25 +101,85 @@ module RuboCop
 
         private
 
+        def handle_sum_candidate(node)
+          sum_candidate?(node) do |method, init, operation|
+            range = sum_method_range(node)
+            message = build_method_message(node, method, init, operation)
+
+            add_offense(range, message: message) do |corrector|
+              autocorrect(corrector, init, range)
+            end
+          end
+        end
+
+        def handle_sum_map_candidate(node)
+          sum_map_candidate?(node) do |map, init|
+            next if node.block_literal? || node.block_argument?
+
+            message = build_sum_map_message(map.method_name, init)
+
+            add_offense(sum_map_range(map, node), message: message) do |corrector|
+              autocorrect_sum_map(corrector, node, map, init)
+            end
+          end
+        end
+
+        def empty_array_literal?(node)
+          receiver = node.children.first
+          array_literal?(node) && receiver && receiver.children.empty?
+        end
+
+        def array_literal?(node)
+          receiver = node.children.first
+          receiver&.literal? && receiver&.array_type?
+        end
+
         def autocorrect(corrector, init, range)
-          return if init.empty?
+          return if init.empty? && safe_autocorrect?
 
           replacement = build_good_method(init)
 
           corrector.replace(range, replacement)
         end
 
+        def autocorrect_sum_map(corrector, sum, map, init)
+          sum_range = method_call_with_args_range(sum)
+          map_range = method_call_with_args_range(map)
+
+          block_pass = map.last_argument if map.last_argument&.block_pass_type?
+          replacement = build_good_method(init, block_pass)
+
+          corrector.remove(sum_range)
+          corrector.replace(map_range, ".#{replacement}")
+        end
+
         def sum_method_range(node)
           range_between(node.loc.selector.begin_pos, node.loc.end.end_pos)
         end
 
+        def sum_map_range(map, sum)
+          range_between(map.loc.selector.begin_pos, sum.source_range.end.end_pos)
+        end
+
         def sum_block_range(send, node)
           range_between(send.loc.selector.begin_pos, node.loc.end.end_pos)
         end
 
-        def build_method_message(method, init, operation)
+        def build_method_message(node, method, init, operation)
           good_method = build_good_method(init)
           bad_method = build_method_bad_method(init, method, operation)
+          msg = if init.empty? && !array_literal?(node)
+                  MSG_IF_NO_INIT_VALUE
+                else
+                  MSG
+                end
+          format(msg, good_method: good_method, bad_method: bad_method)
+        end
+
+        def build_sum_map_message(method, init)
+          sum_method = build_good_method(init)
+          good_method = "#{sum_method} { ... }"
+          bad_method = "#{method} { ... }.#{sum_method}"
           format(MSG, good_method: good_method, bad_method: bad_method)
         end
 
@@ -94,13 +189,16 @@ module RuboCop
           format(MSG, good_method: good_method, bad_method: bad_method)
         end
 
-        def build_good_method(init)
+        def build_good_method(init, block_pass = nil)
           good_method = 'sum'
 
+          args = []
           unless init.empty?
             init = init.first
-            good_method += "(#{init.source})" unless init.int_type? && init.value.zero?
+            args << init.source unless init.int_type? && init.value.zero?
           end
+          args << block_pass.source if block_pass
+          good_method += "(#{args.join(', ')})" unless args.empty?
           good_method
         end
 
@@ -128,6 +226,10 @@ module RuboCop
           bad_method += " { |#{var_acc}, #{var_elem}| #{body.source} }"
           bad_method
         end
+
+        def method_call_with_args_range(node)
+          node.receiver.source_range.end.join(node.source_range.end)
+        end
       end
     end
   end

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

@@ -23,6 +23,7 @@ module RuboCop
         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
 
         def on_send(node)
           check(node)

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

@@ -10,6 +10,7 @@ module RuboCop
       # 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.
       #
       # @example
@@ -24,7 +25,10 @@ module RuboCop
       #   +'something'
       #   +''
       class UnfreezeString < Base
+        extend AutoCorrector
+
         MSG = 'Use unary plus to get an unfrozen string literal.'
+        RESTRICT_ON_SEND = %i[dup new].freeze
 
         def_node_matcher :dup_string?, <<~PATTERN
           (send {str dstr} :dup)
@@ -38,7 +42,21 @@ module RuboCop
         PATTERN
 
         def on_send(node)
-          add_offense(node) if dup_string?(node) || string_new?(node)
+          return unless dup_string?(node) || string_new?(node)
+
+          add_offense(node) do |corrector|
+            corrector.replace(node, "+#{string_value(node)}")
+          end
+        end
+
+        private
+
+        def string_value(node)
+          if node.receiver.source == 'String' && node.method?(:new)
+            node.arguments.empty? ? "''" : node.first_argument.source
+          else
+            node.receiver.source
+          end
         end
       end
     end

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

@@ -18,6 +18,7 @@ module RuboCop
 
         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
           (send

data/lib/rubocop/cop/performance_cops.rb

@@ -4,13 +4,16 @@ require_relative 'mixin/regexp_metacharacter'
 require_relative 'mixin/sort_block'
 
 require_relative 'performance/ancestors_include'
+require_relative 'performance/array_semi_infinite_range_slice'
 require_relative 'performance/big_decimal_with_numeric_argument'
 require_relative 'performance/bind_call'
+require_relative 'performance/block_given_with_explicit_block'
 require_relative 'performance/caller'
 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/constant_regexp'
 require_relative 'performance/count'
 require_relative 'performance/delete_prefix'
 require_relative 'performance/delete_suffix'
@@ -20,6 +23,7 @@ require_relative 'performance/end_with'
 require_relative 'performance/fixed_size'
 require_relative 'performance/flat_map'
 require_relative 'performance/inefficient_hash_search'
+require_relative 'performance/method_object_as_block'
 require_relative 'performance/open_struct'
 require_relative 'performance/range_include'
 require_relative 'performance/io_readlines'

data/lib/rubocop/performance/version.rb

@@ -2,8 +2,13 @@
 
 module RuboCop
   module Performance
+    # This module holds the RuboCop Performance version information.
     module Version
-      STRING = '1.8.1'
+      STRING = '1.9.0'
+
+      def self.document_version
+        STRING.match('\d+\.\d+').to_s
+      end
     end
   end
 end

metadata

@@ -1,16 +1,16 @@
 --- !ruby/object:Gem::Specification
 name: rubocop-performance
 version: !ruby/object:Gem::Version
-  version: 1.8.1
+  version: 1.9.0
 platform: ruby
 authors:
 - Bozhidar Batsov
 - Jonas Arvidsson
 - Yuji Nakayama
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2020-09-18 00:00:00.000000000 Z
+date: 2020-11-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rubocop
@@ -18,14 +18,20 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.87.0
+        version: 0.90.0
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '2.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.87.0
+        version: 0.90.0
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '2.0'
 - !ruby/object:Gem::Dependency
   name: rubocop-ast
   requirement: !ruby/object:Gem::Requirement
@@ -40,20 +46,6 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: 0.4.0
-- !ruby/object:Gem::Dependency
-  name: simplecov
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
 description: |
   A collection of RuboCop cops to check for performance optimizations
   in Ruby code.
@@ -71,14 +63,17 @@ files:
 - lib/rubocop/cop/mixin/regexp_metacharacter.rb
 - lib/rubocop/cop/mixin/sort_block.rb
 - lib/rubocop/cop/performance/ancestors_include.rb
+- lib/rubocop/cop/performance/array_semi_infinite_range_slice.rb
 - lib/rubocop/cop/performance/big_decimal_with_numeric_argument.rb
 - lib/rubocop/cop/performance/bind_call.rb
+- lib/rubocop/cop/performance/block_given_with_explicit_block.rb
 - lib/rubocop/cop/performance/caller.rb
 - lib/rubocop/cop/performance/case_when_splat.rb
 - lib/rubocop/cop/performance/casecmp.rb
 - 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/constant_regexp.rb
 - lib/rubocop/cop/performance/count.rb
 - lib/rubocop/cop/performance/delete_prefix.rb
 - lib/rubocop/cop/performance/delete_suffix.rb
@@ -89,6 +84,7 @@ files:
 - lib/rubocop/cop/performance/flat_map.rb
 - lib/rubocop/cop/performance/inefficient_hash_search.rb
 - lib/rubocop/cop/performance/io_readlines.rb
+- lib/rubocop/cop/performance/method_object_as_block.rb
 - lib/rubocop/cop/performance/open_struct.rb
 - lib/rubocop/cop/performance/range_include.rb
 - lib/rubocop/cop/performance/redundant_block_call.rb
@@ -120,9 +116,9 @@ metadata:
   homepage_uri: https://docs.rubocop.org/rubocop-performance/
   changelog_uri: https://github.com/rubocop-hq/rubocop-performance/blob/master/CHANGELOG.md
   source_code_uri: https://github.com/rubocop-hq/rubocop-performance/
-  documentation_uri: https://docs.rubocop.org/rubocop-performance/
+  documentation_uri: https://docs.rubocop.org/rubocop-performance/1.9/
   bug_tracker_uri: https://github.com/rubocop-hq/rubocop-performance/issues
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -137,8 +133,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.1.4
-signing_key: 
+rubygems_version: 3.2.0.rc.2
+signing_key:
 specification_version: 4
 summary: Automatic performance checking tool for Ruby code.
 test_files: []