rubocop 1.84.2 → 1.88.0

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

@@ -46,7 +46,7 @@ module RuboCop
           message = format_message_from(processed_source)
 
           add_offense(comment, message: message) do
-            autocorrect if autocorrect_requested?
+            autocorrect if autocorrect?
           end
         end
 
@@ -57,6 +57,10 @@ module RuboCop
         end
 
         def executable?(processed_source)
+          # Virtual sources (LSP buffers, programmatic `ProcessedSource`) have no file on
+          # disk to stat or `chmod`, so treat them as executable to skip the offense.
+          return true unless File.exist?(processed_source.file_path)
+
           # Returns true if stat is executable or if the operating system
           # doesn't distinguish executable files from nonexecutable files.
           # See at: https://github.com/ruby/ruby/blob/ruby_2_4/file.c#L5362

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

@@ -90,12 +90,35 @@ module RuboCop
         def on_or_asgn(node)
           return if allow_rbs_inline_annotation? && rbs_inline_annotation?(node.lhs)
 
-          add_offense(node) if rhs_matches_lhs?(node.rhs, node.lhs)
+          add_offense(node) if or_and_asgn_self_assignment?(node.lhs, node.rhs)
         end
         alias on_and_asgn on_or_asgn
 
         private
 
+        def or_and_asgn_self_assignment?(lhs, rhs)
+          case lhs.type
+          when :casgn
+            rhs.const_type? && lhs.namespace == rhs.namespace && lhs.short_name == rhs.short_name
+          when :send, :csend
+            reader_self_assignment?(lhs, rhs)
+          else
+            rhs_matches_lhs?(rhs, lhs)
+          end
+        end
+
+        # Compares two reader calls (attribute `foo.bar` or key `hash['foo']`).
+        def reader_self_assignment?(lhs, rhs)
+          return false unless rhs.type == lhs.type
+          return false unless lhs.method?(rhs.method_name)
+          return false unless lhs.receiver == rhs.receiver
+          return false unless lhs.arguments == rhs.arguments
+
+          # `hash[foo] ||= hash[foo]` is intentionally allowed because a method-call key may
+          # return different results on each call.
+          lhs.arguments.none?(&:call_type?)
+        end
+
         def multiple_self_assignment?(node)
           lhs = node.lhs
           rhs = node.rhs

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

@@ -45,7 +45,7 @@ module RuboCop
         # @!method send_with_mixin_argument?(node)
         def_node_matcher :send_with_mixin_argument?, <<~PATTERN
           (send
-            (const _ _) {:#{SEND_METHODS.join(' :')}}
+            {nil? self (const _ _)} {:#{SEND_METHODS.join(' :')}}
             ({sym str} $#mixin_method?)
               $(const _ _)+)
         PATTERN

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Lint
-      # Checks for a rescued exception that get shadowed by a
+      # Checks for a rescued exception that gets shadowed by a
       # less specific exception being rescued before a more specific
       # exception is rescued.
       #

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

@@ -75,6 +75,8 @@ module RuboCop
         end
 
         def same_conditions_node_different_branch?(variable, outer_local_variable)
+          return true if different_case_in_branch?(variable, outer_local_variable)
+
           variable_node = variable_node(variable)
           return false unless node_or_its_ascendant_conditional?(variable_node)
 
@@ -88,6 +90,18 @@ module RuboCop
             variable_node == outer_local_variable_node.else_branch
         end
 
+        # `case ... in` binds variables in the pattern itself, so a block argument in one
+        # `in` branch does not shadow a pattern variable from a different `in` branch of the
+        # same `case` (the branches are mutually exclusive).
+        def different_case_in_branch?(variable, outer_local_variable)
+          inner_branch = variable.scope.node.each_ancestor(:in_pattern).first
+          outer_branch = outer_local_variable.declaration_node.each_ancestor(:in_pattern).first
+
+          return false unless inner_branch && outer_branch
+
+          inner_branch != outer_branch && inner_branch.parent == outer_branch.parent
+        end
+
         def variable_node(variable)
           parent_node = variable.scope.node.parent
 

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

@@ -56,7 +56,9 @@ module RuboCop
               {array hash (send (const {nil? cbase} {:Array :Hash}) :new)}
               !#capacity_keyword_argument?
             ])
-            (send (const {nil? cbase} :Hash) :new hash #capacity_keyword_argument?)
+            (send (const {nil? cbase} :Hash) :new
+              {array hash (send (const {nil? cbase} {:Array :Hash}) :new)}
+              #capacity_keyword_argument?)
           }
         PATTERN
 

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

@@ -88,6 +88,10 @@ module RuboCop
             return unless (method = numeric_constructor_rescue_nil(node))
           end
 
+          # `Integer(arg, exception: false)` already suppresses the conversion error, so there
+          # is nothing unintentionally swallowed; adding another `exception: false` is wrong.
+          return if exception_keyword_argument?(method)
+
           arguments = method.arguments.map(&:source) << 'exception: false'
           prefer = "#{method.method_name}(#{arguments.join(', ')})"
           prefer = "#{method.receiver.source}#{method.loc.dot.source}#{prefer}" if method.receiver
@@ -100,6 +104,14 @@ module RuboCop
 
         private
 
+        def exception_keyword_argument?(method)
+          method.arguments.any? do |argument|
+            argument.hash_type? && argument.pairs.any? do |pair|
+              pair.key.sym_type? && pair.key.value == :exception
+            end
+          end
+        end
+
         def expected_exception_classes_only?(exception_classes)
           return true unless (arguments = exception_classes.first)
 

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

@@ -77,11 +77,28 @@ module RuboCop
 
         def on_send(node)
           return unless node.receiver
+          return unless (correction = symbol_conversion_correction(node.receiver))
 
-          if node.receiver.type?(:str, :sym)
-            register_offense(node, correction: node.receiver.value.to_sym.inspect)
-          elsif node.receiver.dstr_type?
-            register_offense(node, correction: ":\"#{node.receiver.value.to_sym}\"")
+          register_offense(node, correction: correction)
+        end
+
+        def symbol_conversion_correction(receiver)
+          if receiver.type?(:str, :sym)
+            receiver.value.to_sym.inspect
+          elsif receiver.dstr_type? && !receiver.heredoc?
+            dstr_correction(receiver)
+          end
+        end
+
+        # Reuse the already-escaped inner source for a plain `"..."` string so embedded
+        # quotes stay escaped. Percent literals (`%{}`, `%Q{}`, ...) and adjacent string
+        # concatenation have multi-character or no delimiters, so slicing the source would
+        # corrupt them; fall back to the node's value there.
+        def dstr_correction(receiver)
+          if receiver.loc.begin&.source == '"'
+            ":\"#{receiver.source[1..-2]}\""
+          else
+            ":\"#{receiver.value.to_sym}\""
           end
         end
 

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

@@ -26,7 +26,31 @@ module RuboCop
                       "#{diagnostic.message}\n(Using Ruby #{ruby_version} parser; " \
                         'configure using `TargetRubyVersion` parameter, under `AllCops`)'
                     end
-          add_offense(diagnostic.location, message: message, severity: diagnostic.level)
+          location = diagnostic_location(diagnostic.location)
+          add_offense(location, message: message, severity: diagnostic.level)
+        end
+
+        # Expand zero-length diagnostic ranges so that editors and formatters
+        # can display them. This typically occurs when the parser reports
+        # `unexpected token $end` at EOF.
+        def diagnostic_location(location)
+          return location if location.size.positive?
+
+          source_buffer = location.source_buffer
+          if location.end_pos < source_buffer.source.size
+            location.resize(1)
+          elsif location.begin_pos.positive?
+            location.adjust(begin_pos: -1)
+          else
+            location
+          end
+        end
+
+        # Override to skip multiline_ranges check which requires AST.
+        # Syntax errors mean the AST is nil, so we go directly to
+        # the EOL comment insertion path.
+        def disable_offense(offense_range)
+          disable_offense_with_eol_or_surround_comment(offense_range)
         end
 
         def add_offense_from_error(error)

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

@@ -61,7 +61,7 @@ module RuboCop
         def arguments_match?(arguments, def_node)
           index = 0
 
-          def_node.arguments.reject(&:blockarg_type?).all? do |def_arg|
+          all_present = def_node.arguments.reject(&:blockarg_type?).all? do |def_arg|
             send_arg = arguments[index]
             case def_arg.type
             when :arg, :restarg, :optarg
@@ -70,6 +70,33 @@ module RuboCop
 
             send_arg && argument_match?(send_arg, def_arg)
           end
+
+          all_present && !extra_positional_arguments?(arguments, def_node)
+        end
+
+        # The enumerator re-invokes the method with these arguments, so passing more
+        # positional arguments than the method accepts raises `ArgumentError` at runtime.
+        def extra_positional_arguments?(arguments, def_node)
+          return false if variadic_parameters?(def_node) || expandable_arguments?(arguments)
+
+          positional_arguments(arguments).size > positional_parameters(def_node).size
+        end
+
+        def variadic_parameters?(def_node)
+          def_node.arguments.any? { |arg| arg.type?(:restarg, :forward_arg) }
+        end
+
+        # A splat or argument forwarding on the call side can expand to any arity.
+        def expandable_arguments?(arguments)
+          arguments.any? { |arg| arg.type?(:splat, :forwarded_args, :forwarded_restarg) }
+        end
+
+        def positional_arguments(arguments)
+          arguments.reject { |arg| arg.type?(:hash, :kwsplat, :block_pass, :forwarded_kwrestarg) }
+        end
+
+        def positional_parameters(def_node)
+          def_node.arguments.select { |arg| arg.type?(:arg, :optarg) }
         end
 
         # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength

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
       #

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/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
@@ -69,11 +67,7 @@ module RuboCop
           range = offense_range(assignment)
 
           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.
-            next if sequential_assignment?(assignment_node) ||
-                    assignment_node.parent&.or_asgn_type?
+            next if uncorrectable_assignment?(assignment_node)
 
             autocorrect(corrector, assignment)
           end
@@ -81,6 +75,15 @@ module RuboCop
           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)
@@ -189,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)
@@ -213,7 +213,7 @@ 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)

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