rubocop-performance 1.18.0 → 1.21.0

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

@@ -12,6 +12,12 @@ module RuboCop
       # @safety
       #   This cop is unsafe because `Range#include?` (or `Range#member?`) and `Range#cover?`
       #   are not equivalent behavior.
+      #   Example of a case where `Range#cover?` may not provide the desired result:
+      #
+      #   [source,ruby]
+      #   ----
+      #   ('a'..'z').cover?('yellow') # => true
+      #   ----
       #
       # @example
       #   # bad
@@ -20,11 +26,6 @@ module RuboCop
       #
       #   # good
       #   ('a'..'z').cover?('b') # => true
-      #
-      #   # Example of a case where `Range#cover?` may not provide
-      #   # the desired result:
-      #
-      #   ('a'..'z').cover?('yellow') # => true
       class RangeInclude < Base
         extend AutoCorrector
 
@@ -37,7 +38,7 @@ module RuboCop
         # (We don't even catch it if the Range is in double parens)
 
         def_node_matcher :range_include, <<~PATTERN
-          (send {irange erange (begin {irange erange})} ${:include? :member?} ...)
+          (call {irange erange (begin {irange erange})} ${:include? :member?} ...)
         PATTERN
 
         def on_send(node)
@@ -49,6 +50,7 @@ module RuboCop
             end
           end
         end
+        alias on_csend on_send
       end
     end
   end

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

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

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

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

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

@@ -23,6 +23,8 @@ module RuboCop
         MSG = 'Use `=~` in places where the `MatchData` returned by `#match` will not be used.'
         RESTRICT_ON_SEND = %i[match].freeze
 
+        HIGHER_PRECEDENCE_OPERATOR_METHODS = %i[| ^ & + - * / % ** > >= < <= << >>].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
         def_node_matcher :match_call?, <<~PATTERN
@@ -47,7 +49,7 @@ module RuboCop
         private
 
         def autocorrect(corrector, node)
-          new_source = "#{node.receiver.source} =~ #{node.first_argument.source}"
+          new_source = "#{node.receiver.source} =~ #{replacement(node)}"
 
           corrector.replace(node, new_source)
         end
@@ -57,6 +59,33 @@ module RuboCop
           # register an offense in that case
           node.receiver.regexp_type? || node.first_argument.regexp_type?
         end
+
+        def replacement(node)
+          arg = node.first_argument
+
+          if requires_parentheses?(arg)
+            "(#{arg.source})"
+          else
+            arg.source
+          end
+        end
+
+        def requires_parentheses?(arg)
+          return true if arg.if_type? && arg.ternary?
+          return true if arg.and_type? || arg.or_type? || arg.range_type?
+
+          call_like?(arg) && requires_parentheses_for_call_like?(arg)
+        end
+
+        def requires_parentheses_for_call_like?(arg)
+          return false if arg.parenthesized? || !arg.arguments?
+
+          !HIGHER_PRECEDENCE_OPERATOR_METHODS.include?(arg.method_name)
+        end
+
+        def call_like?(arg)
+          arg.call_type? || arg.yield_type? || arg.super_type?
+        end
       end
     end
   end

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

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

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

@@ -21,7 +21,7 @@ module RuboCop
         STR_SPECIAL_CHARS = %w[\n \" \' \\\\ \t \b \f \r].freeze
 
         def_node_matcher :split_call_with_regexp?, <<~PATTERN
-          {(send !nil? :split $regexp)}
+          {(call !nil? :split $regexp)}
         PATTERN
 
         def on_send(node)
@@ -35,6 +35,7 @@ module RuboCop
             corrector.replace(regexp_node, "\"#{new_argument}\"")
           end
         end
+        alias on_csend on_send
 
         private
 

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

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

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

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

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

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

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

@@ -24,10 +24,6 @@ module RuboCop
         MSG = 'Use `filter_map` instead of `%<method_name>s.map`.'
         RESTRICT_ON_SEND = %i[select filter].freeze
 
-        def_node_matcher :bad_method?, <<~PATTERN
-          (send nil? :bad_method ...)
-        PATTERN
-
         def on_send(node)
           return if (first_argument = node.first_argument) && !first_argument.block_pass_type?
           return unless (send_node = map_method_candidate(node))
@@ -38,15 +34,16 @@ module RuboCop
           range = offense_range(node, map_method)
           add_offense(range, message: format(MSG, method_name: node.method_name))
         end
+        alias on_csend on_send
 
         private
 
         def map_method_candidate(node)
           return unless (parent = node.parent)
 
-          if parent.block_type? && parent.parent&.send_type?
+          if parent.block_type? && parent.parent&.call_type?
             parent.parent
-          elsif parent.send_type?
+          elsif parent.call_type?
             parent
           end
         end

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

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

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

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

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

@@ -27,7 +27,7 @@ module RuboCop
         PREFERRED_METHODS = { gsub: :squeeze, gsub!: :squeeze! }.freeze
 
         def_node_matcher :squeeze_candidate?, <<~PATTERN
-          (send
+          (call
             $!nil? ${:gsub :gsub!}
             (regexp
               (str $#repeating_literal?)
@@ -35,6 +35,7 @@ module RuboCop
             (str $_))
         PATTERN
 
+        # rubocop:disable Metrics/AbcSize
         def on_send(node)
           squeeze_candidate?(node) do |receiver, bad_method, regexp_str, replace_str|
             regexp_str = regexp_str[0..-2] # delete '+' from the end
@@ -46,12 +47,14 @@ module RuboCop
 
             add_offense(node.loc.selector, message: message) do |corrector|
               string_literal = to_string_literal(replace_str)
-              new_code = "#{receiver.source}.#{good_method}(#{string_literal})"
+              new_code = "#{receiver.source}#{node.loc.dot.source}#{good_method}(#{string_literal})"
 
               corrector.replace(node, new_code)
             end
           end
         end
+        # rubocop:enable Metrics/AbcSize
+        alias on_csend on_send
 
         private
 

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

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

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

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

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

@@ -16,6 +16,7 @@ module RuboCop
       #   /ab/ =~ str
       #   str.match(/ab/)
       #   /ab/.match(str)
+      #   /ab/ === str
       #
       #   # good
       #   str.include?('ab')
@@ -23,14 +24,16 @@ module RuboCop
         extend AutoCorrector
 
         MSG = 'Use `%<negation>sString#include?` instead of a regex match with literal-only pattern.'
-        RESTRICT_ON_SEND = %i[match =~ !~ match?].freeze
+        RESTRICT_ON_SEND = %i[match =~ !~ match? ===].freeze
 
         def_node_matcher :redundant_regex?, <<~PATTERN
-          {(send $!nil? {:match :=~ :!~ :match?} (regexp (str $#literal?) (regopt)))
-           (send (regexp (str $#literal?) (regopt)) {:match :match?} $_)
-           (match-with-lvasgn (regexp (str $#literal?) (regopt)) $_)}
+          {(call $!nil? {:match :=~ :!~ :match?} (regexp (str $#literal?) (regopt)))
+           (send (regexp (str $#literal?) (regopt)) {:match :match? :===} $_)
+           (match-with-lvasgn (regexp (str $#literal?) (regopt)) $_)
+           (send (regexp (str $#literal?) (regopt)) :=~ $_)}
         PATTERN
 
+        # rubocop:disable Metrics/AbcSize
         def on_send(node)
           return unless (receiver, regex_str = redundant_regex?(node))
 
@@ -40,12 +43,15 @@ module RuboCop
           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)
+            dot = node.loc.dot ? node.loc.dot.source : '.'
 
-            new_source = "#{'!' if negation}#{receiver.source}.include?(#{to_string_literal(regex_str)})"
+            new_source = "#{'!' if negation}#{receiver.source}#{dot}include?(#{to_string_literal(regex_str)})"
 
             corrector.replace(node, new_source)
           end
         end
+        # rubocop:enable Metrics/AbcSize
+        alias on_csend on_send
         alias on_match_with_lvasgn on_send
 
         private

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

@@ -29,7 +29,7 @@ module RuboCop
         BANG = '!'
 
         def_node_matcher :string_replacement?, <<~PATTERN
-          (send _ {:gsub :gsub!}
+          (call _ {:gsub :gsub!}
                     ${regexp str (send (const nil? :Regexp) {:new :compile} _)}
                     $str)
         PATTERN
@@ -42,6 +42,7 @@ module RuboCop
             offense(node, first_param, second_param)
           end
         end
+        alias on_csend on_send
 
         private
 

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

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