rubocop 1.68.0 → 1.69.0

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

@@ -0,0 +1,106 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # Certain numeric operations have a constant result, usually 0 or 1.
+      # Subtracting a number from itself or multiplying it by 0 will always return 0.
+      # Additionally, a variable modulo 0 or itself 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.
+      #
+      # @example
+      #
+      #   # bad
+      #   x - x
+      #   x * 0
+      #   x % 1
+      #   x % x
+      #
+      #   # good
+      #   0
+      #
+      #   # bad
+      #   x -= x
+      #   x *= 0
+      #   x %= 1
+      #   x %= x
+      #
+      #   # 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?,
+                         '(send (send nil? $_) $_ ({int | send nil?} $_))'
+
+        # @!method abbreviated_assignment_with_constant_result?(node)
+        def_node_matcher :abbreviated_assignment_with_constant_result?,
+                         '(op-asgn (lvasgn $_) $_ ({int | lvar} $_))'
+
+        def on_send(node)
+          return unless operation_with_constant_result?(node)
+
+          variable, operation, number = operation_with_constant_result?(node)
+          result = constant_result?(variable, operation, number)
+          return unless result
+
+          add_offense(node) do |corrector|
+            corrector.replace(node, result.to_s)
+          end
+        end
+
+        def on_op_asgn(node)
+          return unless abbreviated_assignment_with_constant_result?(node)
+
+          variable, operation, number = abbreviated_assignment_with_constant_result?(node)
+          result = constant_result?(variable, operation, number)
+          return unless result
+
+          add_offense(node) do |corrector|
+            corrector.replace(node, "#{variable} = #{result}")
+          end
+        end
+
+        private
+
+        # rubocop :disable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+        def constant_result?(variable, operation, number)
+          if number.to_s == '0'
+            return 0 if operation == :*
+            return 1 if operation == :**
+          elsif number.to_s == '1'
+            return 0 if operation == :%
+          elsif number == variable
+            return 0 if %i[- %].include?(operation)
+            return 1 if operation == :/
+          end
+          # If we weren't able to find any matches, return false so we can bail out.
+          false
+        end
+        # rubocop :enable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+      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

@@ -75,7 +75,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/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_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/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_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_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|

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

@@ -39,6 +39,8 @@ module RuboCop
       #   end
       #
       # @example IgnoreNotImplementedMethods: true (default)
+      #   # with default value of `NotImplementedExceptions: ['NotImplementedError']`
+      #
       #   # good
       #   def do_something(unused)
       #     raise NotImplementedError
@@ -48,6 +50,14 @@ module RuboCop
       #     fail "TODO"
       #   end
       #
+      # @example IgnoreNotImplementedMethods: true
+      #   # with `NotImplementedExceptions: ['AbstractMethodError']`
+      #
+      #   # good
+      #   def do_something(unused)
+      #     raise AbstractMethodError
+      #   end
+      #
       # @example IgnoreNotImplementedMethods: false
       #   # bad
       #   def do_something(unused)
@@ -57,14 +67,13 @@ module RuboCop
       #   def do_something_else(unused)
       #     fail "TODO"
       #   end
-      #
       class UnusedMethodArgument < Base
         include UnusedArgument
         extend AutoCorrector
 
         # @!method not_implemented?(node)
         def_node_matcher :not_implemented?, <<~PATTERN
-          {(send nil? :raise (const {nil? cbase} :NotImplementedError) ...)
+          {(send nil? :raise #allowed_exception_class? ...)
            (send nil? :fail ...)}
         PATTERN
 
@@ -115,6 +124,13 @@ module RuboCop
 
           message
         end
+
+        def allowed_exception_class?(node)
+          return false unless node.const_type?
+
+          allowed_class_names = Array(cop_config.fetch('NotImplementedExceptions', []))
+          allowed_class_names.include?(node.const_name)
+        end
       end
     end
   end

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

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # Checks for calls to `defined?` with strings or symbols as the argument.
+      # Such calls will always return `'expression'`, you probably meant to
+      # check for the existence of a constant, method, or variable instead.
+      #
+      # `defined?` is part of the Ruby syntax and doesn't behave like normal methods.
+      # You can safely pass in what you are checking for directly, without encountering
+      # a `NameError`.
+      #
+      # When interpolation is used, oftentimes it is not possible to write the
+      # code with `defined?`. In these cases, switch to one of the more specific methods:
+      #
+      # * `class_variable_defined?`
+      # * `const_defined?`
+      # * `method_defined?`
+      # * `instance_variable_defined?`
+      # * `binding.local_variable_defined?`
+      #
+      # @example
+      #
+      #   # bad
+      #   defined?('FooBar')
+      #   defined?(:FooBar)
+      #   defined?(:foo_bar)
+      #   defined?('foo_bar')
+      #
+      #   # good
+      #   defined?(FooBar)
+      #   defined?(foo_bar)
+      #
+      #   # bad - interpolation
+      #   bar = 'Bar'
+      #   defined?("Foo::#{bar}::Baz")
+      #
+      #   # good
+      #   bar = 'Bar'
+      #   defined?(Foo) && Foo.const_defined?(bar) && Foo.const_get(bar).const_defined?(:Baz)
+      class UselessDefined < Base
+        MSG = 'Calling `defined?` with a %<type>s argument will always return a truthy value.'
+        TYPES = { str: 'string', dstr: 'string', sym: 'symbol', dsym: 'symbol' }.freeze
+
+        def on_defined?(node)
+          # NOTE: `defined?` always takes one argument. Anything else is a syntax error.
+          return unless (type = TYPES[node.first_argument.type])
+
+          add_offense(node, message: format(MSG, type: type))
+        end
+      end
+    end
+  end
+end

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

@@ -75,7 +75,7 @@ module RuboCop
         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)
+          return false unless (ensure_body = ensure_node.branch)
 
           ensure_body.each_descendant(:lvar).map(&:source).include?(exception_variable.source)
         end

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

@@ -102,24 +102,18 @@ module RuboCop
             when :op_asgn
               process_binary_operator_assignment(node)
             when *ASSIGNMENT_TYPES
-              _, rhs_node = *node
-              process_assignment(node, rhs_node) if rhs_node
+              process_assignment(node, node.rhs) if node.rhs
             end
           end
 
           def process_multiple_assignment(masgn_node)
-            mlhs_node, mrhs_node = *masgn_node
-
-            mlhs_node.children.each_with_index do |lhs_node, index|
+            masgn_node.assignments.each_with_index do |lhs_node, index|
               next unless ASSIGNMENT_TYPES.include?(lhs_node.type)
 
-              lhs_variable_name, = *lhs_node
-              rhs_node = mrhs_node.children[index]
-
-              if mrhs_node.array_type? && rhs_node
-                process_assignment(lhs_variable_name, rhs_node)
+              if masgn_node.rhs.array_type? && (rhs_node = masgn_node.rhs.children[index])
+                process_assignment(lhs_node, rhs_node)
               else
-                @local[lhs_variable_name] = true
+                @local[lhs_node.name] = true
               end
             end
 
@@ -127,33 +121,28 @@ module RuboCop
           end
 
           def process_logical_operator_assignment(asgn_node)
-            lhs_node, rhs_node = *asgn_node
-            return unless ASSIGNMENT_TYPES.include?(lhs_node.type)
+            return unless ASSIGNMENT_TYPES.include?(asgn_node.lhs.type)
 
-            process_assignment(lhs_node, rhs_node)
+            process_assignment(asgn_node.lhs, asgn_node.rhs)
 
             throw :skip_children
           end
 
           def process_binary_operator_assignment(op_asgn_node)
-            lhs_node, = *op_asgn_node
+            lhs_node = op_asgn_node.lhs
             return unless ASSIGNMENT_TYPES.include?(lhs_node.type)
 
-            lhs_variable_name, = *lhs_node
-            @local[lhs_variable_name] = true
+            @local[lhs_node.name] = true
 
             throw :skip_children
           end
 
           def process_assignment(asgn_node, rhs_node)
-            lhs_variable_name, = *asgn_node
-
-            @local[lhs_variable_name] = if rhs_node.variable?
-                                          rhs_variable_name, = *rhs_node
-                                          @local[rhs_variable_name]
-                                        else
-                                          constructor?(rhs_node)
-                                        end
+            @local[asgn_node.name] = if rhs_node.variable?
+                                       @local[rhs_node.name]
+                                     else
+                                       constructor?(rhs_node)
+                                     end
           end
 
           def constructor?(node)

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

@@ -126,7 +126,7 @@ module RuboCop
 
         def check_void_op(node, &block)
           node = node.children.first while node.begin_type?
-          return unless node.send_type? && OPERATORS.include?(node.method_name)
+          return unless node.call_type? && OPERATORS.include?(node.method_name)
           return if block && yield(node)
 
           add_offense(node.loc.selector,
@@ -196,7 +196,7 @@ module RuboCop
         end
 
         def check_ensure(node)
-          return unless (body = node.body)
+          return unless (body = node.branch)
           # NOTE: the `begin` node case is already handled via `on_begin`
           return if body.begin_type?
 
@@ -219,6 +219,7 @@ module RuboCop
           if node.arguments.empty?
             corrector.replace(node, node.receiver.source)
           else
+            corrector.remove(node.loc.dot) if node.loc.dot
             corrector.replace(
               range_with_surrounding_space(range: node.loc.selector, side: :both,
                                            newlines: false),

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

@@ -53,13 +53,13 @@ module RuboCop
         def on_casgn(node)
           parent = node.parent
 
-          if parent&.assignment?
-            block_node = parent.children[1]
-          elsif parent&.parent&.masgn_type?
-            block_node = parent.parent.children[1]
-          else
-            _scope, _name, block_node = *node
-          end
+          block_node = if parent&.assignment?
+                         parent.expression
+                       elsif parent&.parent&.masgn_type?
+                         parent.parent.expression
+                       else
+                         node.expression
+                       end
 
           return unless block_node.respond_to?(:class_definition?) && block_node.class_definition?
 

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

@@ -95,7 +95,7 @@ module RuboCop
           def compound_assignment(node)
             # Methods setter cannot be detected for multiple assignments
             # and shorthand assigns, so we'll count them here instead
-            children = node.masgn_type? ? node.children[0].children : node.children
+            children = node.masgn_type? ? node.assignments : node.children
 
             will_be_miscounted = children.count do |child|
               child.respond_to?(:setter_method?) && !child.setter_method?

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

@@ -148,8 +148,7 @@ module RuboCop
             when :class, :module, :sclass, :block, :numblock, :def, :defs
               node.body
             when :casgn
-              _scope, _name, value = *node
-              extract_body(value)
+              extract_body(node.expression)
             else
               node
             end

data/lib/rubocop/cop/mixin/check_assignment.rb

@@ -17,9 +17,7 @@ module RuboCop
       alias on_and_asgn on_lvasgn
 
       def on_send(node)
-        rhs = extract_rhs(node)
-
-        return unless rhs
+        return unless (rhs = extract_rhs(node))
 
         check_assignment(node, rhs)
       end
@@ -27,17 +25,11 @@ module RuboCop
       module_function
 
       def extract_rhs(node)
-        if node.casgn_type?
-          _scope, _lhs, rhs = *node
-        elsif node.op_asgn_type?
-          _lhs, _op, rhs = *node
-        elsif node.call_type?
-          rhs = node.last_argument
+        if node.call_type?
+          node.last_argument
         elsif node.assignment?
-          _lhs, rhs = *node
+          node.expression
         end
-
-        rhs
       end
     end
   end