rubocop 0.82.0 → 1.18.4

data/lib/rubocop/cop/style/redundant_return.rb

@@ -47,8 +47,9 @@ module RuboCop
       #     return x, y
       #   end
       #
-      class RedundantReturn < Cop
+      class RedundantReturn < Base
         include RangeHelp
+        extend AutoCorrector
 
         MSG = 'Redundant `return` detected.'
         MULTI_RETURN_MSG = 'To return multiple values, use an array.'
@@ -58,16 +59,6 @@ module RuboCop
         end
         alias on_defs on_def
 
-        def autocorrect(node)
-          lambda do |corrector|
-            if node.arguments?
-              correct_with_arguments(node, corrector)
-            else
-              correct_without_arguments(node, corrector)
-            end
-          end
-        end
-
         private
 
         def correct_without_arguments(return_node, corrector)
@@ -75,14 +66,17 @@ module RuboCop
         end
 
         def correct_with_arguments(return_node, corrector)
-          if return_node.arguments.size > 1
+          if return_node.children.size > 1
             add_brackets(corrector, return_node)
           elsif hash_without_braces?(return_node.first_argument)
             add_braces(corrector, return_node.first_argument)
           end
+          if return_node.splat_argument?
+            first_argument = return_node.first_argument
+            corrector.replace(first_argument, first_argument.source.delete_prefix('*'))
+          end
 
-          keyword = range_with_surrounding_space(range: return_node.loc.keyword,
-                                                 side: :right)
+          keyword = range_with_surrounding_space(range: return_node.loc.keyword, side: :right)
           corrector.remove(keyword)
         end
 
@@ -108,8 +102,8 @@ module RuboCop
           when :return then check_return_node(node)
           when :case   then check_case_node(node)
           when :if     then check_if_node(node)
-          when :rescue, :resbody
-            check_rescue_node(node)
+          when :rescue then check_rescue_node(node)
+          when :resbody then check_resbody_node(node)
           when :ensure then check_ensure_node(node)
           when :begin, :kwbegin
             check_begin_node(node)
@@ -118,10 +112,15 @@ module RuboCop
         # rubocop:enable Metrics/CyclomaticComplexity
 
         def check_return_node(node)
-          return if cop_config['AllowMultipleReturnValues'] &&
-                    node.children.size > 1
+          return if cop_config['AllowMultipleReturnValues'] && node.children.size > 1
 
-          add_offense(node, location: :keyword)
+          add_offense(node.loc.keyword, message: message(node)) do |corrector|
+            if node.arguments?
+              correct_with_arguments(node, corrector)
+            else
+              correct_without_arguments(node, corrector)
+            end
+          end
         end
 
         def check_case_node(node)
@@ -137,9 +136,12 @@ module RuboCop
         end
 
         def check_rescue_node(node)
-          node.child_nodes.each do |child_node|
-            check_branch(child_node)
-          end
+          node.branches.each { |branch| check_branch(branch) }
+          check_branch(node.body) unless node.else?
+        end
+
+        def check_resbody_node(node)
+          check_branch(node.body)
         end
 
         def check_ensure_node(node)

data/lib/rubocop/cop/style/redundant_self.rb

@@ -11,7 +11,7 @@ module RuboCop
       #   presence of a method name clash with an argument or a local
       #   variable.
       #
-      # * Calling an attribute writer to prevent an local variable assignment.
+      # * Calling an attribute writer to prevent a local variable assignment.
       #
       # Note, with using explicit self you can only send messages with public or
       # protected scope, you cannot send private messages this way.
@@ -41,9 +41,16 @@ module RuboCop
       #       self.bar == bar  # Resolves name clash with argument of the block.
       #     end
       #   end
-      class RedundantSelf < Cop
+      class RedundantSelf < Base
+        extend AutoCorrector
+
         MSG = 'Redundant `self` detected.'
         KERNEL_METHODS = Kernel.methods(false)
+        KEYWORDS = %i[alias and begin break case class def defined? do
+                      else elsif end ensure false for if in module
+                      next nil not or redo rescue retry return self
+                      super then true undef unless until when while
+                      yield __FILE__ __LINE__ __ENCODING__].freeze
 
         def self.autocorrect_incompatible_with
           [ColonMethodCall]
@@ -52,7 +59,7 @@ module RuboCop
         def initialize(config = nil, options = nil)
           super
           @allowed_send_nodes = []
-          @local_variables_scopes = Hash.new { |hash, key| hash[key] = [] }
+          @local_variables_scopes = Hash.new { |hash, key| hash[key] = [] }.compare_by_identity
         end
 
         # Assignment of self.x
@@ -85,9 +92,7 @@ module RuboCop
 
         def on_masgn(node)
           lhs, rhs = *node
-          lhs.children.each do |child|
-            add_lhs_to_local_variables_scopes(rhs, child.to_a.first)
-          end
+          add_masgn_lhs_variables(rhs, lhs)
         end
 
         def on_lvasgn(node)
@@ -101,24 +106,36 @@ module RuboCop
 
           return if allowed_send_node?(node)
 
-          add_offense(node)
+          add_offense(node.receiver) do |corrector|
+            corrector.remove(node.receiver)
+            corrector.remove(node.loc.dot)
+          end
         end
 
         def on_block(node)
           add_scope(node, @local_variables_scopes[node])
         end
 
-        def autocorrect(node)
-          lambda do |corrector|
-            corrector.remove(node.receiver)
-            corrector.remove(node.loc.dot)
+        def on_if(node)
+          # Allow conditional nodes to use `self` in the condition if that variable
+          # name is used in an `lvasgn` or `masgn` within the `if`.
+          node.child_nodes.each do |child_node|
+            lhs, _rhs = *child_node
+
+            if child_node.lvasgn_type?
+              add_lhs_to_local_variables_scopes(node.condition, lhs)
+            elsif child_node.masgn_type?
+              add_masgn_lhs_variables(node.condition, lhs)
+            end
           end
         end
+        alias on_while on_if
+        alias on_until on_if
 
         private
 
         def add_scope(node, local_variables = [])
-          node.descendants.each do |child_node|
+          node.each_descendant do |child_node|
             @local_variables_scopes[child_node] = local_variables
           end
         end
@@ -126,28 +143,27 @@ module RuboCop
         def allowed_send_node?(node)
           @allowed_send_nodes.include?(node) ||
             @local_variables_scopes[node].include?(node.method_name) ||
+            node.each_ancestor.any? do |ancestor|
+              @local_variables_scopes[ancestor].include?(node.method_name)
+            end ||
             KERNEL_METHODS.include?(node.method_name)
         end
 
         def regular_method_call?(node)
           !(node.operator_method? ||
-            keyword?(node.method_name) ||
+            KEYWORDS.include?(node.method_name) ||
             node.camel_case_method? ||
             node.setter_method? ||
             node.implicit_call?)
         end
 
         def on_argument(node)
-          name, = *node
-          @local_variables_scopes[node] << name
-        end
-
-        def keyword?(method_name)
-          %i[alias and begin break case class def defined? do
-             else elsif end ensure false for if in module
-             next nil not or redo rescue retry return self
-             super then true undef unless until when while
-             yield __FILE__ __LINE__ __ENCODING__].include?(method_name)
+          if node.mlhs_type?
+            on_args(node)
+          else
+            name, = *node
+            @local_variables_scopes[node] << name
+          end
         end
 
         def allow_self(node)
@@ -158,13 +174,17 @@ module RuboCop
 
         def add_lhs_to_local_variables_scopes(rhs, lhs)
           if rhs&.send_type? && !rhs.arguments.empty?
-            rhs.arguments.each do |argument|
-              @local_variables_scopes[argument] << lhs
-            end
+            rhs.arguments.each { |argument| @local_variables_scopes[argument] << lhs }
           else
             @local_variables_scopes[rhs] << lhs
           end
         end
+
+        def add_masgn_lhs_variables(rhs, lhs)
+          lhs.children.each do |child|
+            add_lhs_to_local_variables_scopes(rhs, child.to_a.first)
+          end
+        end
       end
     end
   end

data/lib/rubocop/cop/style/redundant_self_assignment.rb

@@ -0,0 +1,118 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop checks for places where redundant assignments are made for in place
+      # modification methods.
+      #
+      # This cop is marked as unsafe, because it can produce false positives for
+      # user defined methods having one of the expected names, but not modifying
+      # its receiver in place.
+      #
+      # @example
+      #   # bad
+      #   args = args.concat(ary)
+      #   hash = hash.merge!(other)
+      #
+      #   # good
+      #   args.concat(foo)
+      #   args += foo
+      #   hash.merge!(other)
+      #
+      #   # bad
+      #   self.foo = foo.concat(ary)
+      #
+      #   # good
+      #   foo.concat(ary)
+      #   self.foo += ary
+      #
+      class RedundantSelfAssignment < Base
+        include RangeHelp
+        extend AutoCorrector
+
+        MSG = 'Redundant self assignment detected. '\
+              'Method `%<method_name>s` modifies its receiver in place.'
+
+        METHODS_RETURNING_SELF = %i[
+          append clear collect! compare_by_identity concat delete_if
+          fill initialize_copy insert keep_if map! merge! prepend push
+          rehash replace reverse! rotate! shuffle! sort! sort_by!
+          transform_keys! transform_values! unshift update
+        ].to_set.freeze
+
+        ASSIGNMENT_TYPE_TO_RECEIVER_TYPE = {
+          lvasgn: :lvar,
+          ivasgn: :ivar,
+          cvasgn: :cvar,
+          gvasgn: :gvar
+        }.freeze
+
+        def on_lvasgn(node)
+          lhs, rhs = *node
+          receiver, method_name, = *rhs
+          return unless receiver && method_returning_self?(method_name)
+
+          receiver_type = ASSIGNMENT_TYPE_TO_RECEIVER_TYPE[node.type]
+          return unless receiver.type == receiver_type && receiver.children.first == lhs
+
+          message = format(MSG, method_name: method_name)
+          add_offense(node.loc.operator, message: message) do |corrector|
+            corrector.replace(node, rhs.source)
+          end
+        end
+        alias on_ivasgn on_lvasgn
+        alias on_cvasgn on_lvasgn
+        alias on_gvasgn on_lvasgn
+
+        def on_send(node)
+          # TODO: Remove `Symbol#to_s` after supporting only Ruby >= 2.7.
+          return unless node.method_name.to_s.end_with?('=')
+          return unless redundant_assignment?(node)
+
+          message = format(MSG, method_name: node.first_argument.method_name)
+          add_offense(node.loc.operator, message: message) do |corrector|
+            corrector.remove(correction_range(node))
+          end
+        end
+
+        private
+
+        def method_returning_self?(method_name)
+          METHODS_RETURNING_SELF.include?(method_name)
+        end
+
+        # @!method redundant_self_assignment?(node, method_name)
+        def_node_matcher :redundant_self_assignment?, <<~PATTERN
+          (send
+            (self) _
+            (send
+              (send
+                {(self) nil?} %1) #method_returning_self?
+              ...))
+        PATTERN
+
+        # @!method redundant_nonself_assignment?(node, receiver, method_name)
+        def_node_matcher :redundant_nonself_assignment?, <<~PATTERN
+          (send
+            %1 _
+            (send
+              (send
+                %1 %2) #method_returning_self?
+              ...))
+        PATTERN
+
+        def redundant_assignment?(node)
+          receiver_name = node.method_name.to_s[0...-1].to_sym
+
+          redundant_self_assignment?(node, receiver_name) ||
+            redundant_nonself_assignment?(node, node.receiver, receiver_name)
+        end
+
+        def correction_range(node)
+          range_between(node.source_range.begin_pos, node.first_argument.source_range.begin_pos)
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/style/redundant_sort.rb

@@ -49,12 +49,15 @@ module RuboCop
       #   # good
       #   arr.max_by(&:foo)
       #
-      class RedundantSort < Cop
+      class RedundantSort < Base
         include RangeHelp
+        extend AutoCorrector
 
-        MSG = 'Use `%<suggestion>s` instead of '\
-              '`%<sorter>s...%<accessor_source>s`.'
+        MSG = 'Use `%<suggestion>s` instead of `%<sorter>s...%<accessor_source>s`.'
 
+        RESTRICT_ON_SEND = %i[sort sort_by].freeze
+
+        # @!method redundant_sort?(node)
         def_node_matcher :redundant_sort?, <<~MATCHER
           {
             (send $(send _ $:sort ...) ${:last :first})
@@ -72,41 +75,34 @@ module RuboCop
         MATCHER
 
         def on_send(node)
-          redundant_sort?(node) do |sort_node, sorter, accessor|
-            range = range_between(
-              sort_node.loc.selector.begin_pos,
-              node.loc.expression.end_pos
-            )
+          if (sort_node, sorter, accessor = redundant_sort?(node.parent))
+            ancestor = node.parent
+          elsif (sort_node, sorter, accessor = redundant_sort?(node.parent&.parent))
+            ancestor = node.parent.parent
+          else
+            return
+          end
+
+          message = message(ancestor, sorter, accessor)
 
-            add_offense(node,
-                        location: range,
-                        message: message(node,
-                                         sorter,
-                                         accessor))
+          add_offense(offense_range(sort_node, ancestor), message: message) do |corrector|
+            autocorrect(corrector, ancestor, sort_node, sorter, accessor)
           end
         end
 
-        def autocorrect(node)
-          sort_node, sorter, accessor = redundant_sort?(node)
+        private
 
-          lambda do |corrector|
-            # Remove accessor, e.g. `first` or `[-1]`.
-            corrector.remove(
-              range_between(
-                accessor_start(node),
-                node.loc.expression.end_pos
-              )
-            )
+        def autocorrect(corrector, node, sort_node, sorter, accessor)
+          # Remove accessor, e.g. `first` or `[-1]`.
+          corrector.remove(range_between(accessor_start(node), node.loc.expression.end_pos))
 
-            # Replace "sort" or "sort_by" with the appropriate min/max method.
-            corrector.replace(
-              sort_node.loc.selector,
-              suggestion(sorter, accessor, arg_value(node))
-            )
-          end
+          # Replace "sort" or "sort_by" with the appropriate min/max method.
+          corrector.replace(sort_node.loc.selector, suggestion(sorter, accessor, arg_value(node)))
         end
 
-        private
+        def offense_range(sort_node, ancestor)
+          range_between(sort_node.loc.selector.begin_pos, ancestor.loc.expression.end_pos)
+        end
 
         def message(node, sorter, accessor)
           accessor_source = range_between(
@@ -115,9 +111,7 @@ module RuboCop
           ).source
 
           format(MSG,
-                 suggestion: suggestion(sorter,
-                                        accessor,
-                                        arg_value(node)),
+                 suggestion: suggestion(sorter, accessor, arg_value(node)),
                  sorter: sorter,
                  accessor_source: accessor_source)
         end
@@ -135,9 +129,10 @@ module RuboCop
         end
 
         def suffix(sorter)
-          if sorter == :sort
+          case sorter
+          when :sort
             ''
-          elsif sorter == :sort_by
+          when :sort_by
             '_by'
           end
         end