rubocop 0.42.0 → 0.52.1

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

@@ -1,49 +1,53 @@
-# encoding: utf-8
 # frozen_string_literal: true
 
 module RuboCop
   module Cop
     module Performance
-      # This cop identifies use of `Regexp#match` or `String#match in a context
-      # where the integral return value of `=~` would do just as well.
+      # This cop identifies the use of `Regexp#match` or `String#match`, which
+      # returns `#<MatchData>`/`nil`. The return value of `=~` is an integral
+      # index/`nil` and is more performant.
       #
       # @example
-      #   @bad
+      #   # bad
       #   do_something if str.match(/regex/)
       #   while regex.match('str')
       #     do_something
       #   end
       #
-      #   @good
-      #   method(str.match(/regex/))
-      #   return regex.match('str')
+      #   # good
+      #   method(str =~ /regex/)
+      #   return value unless regex =~ 'str'
       class RedundantMatch < Cop
         MSG = 'Use `=~` in places where the `MatchData` returned by ' \
               '`#match` will not be used.'.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?, <<-END
+        def_node_matcher :match_call?, <<-PATTERN
           {(send {str regexp} :match _)
-           (send !nil :match {str regexp})}
-        END
+           (send !nil? :match {str regexp})}
+        PATTERN
 
-        def_node_matcher :only_truthiness_matters?, <<-END
+        def_node_matcher :only_truthiness_matters?, <<-PATTERN
           ^({if while until case while_post until_post} equal?(%0) ...)
-        END
+        PATTERN
 
         def on_send(node)
           return unless match_call?(node) &&
                         (!node.value_used? || only_truthiness_matters?(node)) &&
                         !(node.parent && node.parent.block_type?)
-          add_offense(node, :expression, MSG)
+
+          add_offense(node)
         end
 
         def autocorrect(node)
           # Regexp#match can take a second argument, but this cop doesn't
           # register an offense in that case
-          receiver, _method, arg = *node
-          new_source = receiver.source + ' =~ ' + arg.source
+          return unless node.first_argument.regexp_type?
+
+          new_source =
+            node.receiver.source + ' =~ ' + node.first_argument.source
+
           ->(corrector) { corrector.replace(node.source_range, new_source) }
         end
       end

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

@@ -1,4 +1,3 @@
-# encoding: utf-8
 # frozen_string_literal: true
 
 module RuboCop
@@ -12,86 +11,92 @@ module RuboCop
       #   hash.merge!({'key' => 'value'})
       #   hash.merge!(a: 1, b: 2)
       class RedundantMerge < Cop
-        AREF_ASGN = '%s[%s] = %s'.freeze
-        MSG = 'Use `%s` instead of `%s`.'.freeze
+        AREF_ASGN = '%<receiver>s[%<key>s] = %<value>s'.freeze
+        MSG = 'Use `%<prefer>s` instead of `%<current>s`.'.freeze
 
-        def_node_matcher :redundant_merge, '(send $_ :merge! (hash $...))'
-        def_node_matcher :modifier_flow_control, <<-END
+        def_node_matcher :redundant_merge_candidate, <<-PATTERN
+          (send $!nil? :merge! [(hash $...) !kwsplat_type?])
+        PATTERN
+
+        def_node_matcher :modifier_flow_control?, <<-PATTERN
           [{if while until} modifier_form?]
-        END
-        def_node_matcher :each_with_object_node, <<-END
-          (block (send _ :each_with_object _) (args _ $_) ...)
-        END
+        PATTERN
 
         def on_send(node)
-          each_redundant_merge(node) do |receiver, pairs|
-            assignments = to_assignments(receiver, pairs).join('; ')
-            message = format(MSG, assignments, node.source)
-            add_offense(node, :expression, message)
+          each_redundant_merge(node) do |redundant_merge_node|
+            add_offense(redundant_merge_node)
           end
         end
 
         def autocorrect(node)
-          redundant_merge(node) do |receiver, pairs|
-            lambda do |corrector|
-              new_source = to_assignments(receiver, pairs).join("\n")
-
-              parent = node.parent
-              if parent && pairs.size > 1
-                if modifier_flow_control(parent)
-                  new_source = rewrite_with_modifier(node, parent, new_source)
-                  node = parent
-                else
-                  padding = "\n#{leading_spaces(node)}"
-                  new_source.gsub!(/\n/, padding)
-                end
-              end
-
-              corrector.replace(node.source_range, new_source)
+          redundant_merge_candidate(node) do |receiver, pairs|
+            new_source = to_assignments(receiver, pairs).join("\n")
+
+            if node.parent && pairs.size > 1
+              correct_multiple_elements(node, node.parent, new_source)
+            else
+              correct_single_element(node, new_source)
             end
           end
         end
 
         private
 
-        def each_redundant_merge(node)
-          redundant_merge(node) do |receiver, pairs|
-            next if node.value_used? &&
-                    !value_used_inside_each_with_object?(node, receiver)
-            next if pairs.size > 1 && !receiver.pure?
-            next if pairs.size > max_key_value_pairs
+        def message(node)
+          redundant_merge_candidate(node) do |receiver, pairs|
+            assignments = to_assignments(receiver, pairs).join('; ')
 
-            yield receiver, pairs
+            format(MSG, prefer: assignments, current: node.source)
           end
         end
 
-        def value_used_inside_each_with_object?(node, receiver)
-          while receiver.respond_to?(:send_type?) && receiver.send_type?
-            receiver, = *receiver
+        def each_redundant_merge(node)
+          redundant_merge_candidate(node) do |receiver, pairs|
+            next if non_redundant_merge?(node, receiver, pairs)
+
+            yield node
           end
+        end
 
-          unless receiver.respond_to?(:lvar_type?) && receiver.lvar_type?
-            return false
+        def non_redundant_merge?(node, receiver, pairs)
+          non_redundant_pairs?(receiver, pairs) ||
+            non_redundant_value_used?(receiver, node)
+        end
+
+        def non_redundant_pairs?(receiver, pairs)
+          pairs.size > 1 && !receiver.pure? || pairs.size > max_key_value_pairs
+        end
+
+        def non_redundant_value_used?(receiver, node)
+          node.value_used? &&
+            !EachWithObjectInspector.new(node, receiver).value_used?
+        end
+
+        def correct_multiple_elements(node, parent, new_source)
+          if modifier_flow_control?(parent)
+            new_source = rewrite_with_modifier(node, parent, new_source)
+            node = parent
+          else
+            padding = "\n#{leading_spaces(node)}"
+            new_source.gsub!(/\n/, padding)
           end
 
-          parent = node.parent
-          grandparent = parent.parent if parent.begin_type?
-          second_arg = each_with_object_node(grandparent || parent)
-          return false if second_arg.nil?
+          ->(corrector) { corrector.replace(node.source_range, new_source) }
+        end
 
-          receiver.loc.name.source == second_arg.loc.name.source
+        def correct_single_element(node, new_source)
+          ->(corrector) { corrector.replace(node.source_range, new_source) }
         end
 
         def to_assignments(receiver, pairs)
           pairs.map do |pair|
             key, value = *pair
-            key_src = if key.sym_type? && !key.source.start_with?(':')
-                        ":#{key.source}"
-                      else
-                        key.source
-                      end
 
-            format(AREF_ASGN, receiver.source, key_src, value.source)
+            key = key.sym_type? && pair.colon? ? ":#{key.source}" : key.source
+
+            format(AREF_ASGN, receiver: receiver.source,
+                              key: key,
+                              value: value.source)
           end
         end
 
@@ -115,6 +120,49 @@ module RuboCop
         def max_key_value_pairs
           cop_config['MaxKeyValuePairs'].to_i
         end
+
+        # A utility class for checking the use of values within an
+        # `each_with_object` call.
+        class EachWithObjectInspector
+          extend NodePattern::Macros
+
+          def initialize(node, receiver)
+            @node = node
+            @receiver = unwind(receiver)
+          end
+
+          def value_used?
+            return false unless eligible_receiver? && second_argument
+
+            receiver.loc.name.source == second_argument.loc.name.source
+          end
+
+          private
+
+          attr_reader :node, :receiver
+
+          def eligible_receiver?
+            receiver.respond_to?(:lvar_type?) && receiver.lvar_type?
+          end
+
+          def second_argument
+            parent = node.parent
+            parent = parent.parent if parent.begin_type?
+
+            @second_argument ||= each_with_object_node(parent)
+          end
+
+          def unwind(receiver)
+            while receiver.respond_to?(:send_type?) && receiver.send_type?
+              receiver, = *receiver
+            end
+            receiver
+          end
+
+          def_node_matcher :each_with_object_node, <<-PATTERN
+            (block (send _ :each_with_object _) (args _ $_) ...)
+          PATTERN
+        end
       end
     end
   end

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

@@ -1,4 +1,3 @@
-# encoding: utf-8
 # frozen_string_literal: true
 
 module RuboCop
@@ -8,36 +7,40 @@ module RuboCop
       # `sort`.
       #
       # @example
-      #   @bad
+      #   # bad
       #   array.sort_by { |x| x }
       #   array.sort_by do |var|
       #     var
       #   end
       #
-      #   @good
+      #   # good
       #   array.sort
       class RedundantSortBy < Cop
-        MSG = 'Use `sort` instead of `sort_by { |%s| %s }`.'.freeze
+        MSG = 'Use `sort` instead of `sort_by { |%<var>s| %<var>s }`.'.freeze
 
-        def_node_matcher :redundant_sort_by, <<-END
+        def_node_matcher :redundant_sort_by, <<-PATTERN
           (block $(send _ :sort_by) (args (arg $_x)) (lvar _x))
-        END
+        PATTERN
 
         def on_block(node)
           redundant_sort_by(node) do |send, var_name|
-            range = Parser::Source::Range.new(node.source_range.source_buffer,
-                                              send.loc.selector.begin_pos,
-                                              node.loc.end.end_pos)
-            add_offense(node, range, format(MSG, var_name, var_name))
+            range = sort_by_range(send, node)
+
+            add_offense(node,
+                        location: range,
+                        message: format(MSG, var: var_name))
           end
         end
 
         def autocorrect(node)
           send, = *node
-          range = Parser::Source::Range.new(node.source_range.source_buffer,
-                                            send.loc.selector.begin_pos,
-                                            node.loc.end.end_pos)
-          ->(corrector) { corrector.replace(range, 'sort') }
+          ->(corrector) { corrector.replace(sort_by_range(send, node), 'sort') }
+        end
+
+        private
+
+        def sort_by_range(send, node)
+          range_between(send.loc.selector.begin_pos, node.loc.end.end_pos)
         end
       end
     end

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

@@ -0,0 +1,224 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Performance
+      # In Ruby 2.4, `String#match?`, `Regexp#match?` and `Symbol#match?`
+      # have been added. The methods are faster than `match`.
+      # Because the methods avoid creating a `MatchData` object or saving
+      # backref.
+      # So, when `MatchData` is not used, use `match?` instead of `match`.
+      #
+      # @example
+      #   # bad
+      #   def foo
+      #     if x =~ /re/
+      #       do_something
+      #     end
+      #   end
+      #
+      #   # bad
+      #   def foo
+      #     if x.match(/re/)
+      #       do_something
+      #     end
+      #   end
+      #
+      #   # bad
+      #   def foo
+      #     if /re/ === x
+      #       do_something
+      #     end
+      #   end
+      #
+      #   # good
+      #   def foo
+      #     if x.match?(/re/)
+      #       do_something
+      #     end
+      #   end
+      #
+      #   # good
+      #   def foo
+      #     if x =~ /re/
+      #       do_something(Regexp.last_match)
+      #     end
+      #   end
+      #
+      #   # good
+      #   def foo
+      #     if x.match(/re/)
+      #       do_something($~)
+      #     end
+      #   end
+      #
+      #   # good
+      #   def foo
+      #     if /re/ === x
+      #       do_something($~)
+      #     end
+      #   end
+      class RegexpMatch < Cop
+        extend TargetRubyVersion
+
+        minimum_target_ruby_version 2.4
+
+        MSG =
+          'Use `match?` instead of `%<current>s` when `MatchData` ' \
+          'is not used.'.freeze
+
+        def_node_matcher :match_method?, <<-PATTERN
+          {
+            (send _recv :match _)
+            (send _recv :match _ (int ...))
+          }
+        PATTERN
+
+        def_node_matcher :match_operator?, <<-PATTERN
+          (send !nil? :=~ !nil?)
+        PATTERN
+
+        def_node_matcher :match_threequals?, <<-PATTERN
+          (send (regexp (str _) {(regopt) (regopt _)}) :=== !nil?)
+        PATTERN
+
+        def match_with_lvasgn?(node)
+          return false unless node.match_with_lvasgn_type?
+          regexp, _rhs = *node
+          regexp.to_regexp.named_captures.empty?
+        end
+
+        MATCH_NODE_PATTERN = <<-PATTERN.freeze
+          {
+            #match_method?
+            #match_operator?
+            #match_threequals?
+            #match_with_lvasgn?
+          }
+        PATTERN
+
+        def_node_matcher :match_node?, MATCH_NODE_PATTERN
+        def_node_search :search_match_nodes, MATCH_NODE_PATTERN
+
+        def_node_search :last_matches, <<-PATTERN
+          {
+            (send (const nil? :Regexp) :last_match)
+            (send (const nil? :Regexp) :last_match _)
+            ({back_ref nth_ref} _)
+            (gvar #match_gvar?)
+          }
+        PATTERN
+
+        def on_if(node)
+          check_condition(node.condition)
+        end
+
+        def on_case(node)
+          return if node.condition
+
+          node.each_when do |when_node|
+            when_node.each_condition do |condition|
+              check_condition(condition)
+            end
+          end
+        end
+
+        def autocorrect(node)
+          lambda do |corrector|
+            if match_method?(node)
+              corrector.replace(node.loc.selector, 'match?')
+            elsif match_operator?(node) || match_threequals?(node)
+              recv, _, arg = *node
+              correct_operator(corrector, recv, arg)
+            elsif match_with_lvasgn?(node)
+              recv, arg = *node
+              correct_operator(corrector, recv, arg)
+            end
+          end
+        end
+
+        private
+
+        def check_condition(cond)
+          match_node?(cond) do
+            return if last_match_used?(cond)
+
+            add_offense(cond)
+          end
+        end
+
+        def message(node)
+          format(MSG, current: node.loc.selector.source)
+        end
+
+        def last_match_used?(match_node)
+          scope_root = scope_root(match_node)
+          body = scope_root ? scope_body(scope_root) : match_node.ancestors.last
+          match_node_pos = match_node.loc.expression.begin_pos
+
+          next_match_pos = next_match_pos(body, match_node_pos, scope_root)
+          range = match_node_pos..next_match_pos
+
+          find_last_match(body, range, scope_root)
+        end
+
+        def next_match_pos(body, match_node_pos, scope_root)
+          node = search_match_nodes(body).find do |match|
+            match.loc.expression.begin_pos > match_node_pos &&
+              scope_root(match) == scope_root
+          end
+          node ? node.loc.expression.begin_pos : Float::INFINITY
+        end
+
+        def find_last_match(body, range, scope_root)
+          last_matches(body).find do |ref|
+            ref_pos = ref.loc.expression.begin_pos
+            range.cover?(ref_pos) &&
+              scope_root(ref) == scope_root
+          end
+        end
+
+        def scope_body(node)
+          children = node.children
+          case node.type
+          when :module
+            children[1]
+          when :defs
+            children[3]
+          else
+            children[2]
+          end
+        end
+
+        def scope_root(node)
+          node.each_ancestor.find do |ancestor|
+            ancestor.def_type? ||
+              ancestor.defs_type? ||
+              ancestor.class_type? ||
+              ancestor.module_type?
+          end
+        end
+
+        def match_gvar?(sym)
+          %i[
+            $~
+            $MATCH
+            $PREMATCH
+            $POSTMATCH
+            $LAST_PAREN_MATCH
+            $LAST_MATCH_INFO
+          ].include?(sym)
+        end
+
+        def correct_operator(corrector, recv, arg)
+          buffer = processed_source.buffer
+          op_begin_pos = recv.loc.expression.end_pos
+          op_end_pos = arg.loc.expression.begin_pos
+          op_range = Parser::Source::Range.new(buffer, op_begin_pos, op_end_pos)
+          corrector.replace(op_range, '.match?(')
+          corrector.insert_after(arg.loc.expression, ')')
+        end
+      end
+    end
+  end
+end

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

@@ -1,4 +1,3 @@
-# encoding: utf-8
 # frozen_string_literal: true
 
 module RuboCop
@@ -23,14 +22,12 @@ module RuboCop
 
         def on_send(node)
           reverse_each?(node) do |receiver|
-            source_buffer = node.source_range.source_buffer
             location_of_reverse = receiver.loc.selector.begin_pos
             end_location = node.loc.selector.end_pos
 
-            range = Parser::Source::Range.new(source_buffer,
-                                              location_of_reverse,
-                                              end_location)
-            add_offense(node, range, MSG)
+            range = range_between(location_of_reverse, end_location)
+
+            add_offense(node, location: range)
           end
         end