rubocop 1.68.0 → 1.71.2

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

@@ -95,14 +95,14 @@ module RuboCop
         MSG = 'Method definitions must not be nested. Use `lambda` instead.'
 
         def on_def(node)
-          subject, = *node
-          return if node.defs_type? && subject.variable?
+          subject, = *node # rubocop:disable InternalAffairs/NodeDestructuring
+          return if node.defs_type? && allowed_subject_type?(subject)
 
           def_ancestor = node.each_ancestor(:def, :defs).first
           return unless def_ancestor
 
           within_scoping_def =
-            node.each_ancestor(:block, :numblock, :sclass).any? do |ancestor|
+            node.each_ancestor(:any_block, :sclass).any? do |ancestor|
               scoping_method_call?(ancestor)
             end
 
@@ -117,6 +117,10 @@ module RuboCop
             child.class_constructor? || allowed_method_name?(child)
         end
 
+        def allowed_subject_type?(subject)
+          subject.variable? || subject.const_type? || subject.call_type?
+        end
+
         def allowed_method_name?(node)
           name = node.method_name
 
@@ -125,12 +129,12 @@ module RuboCop
 
         # @!method eval_call?(node)
         def_node_matcher :eval_call?, <<~PATTERN
-          ({block numblock} (send _ {:instance_eval :class_eval :module_eval} ...) ...)
+          (any_block (send _ {:instance_eval :class_eval :module_eval} ...) ...)
         PATTERN
 
         # @!method exec_call?(node)
         def_node_matcher :exec_call?, <<~PATTERN
-          ({block numblock} (send _ {:instance_exec :class_exec :module_exec} ...) ...)
+          (any_block (send _ {:instance_exec :class_exec :module_exec} ...) ...)
         PATTERN
       end
     end

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

@@ -43,7 +43,7 @@ module RuboCop
         PATTERN
 
         def parent_block_node(node)
-          node.each_ancestor(:block, :numblock).first
+          node.each_ancestor(:any_block).first
         end
       end
     end

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

@@ -45,8 +45,8 @@ module RuboCop
             end
           end
         end
-        alias on_or_asgn    on_lvasgn
-        alias on_op_asgn    on_lvasgn
+        alias on_or_asgn on_lvasgn
+        alias on_op_asgn on_lvasgn
       end
     end
   end

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

@@ -59,12 +59,12 @@ module RuboCop
 
         # @!method send_exist_node(node)
         def_node_search :send_exist_node, <<~PATTERN
-          $(send (const nil? {:FileTest :File :Dir :Shell}) {:exist? :exists?} ...)
+          $(send (const {cbase nil?} {:FileTest :File :Dir :Shell}) {:exist? :exists?} ...)
         PATTERN
 
         # @!method receiver_and_method_name(node)
         def_node_matcher :receiver_and_method_name, <<~PATTERN
-          (send (const nil? $_) $_ ...)
+          (send (const {cbase nil?} $_) $_ ...)
         PATTERN
 
         # @!method force?(node)
@@ -78,6 +78,7 @@ module RuboCop
         PATTERN
 
         def on_send(node)
+          return unless node.receiver&.const_type?
           return unless if_node_child?(node)
           return if explicit_not_force?(node)
           return unless (exist_node = send_exist_node(node.parent).first)
@@ -95,7 +96,7 @@ module RuboCop
         end
 
         def allowable_use_with_if?(if_node)
-          if_node.condition.and_type? || if_node.condition.or_type? || if_node.else_branch
+          if_node.condition.operator_keyword? || if_node.else_branch
         end
 
         def register_offense(node, exist_node)
@@ -115,6 +116,7 @@ module RuboCop
 
         def message_remove_file_exist_check(node)
           receiver, method_name = receiver_and_method_name(node)
+
           format(MSG_REMOVE_FILE_EXIST_CHECK, receiver: receiver, method_name: method_name)
         end
 

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

@@ -59,11 +59,13 @@ module RuboCop
       #
       class NonDeterministicRequireOrder < Base
         extend AutoCorrector
+        extend TargetRubyVersion
 
         MSG = 'Sort files before requiring them.'
 
+        maximum_target_ruby_version 2.7
+
         def on_block(node)
-          return if target_ruby_version >= 3.0
           return unless node.body
           return unless unsorted_dir_loop?(node.send_node)
 
@@ -75,7 +77,6 @@ module RuboCop
         end
 
         def on_numblock(node)
-          return if target_ruby_version >= 3.0
           return unless node.body
           return unless unsorted_dir_loop?(node.send_node)
 
@@ -87,7 +88,6 @@ module RuboCop
         end
 
         def on_block_pass(node)
-          return if target_ruby_version >= 3.0
           return unless method_require?(node)
           return unless unsorted_dir_pass?(node.parent)
 

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

@@ -66,7 +66,7 @@ module RuboCop
         private
 
         def scoped_node?(node)
-          node.def_type? || node.defs_type? || node.lambda?
+          node.type?(:def, :defs) || node.lambda?
         end
 
         def return_value?(return_node)

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

@@ -74,7 +74,6 @@ module RuboCop
         extend AutoCorrector
         include AllowedMethods
         include AllowedPattern
-        include IgnoredNode
 
         CONVERSION_METHOD_CLASS_MAPPING = {
           to_i: "#{Integer.name}(%<number_object>s, 10)",

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

@@ -33,8 +33,7 @@ module RuboCop
         NUMBERED_PARAMETER_RANGE = (1..9).freeze
 
         def on_lvasgn(node)
-          lhs, _rhs = *node
-          return unless /\A_(\d+)\z/ =~ lhs
+          return unless /\A_(\d+)\z/ =~ node.name
 
           number = Regexp.last_match(1).to_i
           template = NUMBERED_PARAMETER_RANGE.include?(number) ? NUM_PARAM_MSG : LVAR_MSG

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

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # Certain numeric operations have a constant result, usually 0 or 1.
+      # Multiplying a number by 0 will always return 0.
+      # Dividing a number by itself or raising it to the power of 0 will always return 1.
+      # As such, they can be replaced with that result.
+      # These are probably leftover from debugging, or are mistakes.
+      # Other numeric operations that are similarly leftover from debugging or mistakes
+      # are handled by `Lint/UselessNumericOperation`.
+      #
+      # NOTE: This cop doesn't detect offenses for the `-` and `%` operator because it
+      # can't determine the type of `x`. If `x` is an `Array` or `String`, it doesn't perform
+      # a numeric operation.
+      #
+      # @example
+      #
+      #   # bad
+      #   x * 0
+      #
+      #   # good
+      #   0
+      #
+      #   # bad
+      #   x *= 0
+      #
+      #   # good
+      #   x = 0
+      #
+      #   # bad
+      #   x / x
+      #   x ** 0
+      #
+      #   # good
+      #   1
+      #
+      #   # bad
+      #   x /= x
+      #   x **= 0
+      #
+      #   # good
+      #   x = 1
+      #
+      class NumericOperationWithConstantResult < Base
+        extend AutoCorrector
+        MSG = 'Numeric operation with a constant result detected.'
+        RESTRICT_ON_SEND = %i[* / **].freeze
+
+        # @!method operation_with_constant_result?(node)
+        def_node_matcher :operation_with_constant_result?,
+                         '(call (call nil? $_lhs) $_operation ({int | call nil?} $_rhs))'
+
+        # @!method abbreviated_assignment_with_constant_result?(node)
+        def_node_matcher :abbreviated_assignment_with_constant_result?,
+                         '(op-asgn (lvasgn $_lhs) $_operation ({int lvar} $_rhs))'
+
+        def on_send(node)
+          return unless (lhs, operation, rhs = operation_with_constant_result?(node))
+          return unless (result = constant_result?(lhs, operation, rhs))
+
+          add_offense(node) do |corrector|
+            corrector.replace(node, result.to_s)
+          end
+        end
+        alias on_csend on_send
+
+        def on_op_asgn(node)
+          return unless (lhs, operation, rhs = abbreviated_assignment_with_constant_result?(node))
+          return unless (result = constant_result?(lhs, operation, rhs))
+
+          add_offense(node) do |corrector|
+            corrector.replace(node, "#{lhs} = #{result}")
+          end
+        end
+
+        private
+
+        def constant_result?(lhs, operation, rhs)
+          if rhs.to_s == '0'
+            return 0 if operation == :*
+            return 1 if operation == :**
+          elsif rhs == lhs
+            return 1 if operation == :/
+          end
+          # If we weren't able to find any matches, return false so we can bail out.
+          false
+        end
+      end
+    end
+  end
+end

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

@@ -27,8 +27,7 @@ module RuboCop
         MSG = 'Avoid using or-assignment with constants.'
 
         def on_or_asgn(node)
-          lhs, _rhs = *node
-          return unless lhs&.casgn_type?
+          return unless node.lhs&.casgn_type?
 
           add_offense(node.loc.operator) do |corrector|
             next if node.each_ancestor(:def, :defs).any?

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Lint
-      # Looks for references of Regexp captures that are out of range
+      # Looks for references of `Regexp` captures that are out of range
       # and thus always returns nil.
       #
       # @safety
@@ -61,6 +61,7 @@ module RuboCop
             check_regexp(node.receiver)
           end
         end
+        alias after_csend after_send
 
         def on_when(node)
           regexp_conditions = node.conditions.select(&:regexp_type?)
@@ -75,7 +76,7 @@ module RuboCop
         end
 
         def on_nth_ref(node)
-          backref, = *node
+          backref = node.children.first
           return if @valid_ref.nil? || backref <= @valid_ref
 
           message = format(

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

@@ -38,16 +38,12 @@ module RuboCop
 
         def valid_context?(node)
           return true unless node.arguments.one? && node.first_argument.parenthesized_call?
-          return true if first_argument_block_type?(node.first_argument)
+          return true if node.first_argument.any_block_type?
 
           node.operator_method? || node.setter_method? || chained_calls?(node) ||
             valid_first_argument?(node.first_argument)
         end
 
-        def first_argument_block_type?(first_arg)
-          first_arg.block_type? || first_arg.numblock_type?
-        end
-
         def valid_first_argument?(first_arg)
           first_arg.operator_keyword? || first_arg.hash_type? || ternary_expression?(first_arg) ||
             compound_range?(first_arg)

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

@@ -111,7 +111,7 @@ module RuboCop
           range_between(start + begin_pos - 1, start + end_pos)
         end
 
-        # If the list of cops is comma-separated, but without a empty space after the comma,
+        # If the list of cops is comma-separated, but without an empty space after the comma,
         # we should **not** remove the prepending empty space, thus begin_pos += 1
         def range_with_comma_after(comment, start, begin_pos, end_pos)
           begin_pos += 1 if comment.source[end_pos + 1] != ' '

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Lint
-      # Checks for redundant quantifiers inside Regexp literals.
+      # Checks for redundant quantifiers inside `Regexp` literals.
       #
       # It is always allowed when interpolation is used in a regexp literal,
       # because it's unknown what kind of string will be expanded as a result:

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

@@ -6,7 +6,7 @@ module RuboCop
       # Checks for redundant safe navigation calls.
       # 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 constant. The detection also applies
-      # to literal receivers, except for `nil`.
+      # to `self`, and to literal receivers, except for `nil`.
       #
       # For all receivers, the `instance_of?`, `kind_of?`, `is_a?`, `eql?`, `respond_to?`,
       # and `equal?` methods are checked by default.
@@ -29,6 +29,9 @@ module RuboCop
       #   # bad
       #   CamelCaseConst&.do_something
       #
+      #   # good
+      #   CamelCaseConst.do_something
+      #
       #   # bad
       #   do_something if attrs&.respond_to?(:[])
       #
@@ -41,9 +44,6 @@ module RuboCop
       #   end
       #
       #   # good
-      #   CamelCaseConst.do_something
-      #
-      #   # good
       #   while node.is_a?(BeginNode)
       #     node = node.parent
       #   end
@@ -67,6 +67,12 @@ module RuboCop
       #   foo.to_f
       #   foo.to_s
       #
+      #   # bad
+      #   self&.foo
+      #
+      #   # good
+      #   self.foo
+      #
       # @example AllowedMethods: [nil_safe_method]
       #   # bad
       #   do_something if attrs&.nil_safe_method(:[])
@@ -133,7 +139,7 @@ module RuboCop
         def assume_receiver_instance_exists?(receiver)
           return true if receiver.const_type? && !receiver.short_name.match?(SNAKE_CASE)
 
-          receiver.literal? && !receiver.nil_type?
+          receiver.self_type? || (receiver.literal? && !receiver.nil_type?)
         end
 
         def check?(node)
@@ -141,8 +147,7 @@ module RuboCop
           return false unless parent
 
           condition?(parent, node) ||
-            parent.and_type? ||
-            parent.or_type? ||
+            parent.operator_keyword? ||
             (parent.send_type? && parent.negation_method?)
         end
 

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

@@ -135,10 +135,10 @@ module RuboCop
           grandparent.array_type? && grandparent.children.size > 1
         end
 
+        # rubocop:disable Metrics/AbcSize
         def replacement_range_and_content(node)
-          variable, = *node
-          loc = node.loc
-          expression = loc.expression
+          variable = node.children.first
+          expression = node.source_range
 
           if array_new?(variable)
             expression = node.parent.source_range if node.parent.array_type?
@@ -148,16 +148,17 @@ module RuboCop
           elsif redundant_brackets?(node)
             [expression, remove_brackets(variable)]
           else
-            [loc.operator, '']
+            [node.loc.operator, '']
           end
         end
+        # rubocop:enable Metrics/AbcSize
 
         def array_splat?(node)
           node.children.first.array_type?
         end
 
         def method_argument?(node)
-          node.parent.send_type?
+          node.parent.call_type?
         end
 
         def part_of_an_array?(node)
@@ -171,7 +172,7 @@ module RuboCop
           parent = node.parent
           grandparent = node.parent.parent
 
-          parent.when_type? || parent.send_type? || part_of_an_array?(node) ||
+          parent.when_type? || method_argument?(node) || part_of_an_array?(node) ||
             grandparent&.resbody_type?
         end
 
@@ -196,7 +197,7 @@ module RuboCop
         def use_percent_literal_array_argument?(node)
           argument = node.children.first
 
-          node.parent.send_type? &&
+          method_argument?(node) &&
             (argument.percent_literal?(:string) || argument.percent_literal?(:symbol))
         end
 

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

@@ -29,7 +29,7 @@ module RuboCop
         RESTRICT_ON_SEND = %i[print puts warn].freeze
 
         # @!method to_s_without_args?(node)
-        def_node_matcher :to_s_without_args?, '(send _ :to_s)'
+        def_node_matcher :to_s_without_args?, '(call _ :to_s)'
 
         def on_interpolation(begin_node)
           final_node = begin_node.children.last
@@ -42,7 +42,7 @@ module RuboCop
         def on_send(node)
           return if node.receiver
 
-          node.each_child_node(:send) do |child|
+          node.each_child_node(:call) do |child|
             next if !child.method?(:to_s) || child.arguments.any?
 
             register_offense(child, "`#{node.method_name}`")

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

@@ -6,7 +6,7 @@ module RuboCop
       # Checks if `include` or `prepend` is called in `refine` block.
       # These methods are deprecated and should be replaced with `Refinement#import_methods`.
       #
-      # It emulates deprecation warnings in Ruby 3.1.
+      # It emulates deprecation warnings in Ruby 3.1. Functionality has been removed in Ruby 3.2.
       #
       # @safety
       #   This cop's autocorrection is unsafe because `include M` will affect the included class

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

@@ -17,7 +17,6 @@ module RuboCop
       #     do_something
       #   end
       class RegexpAsCondition < Base
-        include IgnoredNode
         extend AutoCorrector
 
         MSG = 'Do not use regexp literal as a condition. ' \

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Lint
-      # Checks for `rescue` blocks targeting the Exception class.
+      # Checks for `rescue` blocks targeting the `Exception` class.
       #
       # @example
       #

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

@@ -42,15 +42,11 @@ module RuboCop
         INVALID_TYPES = %i[array dstr float hash nil int str sym].freeze
 
         def on_resbody(node)
-          rescued, _, _body = *node
-          return if rescued.nil?
-
-          exceptions = *rescued
-          invalid_exceptions = invalid_exceptions(exceptions)
+          invalid_exceptions = invalid_exceptions(node.exceptions)
           return if invalid_exceptions.empty?
 
           add_offense(
-            node.loc.keyword.join(rescued.source_range),
+            node.loc.keyword.join(node.children.first.source_range),
             message: format(MSG, invalid_exceptions: invalid_exceptions.map(&:source).join(', '))
           ) do |corrector|
             autocorrect(corrector, node)
@@ -58,7 +54,7 @@ module RuboCop
         end
 
         def autocorrect(corrector, node)
-          rescued, _, _body = *node
+          rescued = node.children.first
           range = node.loc.keyword.end.join(rescued.source_range.end)
 
           corrector.replace(range, correction(*rescued))

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

@@ -33,7 +33,7 @@ module RuboCop
         def_node_matcher :bad_method?, <<~PATTERN
           {
             (send $(csend ...) $_ ...)
-            (send $({block numblock} (csend ...) ...) $_ ...)
+            (send $(any_block (csend ...) ...) $_ ...)
           }
         PATTERN
 
@@ -97,12 +97,19 @@ module RuboCop
         end
 
         def require_parentheses?(send_node)
+          return true if operator_inside_hash?(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
+
+        def operator_inside_hash?(send_node)
+          # If an operator call (without a dot) is inside a hash, it needs
+          # to be parenthesized when converted to safe navigation.
+          send_node.parent&.pair_type? && !send_node.loc.dot
+        end
       end
     end
   end

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

@@ -83,6 +83,8 @@ module RuboCop
         def find_consistent_parts(grouped_operands)
           csend_in_and, csend_in_or, send_in_and, send_in_or = most_left_indices(grouped_operands)
 
+          return if csend_in_and && csend_in_or && csend_in_and < csend_in_or
+
           if csend_in_and
             ['.', (send_in_and ? [send_in_and, csend_in_and].min : csend_in_and) + 1]
           elsif send_in_or && csend_in_or

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

@@ -43,23 +43,21 @@ module RuboCop
         alias on_csend on_send
 
         def on_lvasgn(node)
-          lhs, rhs = *node
-          return unless rhs
+          return unless node.rhs
 
           rhs_type = ASSIGNMENT_TYPE_TO_RHS_TYPE[node.type]
 
-          add_offense(node) if rhs.type == rhs_type && rhs.source == lhs.to_s
+          add_offense(node) if node.rhs.type == rhs_type && node.rhs.source == node.lhs.to_s
         end
         alias on_ivasgn on_lvasgn
         alias on_cvasgn on_lvasgn
         alias on_gvasgn on_lvasgn
 
         def on_casgn(node)
-          lhs_scope, lhs_name, rhs = *node
-          return unless rhs&.const_type?
+          return unless node.rhs&.const_type?
 
-          rhs_scope, rhs_name = *rhs
-          add_offense(node) if lhs_scope == rhs_scope && lhs_name == rhs_name
+          add_offense(node) if node.namespace == node.rhs.namespace &&
+                               node.short_name == node.rhs.short_name
         end
 
         def on_masgn(node)
@@ -67,15 +65,15 @@ module RuboCop
         end
 
         def on_or_asgn(node)
-          lhs, rhs = *node
-          add_offense(node) if rhs_matches_lhs?(rhs, lhs)
+          add_offense(node) if rhs_matches_lhs?(node.rhs, node.lhs)
         end
         alias on_and_asgn on_or_asgn
 
         private
 
         def multiple_self_assignment?(node)
-          lhs, rhs = *node
+          lhs = node.lhs
+          rhs = node.rhs
           return false unless rhs.array_type?
           return false unless lhs.children.size == rhs.children.size
 

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

@@ -67,7 +67,7 @@ module RuboCop
         def on_rescue(node)
           return if rescue_modifier?(node)
 
-          _body, *rescues, _else = *node
+          rescues = node.resbody_branches
           rescued_groups = rescued_groups_for(rescues)
 
           rescue_group_rescues_multiple_levels = rescued_groups.any? do |group|