rubocop 1.42.0 → 1.64.1

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/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

@@ -98,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)
@@ -106,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

@@ -4,7 +4,7 @@ module RuboCop
   module Cop
     module Lint
       # Checks for uses of `Integer#times` that will never yield
-      # (when the integer <= 0) or that will only ever yield once
+      # (when the integer ``<= 0``) or that will only ever yield once
       # (`1.times`).
       #
       # @safety
@@ -64,7 +64,7 @@ module RuboCop
             remove_node(corrector, node)
           elsif !proc_name.empty?
             autocorrect_block_pass(corrector, node, proc_name)
-          else
+          elsif node.block_type?
             autocorrect_block(corrector, node)
           end
         end
@@ -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

@@ -6,6 +6,16 @@ module RuboCop
       # Checks for operators, variables, literals, lambda, proc and nonmutating
       # methods used in void context.
       #
+      # `each` blocks are allowed to prevent false positives.
+      # For example, the expression inside the `each` block below.
+      # It's not void, especially when the receiver is an `Enumerator`:
+      #
+      # [source,ruby]
+      # ----
+      # enumerator = [1, 2, 3].filter
+      # enumerator.each { |item| item >= 2 } #=> [2, 3]
+      # ----
+      #
       # @example CheckForMethodsWithNoSideEffects: false (default)
       #   # bad
       #   def some_method
@@ -41,29 +51,39 @@ 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.'
+        CONST_MSG = 'Constant `%<var>s` used in void context.'
         LIT_MSG = 'Literal `%<lit>s` used in void context.'
         SELF_MSG = '`self` used in void context.'
         EXPRESSION_MSG = '`%<expression>s` used in void context.'
-        NONMUTATING_MSG = 'Method `#%<method>s` used in void context. Did you mean `#%<method>s!`?'
+        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?
           return unless in_void_context?(node.body)
 
+          check_void_op(node.body) { node.method?(:each) }
           check_expression(node.body)
         end
 
@@ -79,11 +99,18 @@ module RuboCop
         def check_begin(node)
           expressions = *node
           expressions.pop unless in_void_context?(node)
-          expressions.each { |expr| check_expression(expr) }
+          expressions.each do |expr|
+            check_void_op(expr) do
+              block_node = node.each_ancestor(:block).first
+
+              block_node&.method?(:each)
+            end
+
+            check_expression(expr)
+          end
         end
 
         def check_expression(expr)
-          check_void_op(expr)
           check_literal(expr)
           check_var(expr)
           check_self(expr)
@@ -93,40 +120,74 @@ module RuboCop
           check_nonmutating(expr)
         end
 
-        def check_void_op(node)
+        def check_void_op(node, &block)
           return unless node.send_type? && OPERATORS.include?(node.method_name)
+          return if block && yield(node)
 
-          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?
+            template = node.special_keyword? ? VAR_MSG : CONST_MSG
+
+            offense_range = node
+            message = format(template, var: node.source)
+          else
+            offense_range = node.loc.name
+            message = format(VAR_MSG, var: node.loc.name.source)
+          end
+
+          add_offense(offense_range, message: message) do |corrector|
+            autocorrect_void_expression(corrector, node)
+          end
         end
 
         def check_literal(node)
-          return if !node.literal? || node.xstr_type? || node.range_type?
+          return if !entirely_literal?(node) || 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.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)
@@ -136,6 +197,44 @@ 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
+
+        def entirely_literal?(node)
+          case node.type
+          when :array
+            node.each_value.all? { |value| entirely_literal?(value) }
+          when :hash
+            return false unless node.each_key.all? { |key| entirely_literal?(key) }
+
+            node.each_value.all? { |value| entirely_literal?(value) }
+          else
+            node.literal?
+          end
+        end
       end
     end
   end

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

@@ -10,9 +10,9 @@ module RuboCop
       #
       # Interpreting ABC size:
       #
-      # * <= 17 satisfactory
-      # * 18..30 unsatisfactory
-      # * > 30 dangerous
+      # * ``<= 17`` satisfactory
+      # * `18..30` unsatisfactory
+      # * `>` 30 dangerous
       #
       # You can have repeated "attributes" calls count as a single "branch".
       # For this purpose, attributes are any method with no argument; no attempt

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
@@ -51,7 +51,7 @@ module RuboCop
         def on_block(node)
           return if allowed_method?(node.method_name) || matches_allowed_pattern?(node.method_name)
           return if method_receiver_excluded?(node)
-          return if node.class_constructor? || node.struct_constructor?
+          return if node.class_constructor?
 
           check_code_length(node)
         end

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

@@ -12,7 +12,7 @@ module RuboCop
       #
       # The maximum level of nesting allowed is configurable.
       class BlockNesting < Base
-        NESTING_BLOCKS = %i[case if while while_post until until_post for resbody].freeze
+        NESTING_BLOCKS = %i[case case_match if while while_post until until_post for resbody].freeze
 
         exclude_limit 'Max'
 
@@ -44,7 +44,7 @@ module RuboCop
         def consider_node?(node)
           return true if NESTING_BLOCKS.include?(node.type)
 
-          count_blocks? && node.block_type?
+          count_blocks? && (node.block_type? || node.numblock_type?)
         end
 
         def message(max)

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
 
@@ -43,6 +43,12 @@ module RuboCop
           check_code_length(node)
         end
 
+        def on_sclass(node)
+          return if node.each_ancestor(:class).any?
+
+          on_class(node)
+        end
+
         def on_casgn(node)
           parent = node.parent