rubocop 1.71.1 → 1.92.0

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

@@ -40,8 +40,6 @@ module RuboCop
       class UselessAssignment < Base
         extend AutoCorrector
 
-        include RangeHelp
-
         MSG = 'Useless assignment to variable - `%<variable>s`.'
 
         def self.joining_forces
@@ -52,32 +50,44 @@ module RuboCop
           scope.variables.each_value { |variable| check_for_unused_assignments(variable) }
         end
 
-        # rubocop:disable Metrics/AbcSize, Metrics/PerceivedComplexity, Metrics/CyclomaticComplexity
         def check_for_unused_assignments(variable)
           return if variable.should_be_unused?
 
           variable.assignments.reverse_each do |assignment|
-            assignment_node = assignment.node
-            next if assignment.used? || part_of_ignored_node?(assignment_node)
+            check_for_unused_assignment(variable, assignment)
+          end
+        end
 
-            message = message_for_useless_assignment(assignment)
-            range = offense_range(assignment)
+        def check_for_unused_assignment(variable, assignment)
+          assignment_node = assignment.node
 
-            add_offense(range, message: message) do |corrector|
-              # In cases like `x = 1, y = 2`, where removing a variable would cause a syntax error,
-              # and where changing `x ||= 1` to `x = 1` would cause `NameError`,
-              # the autocorrect will be skipped, even if the variable is unused.
-              if sequential_assignment?(assignment_node) || assignment_node.parent&.or_asgn_type?
-                next
-              end
+          return if ignored_assignment?(variable, assignment_node, assignment)
 
-              autocorrect(corrector, assignment)
-            end
+          message = message_for_useless_assignment(assignment)
+          range = offense_range(assignment)
 
-            ignore_node(assignment_node) if chained_assignment?(assignment_node)
+          add_offense(range, message: message) do |corrector|
+            next if uncorrectable_assignment?(assignment_node)
+
+            autocorrect(corrector, assignment)
           end
+
+          ignore_node(assignment_node) if chained_assignment?(assignment_node)
+        end
+
+        # Autocorrect is skipped when removing a variable would cause a syntax error
+        # (`x = 1, y = 2`), or where rewriting `x ||= 1`/`x &&= 1` to `x = 1` would raise
+        # `NameError` because the variable is not declared before the operator assignment.
+        def uncorrectable_assignment?(assignment_node)
+          sequential_assignment?(assignment_node) ||
+            assignment_node.parent&.or_asgn_type? ||
+            assignment_node.parent&.and_asgn_type?
+        end
+
+        def ignored_assignment?(variable, assignment_node, assignment)
+          assignment.used? || part_of_ignored_node?(assignment_node) ||
+            variable_in_loop_condition?(assignment_node, variable)
         end
-        # rubocop:enable Metrics/AbcSize, Metrics/PerceivedComplexity, Metrics/CyclomaticComplexity
 
         def message_for_useless_assignment(assignment)
           variable = assignment.variable
@@ -104,6 +114,8 @@ module RuboCop
         end
 
         def chained_assignment?(node)
+          return true if node.lvasgn_type? && node.expression&.send_type?
+
           node.respond_to?(:expression) && node.expression&.lvasgn_type?
         end
 
@@ -161,7 +173,7 @@ module RuboCop
           node.receiver.nil? && !node.arguments?
         end
 
-        # rubocop:disable Metrics/AbcSize
+        # rubocop:disable-next Metrics/AbcSize
         def autocorrect(corrector, assignment)
           if assignment.exception_assignment?
             remove_exception_assignment_part(corrector, assignment.node)
@@ -177,15 +189,11 @@ module RuboCop
             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
-            )
-          )
+          range = node.parent.children.first&.source_range || node.parent.location.keyword
+
+          corrector.remove(range.end.join(node.source_range.end))
         end
 
         def rename_variable_with_underscore(corrector, node)
@@ -204,7 +212,35 @@ module RuboCop
         end
 
         def remove_local_variable_assignment_part(corrector, node)
-          corrector.replace(node, node.expression.source)
+          expression = node.expression
+          assignment_part = node.loc.name.begin.join(expression.source_range.begin)
+
+          # `x = 1, 2` cannot become `1, 2`, so the values become an array literal.
+          if expression.array_type? && !expression.bracketed?
+            corrector.replace(assignment_part, '[')
+            corrector.insert_after(expression, ']')
+          else
+            corrector.remove(assignment_part)
+          end
+        end
+
+        def variable_in_loop_condition?(assignment_node, variable)
+          # A method defined inside the loop has its own scope, so the loop condition
+          # can only read the variable if the loop is nearer than any method definition.
+          loop_node = assignment_node.each_ancestor(*VariableForce::LOOP_TYPES, :any_def).first
+          return false if !loop_node || loop_node.any_def_type?
+          return false unless loop_node.respond_to?(:condition)
+
+          condition_node = loop_node.condition
+          variable_name = variable.name
+
+          return true if condition_node.lvar_type? && condition_node.children.first == variable_name
+
+          condition_node.each_descendant(:lvar) do |lvar_node|
+            return true if lvar_node.children.first == variable_name
+          end
+
+          false
         end
       end
     end

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

@@ -0,0 +1,107 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # Checks for useless constant scoping. Private constants must be defined using
+      # `private_constant`. Even if `private` access modifier is used, it is public scope despite
+      # its appearance.
+      #
+      # It does not support autocorrection due to behavior change and multiple ways to fix it.
+      # Or a public constant may be intended.
+      #
+      # Constant assignments that define classes or modules via `Class.new`, `Module.new`,
+      # `Struct.new`, or `Data.define` are allowed. Those forms are class and module definitions
+      # written with assignment syntax, and match the common practice of placing nested
+      # `class` / `module` bodies after `private` without intending private constant visibility.
+      #
+      # @example
+      #
+      #   # bad
+      #   class Foo
+      #     private
+      #     PRIVATE_CONST = 42
+      #   end
+      #
+      #   # good
+      #   class Foo
+      #     PRIVATE_CONST = 42
+      #     private_constant :PRIVATE_CONST
+      #   end
+      #
+      #   # good
+      #   class Foo
+      #     PUBLIC_CONST = 42 # If private scope is not intended.
+      #   end
+      #
+      #   # good - class/module definitions via assignment, same as nested `class`/`module`
+      #   class Foo
+      #     private
+      #
+      #     def some_private_method
+      #     end
+      #
+      #     MyClass = Class.new
+      #     MyModule = Module.new
+      #     MyStruct = Struct.new(:name)
+      #     MyData = Data.define(:name)
+      #   end
+      #
+      class UselessConstantScoping < Base
+        MSG = 'Useless `private` access modifier for constant scope.'
+
+        # @!method private_constants(node)
+        def_node_matcher :private_constants, <<~PATTERN
+          (send nil? :private_constant $...)
+        PATTERN
+
+        # Matches class/module-like constant assignments. Nested `class` / `module`
+        # keyword definitions are not visited by this cop; these assignment forms are
+        # the equivalent syntax and should be treated the same way.
+        # @!method class_or_module_definition_assignment?(node)
+        def_node_matcher :class_or_module_definition_assignment?, <<~PATTERN
+          {
+            (send (const {nil? cbase} {:Class :Module :Struct}) :new ...)
+            (send (const {nil? cbase} :Data) :define ...)
+            (any_block
+              {
+                (send (const {nil? cbase} {:Class :Module :Struct}) :new ...)
+                (send (const {nil? cbase} :Data) :define ...)
+              }
+              ...)
+          }
+        PATTERN
+
+        def on_casgn(node)
+          return unless after_private_modifier?(node.left_siblings)
+          return if private_constantize?(node.right_siblings, node.name)
+          return if class_or_module_definition_assignment?(node.expression)
+
+          add_offense(node)
+        end
+
+        private
+
+        def after_private_modifier?(left_siblings)
+          access_modifier_candidates = left_siblings.compact.select do |left_sibling|
+            left_sibling.respond_to?(:bare_access_modifier?) && left_sibling.bare_access_modifier?
+          end
+
+          return false if access_modifier_candidates.empty?
+
+          access_modifier_candidates.last.command?(:private)
+        end
+
+        def private_constantize?(right_siblings, const_value)
+          private_constant_arguments = right_siblings.map { |node| private_constants(node) }
+
+          private_constant_values = private_constant_arguments.flatten.filter_map do |constant|
+            constant.value.to_sym if constant.respond_to?(:value)
+          end
+
+          private_constant_values.include?(const_value)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # Checks for usage of method `fetch` or `Array.new` with default value argument
+      # and block. In such cases, block will always be used as default value.
+      #
+      # This cop emulates Ruby warning "block supersedes default value argument" which
+      # applies to `Array.new`, `Array#fetch`, `Hash#fetch`, `ENV.fetch` and
+      # `Thread#fetch`.
+      #
+      # A `fetch` call without a receiver is considered a custom method and does not register
+      # an offense.
+      #
+      # @safety
+      #   This cop is unsafe because the receiver could have nonstandard implementation
+      #   of `fetch`, or be a class other than the one listed above.
+      #
+      #   It is also unsafe because default value argument could have side effects:
+      #
+      #   [source,ruby]
+      #   ----
+      #   def x(a) = puts "side effect"
+      #   Array.new(5, x(1)) { 2 }
+      #   ----
+      #
+      #   so removing it would change behavior.
+      #
+      # @example
+      #   # bad
+      #   x.fetch(key, default_value) { block_value }
+      #   Array.new(size, default_value) { block_value }
+      #
+      #   # good
+      #   x.fetch(key) { block_value }
+      #   Array.new(size) { block_value }
+      #
+      #   # also good - in case default value argument is desired instead
+      #   x.fetch(key, default_value)
+      #   Array.new(size, default_value)
+      #
+      #   # good - keyword arguments aren't registered as offenses
+      #   x.fetch(key, keyword: :arg) { block_value }
+      #
+      # @example AllowedReceivers: ['Rails.cache']
+      #   # good
+      #   Rails.cache.fetch(name, options) { block }
+      #
+      class UselessDefaultValueArgument < Base
+        include AllowedReceivers
+        extend AutoCorrector
+
+        MSG = 'Block supersedes default value argument.'
+
+        RESTRICT_ON_SEND = %i[fetch new].freeze
+
+        # @!method default_value_argument_and_block(node)
+        def_node_matcher :default_value_argument_and_block, <<~PATTERN
+          (any_block
+            {
+              (call !nil? :fetch $_key $_default_value)
+              (send (const _ :Array) :new $_size $_default_value)
+            }
+            _args
+            _block_body)
+        PATTERN
+
+        def on_send(node)
+          return unless node.receiver
+
+          unless (prev_arg_node, default_value_node = default_value_argument_and_block(node.parent))
+            return
+          end
+          return if allowed_receiver?(node.receiver)
+          return if hash_without_braces?(default_value_node)
+
+          add_offense(default_value_node) do |corrector|
+            corrector.remove(prev_arg_node.source_range.end.join(default_value_node.source_range))
+          end
+        end
+        alias on_csend on_send
+
+        private
+
+        def hash_without_braces?(node)
+          node.hash_type? && !node.braces?
+        end
+      end
+    end
+  end
+end

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

@@ -59,7 +59,7 @@ module RuboCop
         end
 
         def use_rest_or_optional_args?(node)
-          node.arguments.any? { |arg| arg.type?(:restarg, :optarg, :kwoptarg) }
+          node.arguments.any? { |arg| arg.type?(:restarg, :optarg, :kwoptarg, :kwrestarg) }
         end
 
         def delegating?(node, def_node)

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

@@ -31,35 +31,36 @@ module RuboCop
       #
       class UselessNumericOperation < Base
         extend AutoCorrector
+
         MSG = 'Do not apply inconsequential numeric operations to variables.'
         RESTRICT_ON_SEND = %i[+ - * / **].freeze
 
         # @!method useless_operation?(node)
-        def_node_matcher :useless_operation?, '(call (call nil? $_) $_ (int $_))'
+        def_node_matcher :useless_operation?, <<~PATTERN
+          (call ${lvar ivar cvar gvar const (send nil? _)} $_ (int $_))
+        PATTERN
 
         # @!method useless_abbreviated_assignment?(node)
-        def_node_matcher :useless_abbreviated_assignment?, '(op-asgn (lvasgn $_) $_ (int $_))'
+        def_node_matcher :useless_abbreviated_assignment?, <<~PATTERN
+          (op-asgn ${lvasgn ivasgn cvasgn gvasgn casgn} $_ (int $_))
+        PATTERN
 
         def on_send(node)
-          return unless useless_operation?(node)
-
-          variable, operation, number = useless_operation?(node)
+          return unless (receiver, operation, number = useless_operation?(node))
           return unless useless?(operation, number)
 
           add_offense(node) do |corrector|
-            corrector.replace(node, variable)
+            corrector.replace(node, receiver.source)
           end
         end
         alias on_csend on_send
 
         def on_op_asgn(node)
-          return unless useless_abbreviated_assignment?(node)
-
-          variable, operation, number = useless_abbreviated_assignment?(node)
+          return unless (variable, operation, number = useless_abbreviated_assignment?(node))
           return unless useless?(operation, number)
 
           add_offense(node) do |corrector|
-            corrector.replace(node, "#{variable} = #{variable}")
+            corrector.replace(node, "#{variable.source} = #{variable.source}")
           end
         end
 

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

@@ -0,0 +1,111 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # Checks for useless OR (`||` and `or`) expressions.
+      #
+      # Some methods always return a truthy value, even when called
+      # on `nil` (e.g. `nil.to_i` evaluates to `0`). Therefore, OR expressions
+      # appended after these methods will never evaluate.
+      #
+      # @safety
+      #   As shown in the examples below, there are generally two possible ways to correct the
+      #   offense, but this cop's autocorrection always chooses the option that preserves the
+      #   current behavior. While this does not change how the code behaves, that option is not
+      #   necessarily the appropriate fix in every situation. For this reason, the autocorrection
+      #   provided by this cop is considered unsafe.
+      #
+      # @example
+      #
+      #   # bad
+      #   x.to_a || fallback
+      #   x.to_c || fallback
+      #   x.to_d || fallback
+      #   x.to_i || fallback
+      #   x.to_f || fallback
+      #   x.to_h || fallback
+      #   x.to_r || fallback
+      #   x.to_s || fallback
+      #   x.to_sym || fallback
+      #   x.intern || fallback
+      #   x.inspect || fallback
+      #   x.hash || fallback
+      #   x.object_id || fallback
+      #   x.__id__ || fallback
+      #
+      #   x.to_s or fallback
+      #
+      #   # good - if fallback is same as return value of method called on nil
+      #   x.to_a # nil.to_a returns []
+      #   x.to_c # nil.to_c returns (0+0i)
+      #   x.to_d # nil.to_d returns 0.0
+      #   x.to_i # nil.to_i returns 0
+      #   x.to_f # nil.to_f returns 0.0
+      #   x.to_h # nil.to_h returns {}
+      #   x.to_r # nil.to_r returns (0/1)
+      #   x.to_s # nil.to_s returns ''
+      #   x.to_sym # nil.to_sym raises an error
+      #   x.intern # nil.intern raises an error
+      #   x.inspect # nil.inspect returns "nil"
+      #   x.hash # nil.hash returns an Integer
+      #   x.object_id # nil.object_id returns an Integer
+      #   x.__id__ # nil.object_id returns an Integer
+      #
+      #   # good - if the intention is not to call the method on nil
+      #   x&.to_a || fallback
+      #   x&.to_c || fallback
+      #   x&.to_d || fallback
+      #   x&.to_i || fallback
+      #   x&.to_f || fallback
+      #   x&.to_h || fallback
+      #   x&.to_r || fallback
+      #   x&.to_s || fallback
+      #   x&.to_sym || fallback
+      #   x&.intern || fallback
+      #   x&.inspect || fallback
+      #   x&.hash || fallback
+      #   x&.object_id || fallback
+      #   x&.__id__ || fallback
+      #
+      #   x&.to_s or fallback
+      #
+      class UselessOr < Base
+        extend AutoCorrector
+
+        MSG = '`%<rhs>s` will never evaluate because `%<lhs>s` always returns a truthy value.'
+
+        TRUTHY_RETURN_VALUE_METHODS = Set[:to_a, :to_c, :to_d, :to_i, :to_f, :to_h, :to_r,
+                                          :to_s, :to_sym, :intern, :inspect, :hash, :object_id,
+                                          :__id__].freeze
+
+        # @!method truthy_return_value_method?(node)
+        def_node_matcher :truthy_return_value_method?, <<~PATTERN
+          (send _ %TRUTHY_RETURN_VALUE_METHODS)
+        PATTERN
+
+        def on_or(node)
+          if truthy_return_value_method?(node.lhs)
+            report_offense(node, node.lhs)
+          elsif truthy_return_value_method?(node.rhs)
+            parent = node.parent
+            parent = parent.parent if parent&.begin_type?
+
+            report_offense(parent, node.rhs) if parent&.or_type?
+          end
+        end
+
+        private
+
+        def report_offense(or_node, truthy_node)
+          add_offense(
+            or_node.loc.operator.join(or_node.rhs.source_range),
+            message: format(MSG, lhs: truthy_node.source, rhs: or_node.rhs.source)
+          ) do |corrector|
+            corrector.replace(or_node, or_node.lhs.source)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Lint
-      # Checks for useless `rescue`s, which only reraise rescued exceptions.
+      # Checks for useless ``rescue``s, which only reraise rescued exceptions.
       #
       # @example
       #   # bad
@@ -56,7 +56,7 @@ module RuboCop
 
         private
 
-        # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity
+        # rubocop:disable-next Metrics/AbcSize, Metrics/CyclomaticComplexity
         def only_reraising?(resbody_node)
           return false if use_exception_variable_in_ensure?(resbody_node)
 
@@ -70,7 +70,6 @@ module RuboCop
 
           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)

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 have explicit keyword arguments (`k:` or `k: true`) or
       # a keyword splat (`**kwargs`).
       #
       # @example
@@ -89,7 +89,7 @@ module RuboCop
         private
 
         def inspect_def(node, def_node)
-          return if allowed_arguments(def_node.arguments)
+          return if allowed_arguments?(def_node.arguments)
 
           add_offense(node.loc.selector, message: format(MSG, method_name: def_node.method_name))
         end
@@ -101,21 +101,27 @@ module RuboCop
           definition = find_method_definition(node, method_name)
 
           return unless definition
-          return if allowed_arguments(definition.arguments)
+          return if allowed_arguments?(definition.arguments)
 
           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, :any_block).find do |child|
+          node.each_ancestor do |ancestor|
+            found = ancestor.each_child_node(:def, :any_block).find do |child|
               method_definition(child, method_name)
             end
-          end.find(&:itself)
+            return found if found
+            # A method defined in an outer lexical scope does not define this scope's method,
+            # so stop searching once a class/module boundary is crossed without a match.
+            return nil if ancestor.type?(:class, :module, :sclass)
+          end
+
+          nil
         end
 
         # `ruby2_keywords` is only allowed if there's a `restarg` and no keyword arguments
-        def allowed_arguments(arguments)
+        def allowed_arguments?(arguments)
           return false if arguments.empty?
 
           arguments.each_child_node(:restarg).any? &&

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

@@ -107,7 +107,10 @@ module RuboCop
           end
 
           def process_multiple_assignment(masgn_node)
-            masgn_node.assignments.each_with_index do |lhs_node, index|
+            # Iterate the top-level destructuring slots so each maps to the right-hand side
+            # element at the same position. Using the flattened `assignments` would misalign
+            # the index when a slot is itself a nested destructuring (e.g. `(a, b), c = x, y`).
+            masgn_node.lhs.children.each_with_index do |lhs_node, index|
               next unless ASSIGNMENT_TYPES.include?(lhs_node.type)
 
               if masgn_node.rhs.array_type? && (rhs_node = masgn_node.rhs.children[index])

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

@@ -83,7 +83,7 @@ module RuboCop
 
         def autocorrect_block(corrector, node)
           block_arg = block_arg(node)
-          return if block_reassigns_arg?(node, block_arg)
+          return unless reducible_to_body?(node, block_arg)
 
           source = node.body.source
           source.gsub!(/\b#{block_arg}\b/, '0') if block_arg
@@ -91,6 +91,27 @@ module RuboCop
           corrector.replace(node, fix_indentation(source, node.loc.column...node.body.loc.column))
         end
 
+        def reducible_to_body?(node, block_arg)
+          # A block with multiple arguments can't be reduced to its body (the extra arguments
+          # would become undefined references), and `next`/`break`/`redo` bound to the block
+          # become orphaned (a syntax error) once the block is removed.
+          return false if node.arguments.size > 1 || orphans_loop_control_keyword?(node)
+
+          # A lone non-simple argument (destructuring `|(a, b)|` or a splat `|*a|`) can't be
+          # substituted either, so reducing to the body would leave it referencing an
+          # undefined variable.
+          return false if node.arguments.one? && block_arg.nil?
+
+          !block_reassigns_arg?(node, block_arg)
+        end
+
+        def orphans_loop_control_keyword?(node)
+          node.body&.each_node(:next, :break, :redo)&.any? do |control|
+            inner = control.each_ancestor.take_while { |ancestor| !ancestor.equal?(node) }
+            inner.none? { |ancestor| ancestor.type?(:any_block, :while, :until, :for) }
+          end
+        end
+
         def fix_indentation(source, range)
           # Cleanup indentation in a multiline block
           source_lines = source.split("\n")