rubocop 1.50.2 → 1.57.1

data/lib/rubocop/cop/lint/redundant_safe_navigation.rb

@@ -4,8 +4,12 @@ module RuboCop
   module Cop
     module Lint
       # Checks for redundant safe navigation calls.
-      # `instance_of?`, `kind_of?`, `is_a?`, `eql?`, `respond_to?`, and `equal?` methods
-      # are checked by default. These are customizable with `AllowedMethods` option.
+      # Use cases where a constant, named in camel case for classes and modules is `nil` are rare,
+      # and an offense is not detected when the receiver is a snake case constant.
+      #
+      # For all receivers, the `instance_of?`, `kind_of?`, `is_a?`, `eql?`, `respond_to?`,
+      # and `equal?` methods are checked by default.
+      # These are customizable with `AllowedMethods` option.
       #
       # The `AllowedMethods` option specifies nil-safe methods,
       # in other words, it is a method that is allowed to skip safe navigation.
@@ -22,6 +26,9 @@ module RuboCop
       #
       # @example
       #   # bad
+      #   CamelCaseConst&.do_something
+      #
+      #   # bad
       #   do_something if attrs&.respond_to?(:[])
       #
       #   # good
@@ -33,6 +40,9 @@ module RuboCop
       #   end
       #
       #   # good
+      #   CamelCaseConst.do_something
+      #
+      #   # good
       #   while node.is_a?(BeginNode)
       #     node = node.parent
       #   end
@@ -57,18 +67,24 @@ module RuboCop
 
         NIL_SPECIFIC_METHODS = (nil.methods - Object.new.methods).to_set.freeze
 
+        SNAKE_CASE = /\A[[:digit:][:upper:]_]+\z/.freeze
+
         # @!method respond_to_nil_specific_method?(node)
         def_node_matcher :respond_to_nil_specific_method?, <<~PATTERN
           (csend _ :respond_to? (sym %NIL_SPECIFIC_METHODS))
         PATTERN
 
+        # rubocop:disable Metrics/AbcSize
         def on_csend(node)
-          return unless check?(node) && allowed_method?(node.method_name)
-          return if respond_to_nil_specific_method?(node)
+          unless node.receiver.const_type? && !node.receiver.source.match?(SNAKE_CASE)
+            return unless check?(node) && allowed_method?(node.method_name)
+            return if respond_to_nil_specific_method?(node)
+          end
 
           range = range_between(node.loc.dot.begin_pos, node.source_range.end_pos)
           add_offense(range) { |corrector| corrector.replace(node.loc.dot, '.') }
         end
+        # rubocop:enable Metrics/AbcSize
 
         private
 

data/lib/rubocop/cop/lint/redundant_string_coercion.rb

@@ -47,7 +47,7 @@ module RuboCop
           return if node.receiver
 
           node.each_child_node(:send) do |child|
-            next unless child.method?(:to_s)
+            next if !child.method?(:to_s) || child.arguments.any?
 
             register_offense(child, "`#{node.method_name}`")
           end

data/lib/rubocop/cop/lint/safe_navigation_chain.rb

@@ -82,16 +82,23 @@ module RuboCop
         def autocorrect(corrector, offense_range:, send_node:)
           corrector.replace(
             offense_range,
-            add_safe_navigation_operator(
-              offense_range: offense_range,
-              send_node: send_node
-            )
+            add_safe_navigation_operator(offense_range: offense_range, send_node: send_node)
           )
+
+          corrector.wrap(send_node, '(', ')') if require_parentheses?(send_node)
         end
 
         def brackets?(send_node)
           send_node.method?(:[]) || send_node.method?(:[]=)
         end
+
+        def require_parentheses?(send_node)
+          return false unless send_node.comparison_method?
+          return false unless (node = send_node.parent)
+
+          (node.respond_to?(:logical_operator?) && node.logical_operator?) ||
+            (node.respond_to?(:comparison_method?) && node.comparison_method?)
+        end
       end
     end
   end

data/lib/rubocop/cop/lint/send_with_mixin_argument.rb

@@ -3,8 +3,7 @@
 module RuboCop
   module Cop
     module Lint
-      #
-      # This cop checks for `send`, `public_send`, and `__send__` methods
+      # Checks for `send`, `public_send`, and `__send__` methods
       # when using mix-in.
       #
       # `include` and `prepend` methods were private methods until Ruby 2.0,

data/lib/rubocop/cop/lint/shadowed_exception.rb

@@ -121,18 +121,12 @@ module RuboCop
 
           if rescued_exceptions.any?
             rescued_exceptions.each_with_object([]) do |exception, converted|
-              # FIXME: Workaround `rubocop:disable` comment for JRuby.
-              #        https://github.com/jruby/jruby/issues/6642
-              # rubocop:disable Style/RedundantBegin
-              begin
-                RuboCop::Util.silence_warnings do
-                  # Avoid printing deprecation warnings about constants
-                  converted << Kernel.const_get(exception.source)
-                end
-              rescue NameError
-                converted << nil
+              RuboCop::Util.silence_warnings do
+                # Avoid printing deprecation warnings about constants
+                converted << Kernel.const_get(exception.source)
               end
-              # rubocop:enable Style/RedundantBegin
+            rescue NameError
+              converted << nil
             end
           else
             # treat an empty `rescue` as `rescue StandardError`

data/lib/rubocop/cop/lint/shadowing_outer_local_variable.rb

@@ -68,7 +68,7 @@ module RuboCop
 
         def same_conditions_node_different_branch?(variable, outer_local_variable)
           variable_node = variable_node(variable)
-          return false unless variable_node.conditional?
+          return false unless node_or_its_ascendant_conditional?(variable_node)
 
           outer_local_variable_node =
             find_conditional_node_from_ascendant(outer_local_variable.declaration_node)
@@ -96,6 +96,12 @@ module RuboCop
 
           find_conditional_node_from_ascendant(parent)
         end
+
+        def node_or_its_ascendant_conditional?(node)
+          return true if node.conditional?
+
+          !!find_conditional_node_from_ascendant(node)
+        end
       end
     end
   end

data/lib/rubocop/cop/lint/struct_new_override.rb

@@ -32,25 +32,25 @@ module RuboCop
         # @!method struct_new(node)
         def_node_matcher :struct_new, <<~PATTERN
           (send
-            (const ${nil? cbase} :Struct) :new ...)
+            (const {nil? cbase} :Struct) :new ...)
         PATTERN
 
         def on_send(node)
-          return unless struct_new(node) do
-            node.arguments.each_with_index do |arg, index|
-              # Ignore if the first argument is a class name
-              next if index.zero? && arg.str_type?
+          return unless struct_new(node)
 
-              # Ignore if the argument is not a member name
-              next unless STRUCT_MEMBER_NAME_TYPES.include?(arg.type)
+          node.arguments.each_with_index do |arg, index|
+            # Ignore if the first argument is a class name
+            next if index.zero? && arg.str_type?
 
-              member_name = arg.value
+            # Ignore if the argument is not a member name
+            next unless STRUCT_MEMBER_NAME_TYPES.include?(arg.type)
 
-              next unless STRUCT_METHOD_NAMES.include?(member_name.to_sym)
+            member_name = arg.value
 
-              message = format(MSG, member_name: member_name.inspect, method_name: member_name.to_s)
-              add_offense(arg, message: message)
-            end
+            next unless STRUCT_METHOD_NAMES.include?(member_name.to_sym)
+
+            message = format(MSG, member_name: member_name.inspect, method_name: member_name.to_s)
+            add_offense(arg, message: message)
           end
         end
       end

data/lib/rubocop/cop/lint/suppressed_exception.rb

@@ -117,9 +117,9 @@ module RuboCop
 
         def comment_between_rescue_and_end?(node)
           ancestor = node.each_ancestor(:kwbegin, :def, :defs, :block, :numblock).first
-          return unless ancestor
+          return false unless ancestor
 
-          end_line = ancestor.loc.end.line
+          end_line = ancestor.loc.end&.line || ancestor.loc.last_line
           processed_source[node.first_line...end_line].any? { |line| comment_line?(line) }
         end
 

data/lib/rubocop/cop/lint/symbol_conversion.rb

@@ -124,7 +124,7 @@ module RuboCop
           source == value ||
             # `Symbol#inspect` uses double quotes, but allow single-quoted
             # symbols to work as well.
-            source.tr("'", '"') == value
+            source.gsub('"', '\"').tr("'", '"') == value
         end
 
         def requires_quotes?(sym_node)

data/lib/rubocop/cop/lint/to_enum_arguments.rb

@@ -74,7 +74,7 @@ module RuboCop
           end
         end
 
-        # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity
+        # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength
         def argument_match?(send_arg, def_arg)
           def_arg_name = def_arg.children[0]
 
@@ -87,12 +87,14 @@ module RuboCop
             send_arg.hash_type? &&
               send_arg.pairs.any? { |pair| passing_keyword_arg?(pair, def_arg_name) }
           when :kwrestarg
-            send_arg.each_child_node(:kwsplat).any? { |child| child.source == def_arg.source }
+            send_arg.each_child_node(:kwsplat, :forwarded_kwrestarg).any? do |child|
+              child.source == def_arg.source
+            end
           when :forward_arg
             send_arg.forwarded_args_type?
           end
         end
-        # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity
+        # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength
       end
     end
   end

data/lib/rubocop/cop/lint/top_level_return_with_argument.rb

@@ -8,25 +8,39 @@ module RuboCop
       # always ignored. This is detected automatically since Ruby 2.7.
       #
       # @example
+      #   # bad
+      #   return 1
       #
-      #   # Detected since Ruby 2.7
-      #   return 1 # 1 is always ignored.
+      #   # good
+      #   return
       class TopLevelReturnWithArgument < Base
-        # This cop works by validating the ancestors of the return node. A
-        # top-level return node's ancestors should not be of block, def, or
-        # defs type.
+        extend AutoCorrector
 
         MSG = 'Top level return with argument detected.'
 
         def on_return(return_node)
-          add_offense(return_node) if return_node.arguments? && ancestors_valid?(return_node)
+          return unless top_level_return_with_any_argument?(return_node)
+
+          add_offense(return_node) do |corrector|
+            remove_arguments(corrector, return_node)
+          end
         end
 
         private
 
-        def ancestors_valid?(return_node)
-          prohibited_ancestors = return_node.each_ancestor(:block, :def, :defs)
-          prohibited_ancestors.none?
+        def top_level_return_with_any_argument?(return_node)
+          top_level_return?(return_node) && return_node.arguments?
+        end
+
+        def remove_arguments(corrector, return_node)
+          corrector.replace(return_node, 'return')
+        end
+
+        # This cop works by validating the ancestors of the return node. A
+        # top-level return node's ancestors should not be of block, def, or
+        # defs type.
+        def top_level_return?(return_node)
+          return_node.each_ancestor(:block, :def, :defs).none?
         end
       end
     end

data/lib/rubocop/cop/lint/useless_assignment.rb

@@ -7,12 +7,24 @@ module RuboCop
       # scope.
       # The basic idea for this cop was from the warning of `ruby -cw`:
       #
-      #   assigned but unused variable - foo
+      # [source,console]
+      # ----
+      # assigned but unused variable - foo
+      # ----
       #
       # Currently this cop has advanced logic that detects unreferenced
       # reassignments and properly handles varied cases such as branch, loop,
       # rescue, ensure, etc.
       #
+      # NOTE: Given the assignment `foo = 1, bar = 2`, removing unused variables
+      # can lead to a syntax error, so this case is not autocorrected.
+      #
+      # @safety
+      #   This cop's autocorrection is unsafe because removing assignment from
+      #   operator assignment can cause NameError if this assignment has been used to declare
+      #   local variable. For example, replacing `a ||= 1` to `a || 1` may cause
+      #   "undefined local variable or method `a' for main:Object (NameError)".
+      #
       # @example
       #
       #   # bad
@@ -31,6 +43,10 @@ module RuboCop
       #     do_something(some_var)
       #   end
       class UselessAssignment < Base
+        extend AutoCorrector
+
+        include RangeHelp
+
         MSG = 'Useless assignment to variable - `%<variable>s`.'
 
         def self.joining_forces
@@ -41,23 +57,24 @@ module RuboCop
           scope.variables.each_value { |variable| check_for_unused_assignments(variable) }
         end
 
+        # rubocop:disable Metrics/AbcSize
         def check_for_unused_assignments(variable)
           return if variable.should_be_unused?
 
           variable.assignments.each do |assignment|
-            next if assignment.used?
+            next if assignment.used? || part_of_ignored_node?(assignment.node)
 
             message = message_for_useless_assignment(assignment)
+            range = offense_range(assignment)
 
-            location = if assignment.regexp_named_capture?
-                         assignment.node.children.first.source_range
-                       else
-                         assignment.node.loc.name
-                       end
+            add_offense(range, message: message) do |corrector|
+              autocorrect(corrector, assignment) unless sequential_assignment?(assignment.node)
+            end
 
-            add_offense(location, message: message)
+            ignore_node(assignment.node) if chained_assignment?(assignment.node)
           end
         end
+        # rubocop:enable Metrics/AbcSize
 
         def message_for_useless_assignment(assignment)
           variable = assignment.variable
@@ -65,6 +82,28 @@ module RuboCop
           format(MSG, variable: variable.name) + message_specification(assignment, variable).to_s
         end
 
+        def offense_range(assignment)
+          if assignment.regexp_named_capture?
+            assignment.node.children.first.source_range
+          else
+            assignment.node.loc.name
+          end
+        end
+
+        def sequential_assignment?(node)
+          if node.lvasgn_type? && node.expression&.array_type? &&
+             node.each_descendant.any?(&:assignment?)
+            return true
+          end
+          return false unless node.parent
+
+          sequential_assignment?(node.parent)
+        end
+
+        def chained_assignment?(node)
+          node.respond_to?(:expression) && node.expression&.lvasgn_type?
+        end
+
         def message_specification(assignment, variable)
           if assignment.multiple_assignment?
             multiple_assignment_message(variable.name)
@@ -84,8 +123,7 @@ module RuboCop
           return_value_node = return_value_node_of_scope(scope)
           return unless assignment.meta_assignment_node.equal?(return_value_node)
 
-          " Use `#{assignment.operator.sub(/=$/, '')}` " \
-            "instead of `#{assignment.operator}`."
+          " Use `#{assignment.operator.delete_suffix('=')}` instead of `#{assignment.operator}`."
         end
 
         def similar_name_message(variable)
@@ -119,6 +157,52 @@ module RuboCop
 
           node.receiver.nil? && !node.arguments?
         end
+
+        # rubocop:disable Metrics/AbcSize
+        def autocorrect(corrector, assignment)
+          if assignment.exception_assignment?
+            remove_exception_assignment_part(corrector, assignment.node)
+          elsif assignment.multiple_assignment? || assignment.rest_assignment? ||
+                assignment.for_assignment?
+            rename_variable_with_underscore(corrector, assignment.node)
+          elsif assignment.operator_assignment?
+            remove_trailing_character_from_operator(corrector, assignment.node)
+          elsif assignment.regexp_named_capture?
+            replace_named_capture_group_with_non_capturing_group(corrector, assignment.node,
+                                                                 assignment.variable.name)
+          else
+            remove_local_variable_assignment_part(corrector, assignment.node)
+          end
+        end
+        # rubocop:enable Metrics/AbcSize
+
+        def remove_exception_assignment_part(corrector, node)
+          corrector.remove(
+            range_between(
+              (node.parent.children.first&.source_range || node.parent.location.keyword).end_pos,
+              node.source_range.end_pos
+            )
+          )
+        end
+
+        def rename_variable_with_underscore(corrector, node)
+          corrector.replace(node, '_')
+        end
+
+        def remove_trailing_character_from_operator(corrector, node)
+          corrector.remove(node.parent.location.operator.end.adjust(begin_pos: -1))
+        end
+
+        def replace_named_capture_group_with_non_capturing_group(corrector, node, variable_name)
+          corrector.replace(
+            node.children.first,
+            node.children.first.source.sub(/\(\?<#{variable_name}>/, '(?:')
+          )
+        end
+
+        def remove_local_variable_assignment_part(corrector, node)
+          corrector.replace(node, node.expression.source)
+        end
       end
     end
   end

data/lib/rubocop/cop/lint/void.rb

@@ -41,6 +41,10 @@ module RuboCop
       #     do_something(some_array)
       #   end
       class Void < Base
+        extend AutoCorrector
+
+        include RangeHelp
+
         OP_MSG = 'Operator `%<op>s` used in void context.'
         VAR_MSG = 'Variable `%<var>s` used in void context.'
         LIT_MSG = 'Literal `%<lit>s` used in void context.'
@@ -100,35 +104,53 @@ module RuboCop
         def check_void_op(node)
           return unless node.send_type? && OPERATORS.include?(node.method_name)
 
-          add_offense(node.loc.selector, message: format(OP_MSG, op: node.method_name))
+          add_offense(node.loc.selector,
+                      message: format(OP_MSG, op: node.method_name)) do |corrector|
+            autocorrect_void_op(corrector, node)
+          end
         end
 
         def check_var(node)
           return unless node.variable? || node.const_type?
 
-          add_offense(node.loc.name, message: format(VAR_MSG, var: node.loc.name.source))
+          if node.const_type? && node.special_keyword?
+            add_offense(node, message: format(VAR_MSG, var: node.source)) do |corrector|
+              autocorrect_void_expression(corrector, node)
+            end
+          else
+            add_offense(node.loc.name,
+                        message: format(VAR_MSG, var: node.loc.name.source)) do |corrector|
+              autocorrect_void_expression(corrector, node)
+            end
+          end
         end
 
         def check_literal(node)
           return if !node.literal? || node.xstr_type? || node.range_type?
 
-          add_offense(node, message: format(LIT_MSG, lit: node.source))
+          add_offense(node, message: format(LIT_MSG, lit: node.source)) do |corrector|
+            autocorrect_void_expression(corrector, node)
+          end
         end
 
         def check_self(node)
           return unless node.self_type?
 
-          add_offense(node, message: SELF_MSG)
+          add_offense(node, message: SELF_MSG) do |corrector|
+            autocorrect_void_expression(corrector, node)
+          end
         end
 
         def check_void_expression(node)
           return unless node.defined_type? || node.lambda_or_proc?
 
-          add_offense(node, message: format(EXPRESSION_MSG, expression: node.source))
+          add_offense(node, message: format(EXPRESSION_MSG, expression: node.source)) do |corrector|
+            autocorrect_void_expression(corrector, node)
+          end
         end
 
         def check_nonmutating(node)
-          return unless node.respond_to?(:method_name)
+          return if !node.send_type? && !node.block_type? && !node.numblock_type?
 
           method_name = node.method_name
           return unless NONMUTATING_METHODS.include?(method_name)
@@ -139,7 +161,10 @@ module RuboCop
                          "#{method_name}!"
                        end
           add_offense(node,
-                      message: format(NONMUTATING_MSG, method: method_name, suggest: suggestion))
+                      message: format(NONMUTATING_MSG, method: method_name,
+                                                       suggest: suggestion)) do |corrector|
+            autocorrect_nonmutating_send(corrector, node, suggestion)
+          end
         end
 
         def in_void_context?(node)
@@ -149,6 +174,31 @@ module RuboCop
 
           VOID_CONTEXT_TYPES.include?(parent.type) && parent.void_context?
         end
+
+        def autocorrect_void_op(corrector, node)
+          if node.arguments.empty?
+            corrector.replace(node, node.receiver.source)
+          else
+            corrector.replace(
+              range_with_surrounding_space(range: node.loc.selector, side: :both,
+                                           newlines: false),
+              "\n"
+            )
+          end
+        end
+
+        def autocorrect_void_expression(corrector, node)
+          corrector.remove(range_with_surrounding_space(range: node.source_range, side: :left))
+        end
+
+        def autocorrect_nonmutating_send(corrector, node, suggestion)
+          send_node = if node.send_type?
+                        node
+                      else
+                        node.send_node
+                      end
+          corrector.replace(send_node.loc.selector, suggestion)
+        end
       end
     end
   end

data/lib/rubocop/cop/metrics/block_length.rb

@@ -12,6 +12,7 @@ module RuboCop
       # Available are: 'array', 'hash', 'heredoc', and 'method_call'. Each construct
       # will be counted as one line regardless of its actual size.
       #
+      # NOTE: This cop does not apply for `Struct` definitions.
       #
       # NOTE: The `ExcludedMethods` configuration is deprecated and only kept
       # for backwards compatibility. Please use `AllowedMethods` and `AllowedPatterns`
@@ -40,7 +41,6 @@ module RuboCop
       #     )
       #   end                 # 6 points
       #
-      # NOTE: This cop does not apply for `Struct` definitions.
       class BlockLength < Base
         include CodeLength
         include AllowedMethods

data/lib/rubocop/cop/metrics/class_length.rb

@@ -11,6 +11,8 @@ module RuboCop
       # Available are: 'array', 'hash', 'heredoc', and 'method_call'. Each construct
       # will be counted as one line regardless of its actual size.
       #
+      # NOTE: This cop also applies for `Struct` definitions.
+      #
       # @example CountAsOne: ['array', 'heredoc', 'method_call']
       #
       #   class Foo
@@ -34,8 +36,6 @@ module RuboCop
       #     )
       #   end                 # 6 points
       #
-      #
-      # NOTE: This cop also applies for `Struct` definitions.
       class ClassLength < Base
         include CodeLength
 

data/lib/rubocop/cop/metrics/method_length.rb

@@ -54,7 +54,7 @@ module RuboCop
         alias on_defs on_def
 
         def on_block(node)
-          return unless node.send_node.method?(:define_method)
+          return unless node.method?(:define_method)
 
           check_code_length(node)
         end

data/lib/rubocop/cop/metrics/utils/abc_size_calculator.rb

@@ -117,8 +117,7 @@ module RuboCop
           end
 
           def capturing_variable?(name)
-            # TODO: Remove `Symbol#to_s` after supporting only Ruby >= 2.7.
-            name && !name.to_s.start_with?('_')
+            name && !name.start_with?('_')
           end
 
           def branch?(node)