rubocop 1.34.1 → 1.54.0

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/unreachable_loop.rb

@@ -9,7 +9,7 @@ module RuboCop
       # In rare cases where only one iteration (or at most one iteration) is intended behavior,
       # the code should be refactored to use `if` conditionals.
       #
-      # NOTE: Block methods that are used with `Enumerable`s are considered to be loops.
+      # NOTE: Block methods that are used with ``Enumerable``s are considered to be loops.
       #
       # `AllowedPatterns` can be used to match against the block receiver in order to allow
       # code that would otherwise be registered as an offense (eg. `times` used not in an
@@ -79,7 +79,7 @@ module RuboCop
       #   # bad
       #   2.times { raise ArgumentError }
       #
-      # @example AllowedPatterns: [/(exactly|at_least|at_most)\(\d+\)\.times/] (default)
+      # @example AllowedPatterns: ['(exactly|at_least|at_most)\(\d+\)\.times'] (default)
       #
       #   # good
       #   exactly(2).times { raise StandardError }
@@ -101,15 +101,19 @@ module RuboCop
           check(node) if loop_method?(node)
         end
 
+        def on_numblock(node)
+          check(node) if loop_method?(node)
+        end
+
         private
 
         def loop_method?(node)
-          return false unless node.block_type?
+          return false unless node.block_type? || node.numblock_type?
 
           send_node = node.send_node
-          return false if matches_allowed_pattern?(send_node.source)
-
-          send_node.enumerable_method? || send_node.enumerator_method? || send_node.method?(:loop)
+          loopable = send_node.enumerable_method? || send_node.enumerator_method? ||
+                     send_node.method?(:loop)
+          loopable && !matches_allowed_pattern?(send_node.source)
         end
 
         def check(node)
@@ -179,6 +183,8 @@ module RuboCop
 
         def preceded_by_continue_statement?(break_statement)
           break_statement.left_siblings.any? do |sibling|
+            # Numblocks have the arguments count as a number in the AST.
+            next if sibling.is_a?(Integer)
             next if sibling.loop_keyword? || loop_method?(sibling)
 
             sibling.each_descendant(*CONTINUE_KEYWORDS).any?

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

@@ -68,6 +68,10 @@ module RuboCop
            (send nil? :fail ...)}
         PATTERN
 
+        def self.autocorrect_incompatible_with
+          [Style::ExplicitBlockArgument]
+        end
+
         def self.joining_forces
           VariableForce
         end
@@ -96,7 +100,8 @@ module RuboCop
 
           unless variable.keyword_argument?
             message << " If it's necessary, use `_` or `_#{variable.name}` " \
-                       "as an argument name to indicate that it won't be used."
+                       "as an argument name to indicate that it won't be used. " \
+                       "If it's unnecessary, remove it."
           end
 
           scope = variable.scope

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

@@ -31,8 +31,8 @@ module RuboCop
       #   # bad
       #   class Foo
       #     # The following is redundant (methods defined on the class'
-      #     # singleton class are not affected by the public modifier)
-      #     public
+      #     # singleton class are not affected by the private modifier)
+      #     private
       #
       #     def self.method3
       #     end
@@ -137,11 +137,13 @@ module RuboCop
         alias on_sclass on_class
 
         def on_block(node)
-          return unless eval_call?(node)
+          return unless eval_call?(node) || included_block?(node)
 
           check_node(node.body)
         end
 
+        alias on_numblock on_block
+
         private
 
         def autocorrect(corrector, node)
@@ -157,17 +159,12 @@ module RuboCop
 
         # @!method dynamic_method_definition?(node)
         def_node_matcher :dynamic_method_definition?, <<~PATTERN
-          {(send nil? :define_method ...) (block (send nil? :define_method ...) ...)}
+          {(send nil? :define_method ...) ({block numblock} (send nil? :define_method ...) ...)}
         PATTERN
 
         # @!method class_or_instance_eval?(node)
         def_node_matcher :class_or_instance_eval?, <<~PATTERN
-          (block (send _ {:class_eval :instance_eval}) ...)
-        PATTERN
-
-        # @!method class_or_module_or_struct_new_call?(node)
-        def_node_matcher :class_or_module_or_struct_new_call?, <<~PATTERN
-          (block (send (const {nil? cbase} {:Class :Module :Struct}) :new ...) ...)
+          ({block numblock} (send _ {:class_eval :instance_eval}) ...)
         PATTERN
 
         def check_node(node)
@@ -195,10 +192,13 @@ module RuboCop
           end
         end
 
+        # rubocop:disable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
         def check_child_nodes(node, unused, cur_vis)
           node.child_nodes.each do |child|
             if child.send_type? && access_modifier?(child)
               cur_vis, unused = check_send_node(child, cur_vis, unused)
+            elsif child.block_type? && included_block?(child)
+              next
             elsif method_definition?(child)
               unused = nil
             elsif start_of_new_scope?(child)
@@ -210,6 +210,7 @@ module RuboCop
 
           [cur_vis, unused]
         end
+        # rubocop:enable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
 
         def check_send_node(node, cur_vis, unused)
           if node.bare_access_modifier?
@@ -243,6 +244,10 @@ module RuboCop
           [new_vis, unused]
         end
 
+        def included_block?(block_node)
+          active_support_extensions_enabled? && block_node.method?(:included)
+        end
+
         def method_definition?(child)
           static_method_definition?(child) ||
             dynamic_method_definition?(child) ||
@@ -268,7 +273,7 @@ module RuboCop
 
         def eval_call?(child)
           class_or_instance_eval?(child) ||
-            class_or_module_or_struct_new_call?(child) ||
+            child.class_constructor? ||
             any_context_creating_methods?(child)
         end
 
@@ -277,7 +282,7 @@ module RuboCop
             matcher_name = "#{m}_block?".to_sym
             unless respond_to?(matcher_name)
               self.class.def_node_matcher matcher_name, <<~PATTERN
-                (block (send {nil? const} {:#{m}} ...) ...)
+                ({block numblock} (send {nil? const} {:#{m}} ...) ...)
               PATTERN
             end
 

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

@@ -13,6 +13,12 @@ module RuboCop
       # reassignments and properly handles varied cases such as branch, loop,
       # rescue, ensure, etc.
       #
+      # @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 +37,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
@@ -55,7 +65,9 @@ module RuboCop
                          assignment.node.loc.name
                        end
 
-            add_offense(location, message: message)
+            add_offense(location, message: message) do |corrector|
+              autocorrect(corrector, assignment)
+            end
           end
         end
 
@@ -119,6 +131,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/useless_method_definition.rb

@@ -41,17 +41,25 @@ module RuboCop
         MSG = 'Useless method definition detected.'
 
         def on_def(node)
-          return if optional_args?(node)
+          return if method_definition_with_modifier?(node) || use_rest_or_optional_args?(node)
           return unless delegating?(node.body, node)
 
-          add_offense(node) { |corrector| corrector.remove(node) }
+          add_offense(node) do |corrector|
+            range = node.parent&.send_type? ? node.parent : node
+
+            corrector.remove(range)
+          end
         end
         alias on_defs on_def
 
         private
 
-        def optional_args?(node)
-          node.arguments.any? { |arg| arg.optarg_type? || arg.kwoptarg_type? }
+        def method_definition_with_modifier?(node)
+          node.parent&.send_type? && !node.parent&.non_bare_access_modifier?
+        end
+
+        def use_rest_or_optional_args?(node)
+          node.arguments.any? { |arg| arg.restarg_type? || arg.optarg_type? || arg.kwoptarg_type? }
         end
 
         def delegating?(node, def_node)

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

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # Checks for useless `rescue`s, which only reraise rescued exceptions.
+      #
+      # @example
+      #   # bad
+      #   def foo
+      #     do_something
+      #   rescue
+      #     raise
+      #   end
+      #
+      #   # bad
+      #   def foo
+      #     do_something
+      #   rescue => e
+      #     raise # or 'raise e', or 'raise $!', or 'raise $ERROR_INFO'
+      #   end
+      #
+      #   # good
+      #   def foo
+      #     do_something
+      #   rescue
+      #     do_cleanup
+      #     raise
+      #   end
+      #
+      #   # bad (latest rescue)
+      #   def foo
+      #     do_something
+      #   rescue ArgumentError
+      #     # noop
+      #   rescue
+      #     raise
+      #   end
+      #
+      #   # good (not the latest rescue)
+      #   def foo
+      #     do_something
+      #   rescue ArgumentError
+      #     raise
+      #   rescue
+      #     # noop
+      #   end
+      #
+      class UselessRescue < Base
+        MSG = 'Useless `rescue` detected.'
+
+        def on_rescue(node)
+          resbody_node = node.resbody_branches.last
+          add_offense(resbody_node) if only_reraising?(resbody_node)
+        end
+
+        private
+
+        # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity
+        def only_reraising?(resbody_node)
+          return false if use_exception_variable_in_ensure?(resbody_node)
+
+          body = resbody_node.body
+
+          return false if body.nil? || !body.send_type? || !body.method?(:raise) || body.receiver
+          return true unless body.arguments?
+          return false if body.arguments.size > 1
+
+          exception_name = body.first_argument.source
+
+          exception_objects(resbody_node).include?(exception_name)
+        end
+        # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity
+
+        def use_exception_variable_in_ensure?(resbody_node)
+          return false unless (exception_variable = resbody_node.exception_variable)
+          return false unless (ensure_node = resbody_node.each_ancestor(:ensure).first)
+          return false unless (ensure_body = ensure_node.body)
+
+          ensure_body.each_descendant(:lvar).map(&:source).include?(exception_variable.source)
+        end
+
+        def exception_objects(resbody_node)
+          [resbody_node.exception_variable&.source, '$!', '$ERROR_INFO']
+        end
+      end
+    end
+  end
+end

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

@@ -6,7 +6,7 @@ module RuboCop
       # Looks for `ruby2_keywords` calls for methods that do not need it.
       #
       # `ruby2_keywords` should only be called on methods that accept an argument splat
-      # (`*args`) but do not explicit keyword arguments (`k:` or `k: true`) or
+      # (`\*args`) but do not explicit keyword arguments (`k:` or `k: true`) or
       # a keyword splat (`**kwargs`).
       #
       # @example
@@ -77,10 +77,12 @@ module RuboCop
         PATTERN
 
         def on_send(node)
-          if node.first_argument.def_type?
-            inspect_def(node, node.first_argument)
+          return unless (first_argument = node.first_argument)
+
+          if first_argument.def_type?
+            inspect_def(node, first_argument)
           elsif node.first_argument.sym_type?
-            inspect_sym(node, node.first_argument)
+            inspect_sym(node, first_argument)
           end
         end
 
@@ -96,7 +98,7 @@ module RuboCop
           return unless node.parent
 
           method_name = sym_node.value
-          definition = node.parent.each_child_node.detect { |n| method_definition(n, method_name) }
+          definition = find_method_definition(node, method_name)
 
           return unless definition
           return if allowed_arguments(definition.arguments)
@@ -104,6 +106,14 @@ module RuboCop
           add_offense(node, message: format(MSG, method_name: method_name))
         end
 
+        def find_method_definition(node, method_name)
+          node.each_ancestor.lazy.map do |ancestor|
+            ancestor.each_child_node(:def, :block, :numblock).find do |child|
+              method_definition(child, method_name)
+            end
+          end.find(&:itself)
+        end
+
         # `ruby2_keywords` is only allowed if there's a `restarg` and no keyword arguments
         def allowed_arguments(arguments)
           return false if arguments.empty?

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

@@ -74,7 +74,7 @@ module RuboCop
         end
 
         def remove_node(corrector, node)
-          corrector.remove(range_by_whole_lines(node.loc.expression, include_final_newline: true))
+          corrector.remove(range_by_whole_lines(node.source_range, include_final_newline: true))
         end
 
         def autocorrect_block_pass(corrector, node, proc_name)

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Lint
-      # Checks for operators, variables, literals, and nonmutating
+      # Checks for operators, variables, literals, lambda, proc and nonmutating
       # methods used in void context.
       #
       # @example CheckForMethodsWithNoSideEffects: false (default)
@@ -41,24 +41,32 @@ 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.'
         SELF_MSG = '`self` used in void context.'
-        DEFINED_MSG = '`%<defined>s` used in void context.'
-        NONMUTATING_MSG = 'Method `#%<method>s` used in void context. Did you mean `#%<method>s!`?'
+        EXPRESSION_MSG = '`%<expression>s` used in void context.'
+        NONMUTATING_MSG = 'Method `#%<method>s` used in void context. Did you mean `#%<suggest>s`?'
 
         BINARY_OPERATORS = %i[* / % + - == === != < > <= >= <=>].freeze
         UNARY_OPERATORS = %i[+@ -@ ~ !].freeze
         OPERATORS = (BINARY_OPERATORS + UNARY_OPERATORS).freeze
         VOID_CONTEXT_TYPES = %i[def for block].freeze
-        NONMUTATING_METHODS = %i[capitalize chomp chop collect compact
-                                 delete_prefix delete_suffix downcase
-                                 encode flatten gsub lstrip map merge next
-                                 reject reverse rotate rstrip scrub select
-                                 shuffle slice sort sort_by squeeze strip sub
-                                 succ swapcase tr tr_s transform_values
-                                 unicode_normalize uniq upcase].freeze
+        NONMUTATING_METHODS_WITH_BANG_VERSION = %i[capitalize chomp chop compact
+                                                   delete_prefix delete_suffix downcase
+                                                   encode flatten gsub lstrip merge next
+                                                   reject reverse rotate rstrip scrub select
+                                                   shuffle slice sort sort_by squeeze strip sub
+                                                   succ swapcase tr tr_s transform_values
+                                                   unicode_normalize uniq upcase].freeze
+        METHODS_REPLACEABLE_BY_EACH = %i[collect map].freeze
+
+        NONMUTATING_METHODS = (NONMUTATING_METHODS_WITH_BANG_VERSION +
+                               METHODS_REPLACEABLE_BY_EACH).freeze
 
         def on_block(node)
           return unless node.body && !node.body.begin_type?
@@ -67,6 +75,8 @@ module RuboCop
           check_expression(node.body)
         end
 
+        alias on_numblock on_block
+
         def on_begin(node)
           check_begin(node)
         end
@@ -85,7 +95,7 @@ module RuboCop
           check_literal(expr)
           check_var(expr)
           check_self(expr)
-          check_defined(expr)
+          check_void_expression(expr)
           return unless cop_config['CheckForMethodsWithNoSideEffects']
 
           check_nonmutating(expr)
@@ -94,37 +104,67 @@ 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_defined(node)
-          return unless node.defined_type?
+        def check_void_expression(node)
+          return unless node.defined_type? || node.lambda_or_proc?
 
-          add_offense(node, message: format(DEFINED_MSG, defined: 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.send_type? && NONMUTATING_METHODS.include?(node.method_name)
-
-          add_offense(node, message: format(NONMUTATING_MSG, method: node.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)
+
+          suggestion = if METHODS_REPLACEABLE_BY_EACH.include?(method_name)
+                         'each'
+                       else
+                         "#{method_name}!"
+                       end
+          add_offense(node,
+                      message: format(NONMUTATING_MSG, method: method_name,
+                                                       suggest: suggestion)) do |corrector|
+            autocorrect_nonmutating_send(corrector, node, suggestion)
+          end
         end
 
         def in_void_context?(node)
@@ -134,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/abc_size.rb

@@ -20,7 +20,7 @@ module RuboCop
       #
       # @example CountRepeatedAttributes: false (default is true)
       #
-      #    # `model` and `current_user`, refenced 3 times each,
+      #    # `model` and `current_user`, referenced 3 times each,
       #    # are each counted as only 1 branch each if
       #    # `CountRepeatedAttributes` is set to 'false'
       #