rubocop 1.79.2 → 1.88.0

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

@@ -5,27 +5,23 @@ module RuboCop
     module Lint
       # Checks to make sure `#to_json` includes an optional argument.
       # When overriding `#to_json`, callers may invoke JSON
-      # generation via `JSON.generate(your_obj)`.  Since `JSON#generate` allows
+      # generation via `JSON.generate(your_obj)`. Since `JSON#generate` allows
       # for an optional argument, your method should too.
       #
       # @example
-      #   class Point
-      #     attr_reader :x, :y
-      #
-      #     # bad, incorrect arity
-      #     def to_json
-      #       JSON.generate([x, y])
-      #     end
+      #   # bad - incorrect arity
+      #   def to_json
+      #     JSON.generate([x, y])
+      #   end
       #
-      #     # good, preserving args
-      #     def to_json(*args)
-      #       JSON.generate([x, y], *args)
-      #     end
+      #   # good - preserving args
+      #   def to_json(*args)
+      #     JSON.generate([x, y], *args)
+      #   end
       #
-      #     # good, discarding args
-      #     def to_json(*_args)
-      #       JSON.generate([x, y])
-      #     end
+      #   # good - discarding args
+      #   def to_json(*_args)
+      #     JSON.generate([x, y])
       #   end
       #
       class ToJSON < Base

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

@@ -40,7 +40,7 @@ module RuboCop
         # top-level return node's ancestors should not be of block, def, or
         # defs type.
         def top_level_return?(return_node)
-          return_node.each_ancestor(:block, :any_def).none?
+          return_node.each_ancestor(:any_block, :any_def).none?
         end
       end
     end

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

@@ -32,9 +32,13 @@ module RuboCop
         include RangeHelp
 
         MSG = 'Avoid leaving a trailing comma in attribute declarations.'
+        RESTRICT_ON_SEND = %i[attr_reader attr_writer attr_accessor attr].freeze
 
         def on_send(node)
-          return unless node.attribute_accessor? && node.last_argument.def_type?
+          return unless node.attribute_accessor? && node.last_argument.any_def_type?
+          # A lone `def` argument (e.g. `attr_reader def foo; end`) has no preceding
+          # attribute, so there is no trailing comma to flag.
+          return unless node.arguments.size > 1
 
           trailing_comma = trailing_comma_range(node)
 

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Lint
-      # Checks for Regexpes (both literals and via `Regexp.new` / `Regexp.compile`)
+      # Checks for Regexps (both literals and via `Regexp.new` / `Regexp.compile`)
       # that contain unescaped `]` characters.
       #
       # It emulates the following Ruby warning:
@@ -68,7 +68,9 @@ module RuboCop
 
           expr.text.scan(/(?<!\\)\]/) do
             pos = Regexp.last_match.begin(0)
-            next if pos.zero? # if the unescaped bracket is the first character, Ruby does not warn
+            # If the unescaped bracket is the first character of the regexp, Ruby does not warn.
+            # `pos` is relative to the sub-expression, so add its start offset (`expr.ts`).
+            next if (expr.ts + pos).zero?
 
             location = range_at_index(node, expr.ts, pos)
 

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

@@ -120,6 +120,7 @@ module RuboCop
           check_return_values(node)
         end
         alias on_numblock on_block
+        alias on_itblock on_block
 
         private
 

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

@@ -4,8 +4,8 @@ module RuboCop
   module Cop
     module Lint
       # Checks for unreachable code.
-      # The check are based on the presence of flow of control
-      # statement in non-final position in `begin` (implicit) blocks.
+      # The check is based on the presence of flow-of-control
+      # statements in non-final position in `begin` (implicit) blocks.
       #
       # @example
       #
@@ -78,6 +78,7 @@ module RuboCop
           }
         PATTERN
 
+        # rubocop:disable Metrics/MethodLength
         def flow_expression?(node)
           return report_on_flow_command?(node) if flow_command?(node)
 
@@ -89,12 +90,14 @@ module RuboCop
             check_if(node)
           when :case, :case_match
             check_case(node)
-          when :def
+          when :def, :defs
             register_redefinition(node)
+            false
           else
             false
           end
         end
+        # rubocop:enable Metrics/MethodLength
 
         def check_if(node)
           if_branch = node.if_branch
@@ -113,8 +116,7 @@ module RuboCop
         end
 
         def register_redefinition(node)
-          @redefined << node.method_name if redefinable_flow_method? node.method_name
-          false
+          @redefined << node.method_name if redefinable_flow_method?(node.method_name)
         end
 
         def instance_eval_block?(node)

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

@@ -0,0 +1,113 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # Checks for unreachable `in` pattern branches in `case...in` statements.
+      #
+      # An `in` branch is unreachable when a previous branch uses an unguarded
+      # catch-all pattern that matches any value unconditionally. Any `in` branches
+      # (and `else`) that follow such a catch-all are dead code.
+      #
+      # A catch-all pattern is one of:
+      #
+      # * A bare variable capture (`in x`)
+      # * An underscore (`in _`)
+      # * A pattern alias where the left side is a catch-all (`in _ => y`)
+      # * An alternation pattern where at least one alternative is a catch-all
+      #   (`in _ | Integer`)
+      #
+      # NOTE: A catch-all pattern with a guard clause (e.g., `in _ if condition`)
+      # does NOT make subsequent branches unreachable because the guard might
+      # not be satisfied.
+      #
+      # @example
+      #
+      #   # bad
+      #   case value
+      #   in Integer
+      #     handle_integer
+      #   in x
+      #     handle_other
+      #   in String
+      #     handle_string
+      #   else
+      #     handle_else
+      #   end
+      #
+      #   # good
+      #   case value
+      #   in Integer
+      #     handle_integer
+      #   in String
+      #     handle_string
+      #   in x
+      #     handle_other
+      #   end
+      #
+      #   # bad - else is unreachable after catch-all
+      #   case value
+      #   in Integer
+      #     handle_integer
+      #   in _
+      #     handle_other
+      #   else
+      #     handle_else
+      #   end
+      #
+      #   # good - guard clause means catch-all might not match
+      #   case value
+      #   in x if x.positive?
+      #     handle_positive
+      #   in Integer
+      #     handle_integer
+      #   else
+      #     handle_other
+      #   end
+      #
+      class UnreachablePatternBranch < Base
+        extend TargetRubyVersion
+
+        MSG = 'Unreachable `in` pattern branch detected.'
+        MSG_ELSE = 'Unreachable `else` branch detected.'
+
+        minimum_target_ruby_version 2.7
+
+        def on_case_match(case_node)
+          catch_all_found = false
+
+          case_node.in_pattern_branches.each do |in_pattern_node|
+            if catch_all_found
+              add_offense(in_pattern_node)
+              next
+            end
+
+            pattern = in_pattern_node.pattern
+            guard = in_pattern_node.children[1]
+
+            catch_all_found = true if catch_all_pattern?(pattern) && guard.nil?
+          end
+
+          return unless catch_all_found && case_node.else?
+
+          add_offense(case_node.loc.else, message: MSG_ELSE)
+        end
+
+        private
+
+        def catch_all_pattern?(pattern)
+          case pattern.type
+          when :match_var
+            true
+          when :match_as, :begin
+            catch_all_pattern?(pattern.children[0])
+          when :match_alt
+            pattern.children.any? { |child| catch_all_pattern?(child) }
+          else
+            false
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -95,10 +95,20 @@ module RuboCop
           return unless variable.method_argument?
           return if variable.keyword_argument? && cop_config['AllowUnusedKeywordArguments']
           return if ignored_method?(variable.scope.node.body)
+          return if block_argument_with_yield?(variable)
 
           super
         end
 
+        def block_argument_with_yield?(variable)
+          return false unless variable.declaration_node.blockarg_type?
+
+          method_body = variable.scope.node.body
+          return false unless method_body
+
+          method_body.yield_type? || method_body.each_descendant(:yield).any?
+        end
+
         def ignored_method?(body)
           (cop_config['IgnoreEmptyMethods'] && body.nil?) ||
             (cop_config['IgnoreNotImplementedMethods'] && not_implemented?(body))

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

@@ -17,6 +17,7 @@ module RuboCop
       #
       #   # good
       #   CGI.escape('http://example.com')
+      #   URI.encode_uri_component(uri) # Since Ruby 3.1
       #   URI.encode_www_form([['example', 'param'], ['lang', 'en']])
       #   URI.encode_www_form(page: 10, locale: 'en')
       #   URI.encode_www_form_component('http://example.com')
@@ -27,6 +28,7 @@ module RuboCop
       #
       #   # good
       #   CGI.unescape(enc_uri)
+      #   URI.decode_uri_component(uri) # Since Ruby 3.1
       #   URI.decode_www_form(enc_uri)
       #   URI.decode_www_form_component(enc_uri)
       class UriEscapeUnescape < Base

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
@@ -182,12 +192,9 @@ module RuboCop
         # 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)
@@ -206,7 +213,28 @@ module RuboCop
         end
 
         def remove_local_variable_assignment_part(corrector, node)
-          corrector.replace(node, node.expression.source)
+          corrector.remove(node.loc.name.begin.join(node.expression.source_range.begin))
+        end
+
+        def variable_in_loop_condition?(assignment_node, variable)
+          return false if assignment_node.each_ancestor(:any_def).any?
+
+          loop_node = assignment_node.each_ancestor.find do |ancestor|
+            ancestor.type?(*VariableForce::LOOP_TYPES)
+          end
+
+          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

@@ -48,12 +48,12 @@ module RuboCop
 
         def after_private_modifier?(left_siblings)
           access_modifier_candidates = left_siblings.compact.select do |left_sibling|
-            left_sibling.respond_to?(:send_type?) && left_sibling.send_type?
+            left_sibling.respond_to?(:bare_access_modifier?) && left_sibling.bare_access_modifier?
           end
 
-          access_modifier_candidates.any? do |candidate|
-            candidate.command?(:private) && candidate.arguments.none?
-          end
+          return false if access_modifier_candidates.empty?
+
+          access_modifier_candidates.last.command?(:private)
         end
 
         def private_constantize?(right_siblings, const_value)

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

@@ -67,6 +67,8 @@ module RuboCop
         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

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

@@ -9,6 +9,13 @@ module RuboCop
       # 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
@@ -64,6 +71,8 @@ module RuboCop
       #   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,
@@ -89,8 +98,12 @@ module RuboCop
         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))
+          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

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
@@ -107,11 +107,15 @@ module RuboCop
         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
         end
 
         # `ruby2_keywords` is only allowed if there's a `restarg` and no keyword arguments

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")

data/lib/rubocop/cop/lint/utils/nil_receiver_checker.rb

@@ -31,7 +31,7 @@ module RuboCop
             @checked_nodes[node] = true
 
             case node.type
-            when :def, :class, :module, :sclass
+            when :def, :defs, :class, :module, :sclass
               return false
             when :send
               return non_nil_method?(node.method_name) if node.receiver == receiver
@@ -53,16 +53,14 @@ module RuboCop
                 return true
               end
             when :when
-              node.each_condition do |condition|
+              node.conditions.each do |condition|
                 return true if _cant_be_nil?(condition, receiver)
               end
             when :lvasgn, :ivasgn, :cvasgn, :gvasgn, :casgn
               return true if _cant_be_nil?(node.expression, receiver)
             end
 
-            # Due to how `if/else` are implemented (`elsif` is a child of `if` or another `elsif`),
-            # using left_siblings will not work correctly for them.
-            if !else_branch?(node) || (node.if_type? && !node.elsif?)
+            if sequentially_reached?(node)
               node.left_siblings.reverse_each do |sibling|
                 next unless sibling.is_a?(AST::Node)
 
@@ -82,28 +80,48 @@ module RuboCop
             !NIL_METHODS.include?(method_name) && !@additional_nil_methods.include?(method_name)
           end
 
-          # rubocop:disable Metrics/PerceivedComplexity
+          # rubocop:disable Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity
           def sole_condition_of_parent_if?(node)
+            child = node
             parent = node.parent
 
             while parent
               if parent.if_type?
-                if parent.condition == node
-                  return true
-                elsif parent.elsif?
-                  parent = find_top_if(parent)
+                unless parent.unless?
+                  condition = parent.condition
+                  return true if !child.equal?(condition) && non_nil_condition?(condition, node)
                 end
+
+                parent = find_top_if(parent) if parent.elsif?
               elsif else_branch?(parent)
                 # Find the top `if` for `else`.
                 parent = parent.parent
               end
 
+              child = parent
               parent = parent&.parent
             end
 
             false
           end
-          # rubocop:enable Metrics/PerceivedComplexity
+          # rubocop:enable Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity
+
+          def non_nil_condition?(condition, node)
+            return true if condition == node
+
+            condition.csend_type? && csend_root_receiver(condition) == node
+          end
+
+          # Whether control reaches `node` by falling through its left siblings rather than by
+          # a non-sequential entry. A `resbody` is entered via an exception, the `ensure` branch
+          # runs even after a partway raise, and the `else` arm of an `if/elsif` chain is reached by
+          # branching (its `if/case` siblings are walked via parent recursion instead).
+          def sequentially_reached?(node)
+            return false if node.resbody_type?
+            return false if node.parent&.ensure_type? && node.parent.branch.equal?(node)
+
+            !else_branch?(node) || (node.if_type? && !node.elsif?)
+          end
 
           def else_branch?(node)
             node.parent&.if_type? && node.parent.else_branch == node
@@ -114,6 +132,14 @@ module RuboCop
 
             node
           end
+
+          def csend_root_receiver(node)
+            return unless (receiver = node.receiver)
+
+            receiver = receiver.receiver while receiver.call_type? && receiver.receiver
+
+            receiver
+          end
         end
       end
     end