rubocop 1.79.1 → 1.80.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: dc8a905ea4a217b5c7a43390a0777107217ce2a1a14b325e5367a4dbafb6cf1d
-  data.tar.gz: 01e471a4471ee7ac1151db63ace049693be1a8008955722b1028843034c00e82
+  metadata.gz: 496ab84015431ed6854f23f7a0e5ca4df59bc01056024b8895c59900c885530d
+  data.tar.gz: '09bc286e311ba0b4e2cb9cbc9b4c4ed33b7154311e27be5c9604f30cde4c54d7'
 SHA512:
-  metadata.gz: 21c054eb2cb142bbf75ed66598252f114e1b759d4a699f6319f804ed761cdf68b51ad75a96c02475b5bafdf5341198684c3764aadd4ccdf256d0509bf207ea0c
-  data.tar.gz: 11c7240440560b7ec024b469634ce3621a0e10363083f5ce2a8bd8d8af9ff5e5c1814a87d320297109534e0c7654c20837f9d4963e9c322e24595d907042f285
+  metadata.gz: 9b647e72a501941d047a93c9d761840664ce140ae11a9d5326855d6a9755cab4d065dcbf37db926396ab078cf18a44378ab89ed4a40745dd35bf3cec9fbdb4ce
+  data.tar.gz: 5f26cbc1e08e4fb9fa03b2cef099543864dfa741fb73e5e7062186f810a7f0f816bbe3dae981e8dba2c3758318fcbf015f7dbf140e472fbc8b5dd2f9fde1c9bf

data/README.md

@@ -51,7 +51,7 @@ To prevent an unwanted RuboCop update you might want to use a conservative versi
 in your `Gemfile`:
 
 ```rb
-gem 'rubocop', '~> 1.79', require: false
+gem 'rubocop', '~> 1.80', require: false
 ```
 
 See [our versioning policy](https://docs.rubocop.org/rubocop/versioning.html) for further details.

data/exe/rubocop

@@ -12,13 +12,6 @@ if RuboCop::Server.running?
   exit_status = RuboCop::Server::ClientCommand::Exec.new.run
 else
   require 'rubocop'
-
-  cli = RuboCop::CLI.new
-
-  time_start = Process.clock_gettime(Process::CLOCK_MONOTONIC)
-  exit_status = cli.run
-  elapsed_time = Process.clock_gettime(Process::CLOCK_MONOTONIC) - time_start
-
-  puts "Finished in #{elapsed_time} seconds" if cli.options[:debug] || cli.options[:display_time]
+  exit_status = RuboCop::CLI.new.run
 end
 exit exit_status

data/lib/rubocop/cli.rb

@@ -37,6 +37,8 @@ module RuboCop
     #
     # rubocop:disable Metrics/MethodLength, Metrics/AbcSize
     def run(args = ARGV)
+      time_start = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+
       @options, paths = Options.new.parse(args)
       @env = Environment.new(@options, @config_store, paths)
 
@@ -72,6 +74,9 @@ module RuboCop
       warn e.message
       warn e.backtrace
       STATUS_ERROR
+    ensure
+      elapsed_time = Process.clock_gettime(Process::CLOCK_MONOTONIC) - time_start
+      puts "Finished in #{elapsed_time} seconds" if @options[:debug] || @options[:display_time]
     end
     # rubocop:enable Metrics/MethodLength, Metrics/AbcSize
 

data/lib/rubocop/cop/correctors/for_to_each_corrector.rb

@@ -6,7 +6,7 @@ module RuboCop
     class ForToEachCorrector
       extend NodePattern::Macros
 
-      CORRECTION = '%<collection>s.each do |%<argument>s|'
+      CORRECTION = '%<collection>s%<dot>seach do |%<argument>s|'
 
       def initialize(for_node)
         @for_node        = for_node
@@ -25,7 +25,12 @@ module RuboCop
       attr_reader :for_node, :variable_node, :collection_node
 
       def correction
-        format(CORRECTION, collection: collection_source, argument: variable_node.source)
+        format(
+          CORRECTION,
+          collection: collection_source,
+          dot: collection_node.csend_type? ? '&.' : '.',
+          argument: variable_node.source
+        )
       end
 
       def collection_source

data/lib/rubocop/cop/layout/empty_lines_after_module_inclusion.rb

@@ -38,7 +38,7 @@ module RuboCop
         RESTRICT_ON_SEND = MODULE_INCLUSION_METHODS
 
         def on_send(node)
-          return if node.receiver
+          return if node.receiver || node.arguments.empty?
           return if node.parent&.type?(:send, :any_block)
 
           return if next_line_empty_or_enable_directive_comment?(node.last_line)
@@ -83,6 +83,8 @@ module RuboCop
         end
 
         def allowed_method?(node)
+          node = node.body if node.respond_to?(:modifier_form?) && node.modifier_form?
+
           return false unless node.send_type?
 
           MODULE_INCLUSION_METHODS.include?(node.method_name)

data/lib/rubocop/cop/layout/empty_lines_around_arguments.rb

@@ -62,40 +62,19 @@ module RuboCop
           node.receiver && node.receiver.loc.last_line != node.loc.selector&.line
         end
 
-        def empty_lines(node)
-          lines = processed_lines(node)
-          lines.select! { |code, _| code.empty? }
-          lines.map { |_, line| line }
-        end
-
-        def extra_lines(node)
-          empty_lines(node).each do |line|
-            range = source_range(processed_source.buffer, line, 0)
-            yield(range)
-          end
-        end
-
-        def processed_lines(node)
-          line_numbers(node).each_with_object([]) do |num, array|
-            array << [processed_source.lines[num - 1], num]
+        def extra_lines(node, &block)
+          node.arguments.each do |arg|
+            empty_range_for_starting_point(arg.source_range.begin, &block)
           end
-        end
 
-        def line_numbers(node)
-          inner_lines = []
-          line_nums = node.arguments.each_with_object([]) do |arg_node, lines|
-            lines << outer_lines(arg_node)
-            inner_lines << inner_lines(arg_node) if arg_node.multiline?
-          end
-          line_nums.flatten.uniq - inner_lines.flatten - outer_lines(node)
+          empty_range_for_starting_point(node.loc.end.begin, &block) if node.loc.end
         end
 
-        def inner_lines(node)
-          [node.first_line + 1, node.last_line - 1]
-        end
+        def empty_range_for_starting_point(start)
+          range = range_with_surrounding_space(start, whitespace: true, side: :left)
+          return unless range.last_line - range.first_line > 1
 
-        def outer_lines(node)
-          [node.first_line - 1, node.last_line + 1]
+          yield range.source_buffer.line_range(range.last_line - 1).adjust(end_pos: 1)
         end
       end
     end

data/lib/rubocop/cop/layout/empty_lines_around_class_body.rb

@@ -71,7 +71,7 @@ module RuboCop
         KIND = 'class'
 
         def on_class(node)
-          first_line = node.parent_class.first_line if node.parent_class
+          first_line = node.parent_class.last_line if node.parent_class
 
           check(node, node.body, adjusted_first_line: first_line)
         end

data/lib/rubocop/cop/layout/multiline_operation_indentation.rb

@@ -10,6 +10,8 @@ module RuboCop
       # condition, an explicit `return` statement, etc. In other contexts, the second operand should
       # be indented regardless of enforced style.
       #
+      # In both styles, operators should be aligned when an assignment begins on the next line.
+      #
       # @example EnforcedStyle: aligned (default)
       #   # bad
       #   if a +

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

@@ -24,8 +24,6 @@ module RuboCop
 
         MSG_REPEATED_ELEMENT = 'Duplicate element inside regexp character class'
 
-        OCTAL_DIGITS_AFTER_ESCAPE = 2
-
         def on_regexp(node)
           each_repeated_character_class_element_loc(node) do |loc|
             add_offense(loc, message: MSG_REPEATED_ELEMENT) do |corrector|
@@ -40,9 +38,9 @@ module RuboCop
 
             seen = Set.new
             group_expressions(node, expr.expressions) do |group|
-              group_source = group.map(&:to_s).join
+              group_source = group.to_s
 
-              yield source_range(group) if seen.include?(group_source)
+              yield group.expression if seen.include?(group_source)
 
               seen << group_source
             end
@@ -52,40 +50,13 @@ module RuboCop
         private
 
         def group_expressions(node, expressions)
-          # Create a mutable list to simplify state tracking while we iterate.
-          expressions = expressions.to_a
-
-          until expressions.empty?
-            # With we may need to compose a group of multiple expressions.
-            group = [expressions.shift]
-            next if within_interpolation?(node, group.first)
-
-            # With regexp_parser < 2.7 escaped octal sequences may be up to 3
-            # separate expressions ("\\0", "0", "1").
-            pop_octal_digits(group, expressions) if escaped_octal?(group.first.to_s)
-
-            yield(group)
-          end
-        end
-
-        def pop_octal_digits(current_child, expressions)
-          OCTAL_DIGITS_AFTER_ESCAPE.times do
-            next_child = expressions.first
-            break unless octal?(next_child.to_s)
+          expressions.each do |expression|
+            next if within_interpolation?(node, expression)
 
-            current_child << expressions.shift
+            yield(expression)
           end
         end
 
-        def source_range(children)
-          return children.first.expression if children.size == 1
-
-          range_between(
-            children.first.expression.begin_pos,
-            children.last.expression.begin_pos + children.last.to_s.length
-          )
-        end
-
         def skip_expression?(expr)
           expr.type != :set || expr.token == :intersection
         end
@@ -99,14 +70,6 @@ module RuboCop
           interpolation_locs(node).any? { |il| il.overlaps?(parse_tree_child_loc) }
         end
 
-        def escaped_octal?(string)
-          string.length == 2 && string[0] == '\\' && octal?(string[1])
-        end
-
-        def octal?(char)
-          ('0'..'7').cover?(char)
-        end
-
         def interpolation_locs(node)
           @interpolation_locs ||= {}
 

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

@@ -52,10 +52,9 @@ module RuboCop
           each_missing_enable do |cop, line_range|
             next if acceptable_range?(cop, line_range)
 
-            range = source_range(processed_source.buffer, line_range.min, 0..0)
             comment = processed_source.comment_at_line(line_range.begin)
 
-            add_offense(range, message: message(cop, comment))
+            add_offense(comment, message: message(cop, comment))
           end
         end
 

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

@@ -45,7 +45,7 @@ module RuboCop
           return if allow_rbs_inline_annotation? && rbs_inline_annotation?(node.receiver)
 
           if node.method?(:[]=)
-            handle_key_assignment(node) if node.arguments.size == 2
+            handle_key_assignment(node)
           elsif node.assignment_method?
             handle_attribute_assignment(node) if node.arguments.size == 1
           end
@@ -105,12 +105,13 @@ module RuboCop
         end
 
         def handle_key_assignment(node)
-          value_node = node.arguments[1]
+          value_node = node.last_argument
+          node_arguments = node.arguments[0...-1]
 
           if value_node.send_type? && value_node.method?(:[]) &&
              node.receiver == value_node.receiver &&
-             !node.first_argument.call_type? &&
-             node.first_argument == value_node.first_argument
+             node_arguments.none?(&:call_type?) &&
+             node_arguments == value_node.arguments
             add_offense(node)
           end
         end

data/lib/rubocop/cop/naming/method_name.rb

@@ -198,7 +198,7 @@ module RuboCop
 
           if forbidden_name?(name.to_s)
             register_forbidden_name(node)
-          elsif !OPERATOR_METHODS.include?(name)
+          elsif !OPERATOR_METHODS.include?(name.to_sym)
             check_name(node, name, range_position(node))
           end
         end

data/lib/rubocop/cop/style/array_intersect.rb

@@ -10,6 +10,8 @@ module RuboCop
       # * `(array1 & array2).any?`
       # * `(array1.intersection(array2)).any?`
       # * `array1.any? { |elem| array2.member?(elem) }`
+      # * `(array1 & array2).count > 0`
+      # * `(array1 & array2).size > 0`
       #
       # can be replaced with `array1.intersect?(array2)`.
       #
@@ -51,6 +53,19 @@ module RuboCop
       #   array1.intersect?(array2)
       #   !array1.intersect?(array2)
       #
+      #   # bad
+      #   (array1 & array2).count > 0
+      #   (array1 & array2).count.positive?
+      #   (array1 & array2).count != 0
+      #
+      #   (array1 & array2).count == 0
+      #   (array1 & array2).count.zero?
+      #
+      #   # good
+      #   array1.intersect?(array2)
+      #
+      #   !array1.intersect?(array2)
+      #
       # @example AllCops:ActiveSupportExtensionsEnabled: false (default)
       #   # good
       #   (array1 & array2).present?
@@ -73,9 +88,11 @@ module RuboCop
         PREDICATES = %i[any? empty? none?].to_set.freeze
         ACTIVE_SUPPORT_PREDICATES = (PREDICATES + %i[present? blank?]).freeze
 
+        ARRAY_SIZE_METHODS = %i[count length size].to_set.freeze
+
         # @!method bad_intersection_check?(node, predicates)
         def_node_matcher :bad_intersection_check?, <<~PATTERN
-          (call
+          $(call
             {
               (begin (send $_ :& $_))
               (call $_ :intersection $_)
@@ -84,6 +101,20 @@ module RuboCop
           )
         PATTERN
 
+        # @!method intersection_size_check?(node, predicates)
+        def_node_matcher :intersection_size_check?, <<~PATTERN
+          (call
+            $(call
+              {
+                (begin (send $_ :& $_))
+                (call $_ :intersection $_)
+              }
+              %ARRAY_SIZE_METHODS
+            )
+            {$:> (int 0) | $:positive? | $:!= (int 0) | $:== (int 0) | $:zero?}
+          )
+        PATTERN
+
         # @!method any_none_block_intersection(node)
         def_node_matcher :any_none_block_intersection, <<~PATTERN
           {
@@ -104,15 +135,15 @@ module RuboCop
         PATTERN
 
         MSG = 'Use `%<replacement>s` instead of `%<existing>s`.'
-        STRAIGHT_METHODS = %i[present? any?].freeze
-        NEGATED_METHODS = %i[blank? empty? none?].freeze
+        STRAIGHT_METHODS = %i[present? any? > positive? !=].freeze
+        NEGATED_METHODS = %i[blank? empty? none? == zero?].freeze
         RESTRICT_ON_SEND = (STRAIGHT_METHODS + NEGATED_METHODS).freeze
 
         def on_send(node)
           return if node.block_literal?
-          return unless (receiver, argument, method_name = bad_intersection?(node))
+          return unless (dot_node, receiver, argument, method_name = bad_intersection?(node))
 
-          dot = node.loc.dot.source
+          dot = dot_node.loc.dot.source
           bang = straight?(method_name) ? '' : '!'
           replacement = "#{bang}#{receiver.source}#{dot}intersect?(#{argument.source})"
 
@@ -135,13 +166,16 @@ module RuboCop
         private
 
         def bad_intersection?(node)
-          predicates = if active_support_extensions_enabled?
-                         ACTIVE_SUPPORT_PREDICATES
-                       else
-                         PREDICATES
-                       end
+          bad_intersection_check?(node, bad_intersection_predicates) ||
+            intersection_size_check?(node)
+        end
 
-          bad_intersection_check?(node, predicates)
+        def bad_intersection_predicates
+          if active_support_extensions_enabled?
+            ACTIVE_SUPPORT_PREDICATES
+          else
+            PREDICATES
+          end
         end
 
         def straight?(method_name)

data/lib/rubocop/cop/style/bitwise_predicate.rb

@@ -70,18 +70,25 @@ module RuboCop
             (send _ :& _))
         PATTERN
 
+        # rubocop:disable Metrics/AbcSize
         def on_send(node)
           return unless node.receiver&.begin_type?
           return unless (preferred_method = preferred_method(node))
 
           bit_operation = node.receiver.children.first
           lhs, _operator, rhs = *bit_operation
-          preferred = "#{lhs.source}.#{preferred_method}(#{rhs.source})"
+
+          preferred = if preferred_method == 'allbits?' && lhs.source == node.first_argument.source
+                        "#{rhs.source}.allbits?(#{lhs.source})"
+                      else
+                        "#{lhs.source}.#{preferred_method}(#{rhs.source})"
+                      end
 
           add_offense(node, message: format(MSG, preferred: preferred)) do |corrector|
             corrector.replace(node, preferred)
           end
         end
+        # rubocop:enable Metrics/AbcSize
 
         private
 

data/lib/rubocop/cop/style/infinite_loop.rb

@@ -68,7 +68,7 @@ module RuboCop
         end
 
         def autocorrect(corrector, node)
-          if node.type?(:while_post, :until_post)
+          if node.post_condition_loop?
             replace_begin_end_with_modifier(corrector, node)
           elsif node.modifier_form?
             replace_source(corrector, node.source_range, modifier_replacement(node))

data/lib/rubocop/cop/style/map_to_hash.rb

@@ -56,12 +56,10 @@ module RuboCop
 
         def on_send(node)
           return unless (to_h_node, map_node = map_to_h(node))
+          return if to_h_node.block_literal?
 
           message = format(MSG, method: map_node.loc.selector.source, dot: to_h_node.loc.dot.source)
           add_offense(map_node.loc.selector, message: message) do |corrector|
-            # If the `to_h` call already has a block, do not autocorrect.
-            next if to_h_node.block_literal?
-
             autocorrect(corrector, to_h_node, map_node)
           end
         end

data/lib/rubocop/cop/style/map_to_set.rb

@@ -40,12 +40,10 @@ module RuboCop
 
         def on_send(node)
           return unless (to_set_node, map_node = map_to_set?(node))
+          return if to_set_node.block_literal?
 
           message = format(MSG, method: map_node.loc.selector.source)
           add_offense(map_node.loc.selector, message: message) do |corrector|
-            # If the `to_set` call already has a block, do not autocorrect.
-            next if to_set_node.block_literal?
-
             autocorrect(corrector, to_set_node, map_node)
           end
         end

data/lib/rubocop/cop/style/redundant_begin.rb

@@ -85,6 +85,29 @@ module RuboCop
         end
         alias on_defs on_def
 
+        def on_if(node)
+          return if node.modifier_form?
+
+          inspect_branches(node)
+        end
+
+        def on_case(node)
+          inspect_branches(node)
+        end
+        alias on_case_match on_case
+
+        def on_while(node)
+          return if node.modifier_form?
+
+          body = node.body
+
+          return unless body&.kwbegin_type?
+          return if body.rescue_node || body.ensure_node
+
+          register_offense(body)
+        end
+        alias on_until on_while
+
         def on_block(node)
           return if target_ruby_version < 2.5
           return if node.send_node.lambda_literal?
@@ -199,6 +222,15 @@ module RuboCop
         def valid_begin_assignment?(node)
           node.parent&.assignment? && !node.children.one?
         end
+
+        def inspect_branches(node)
+          node.branches.each do |branch|
+            next unless branch&.kwbegin_type?
+            next if branch.rescue_node || branch.ensure_node
+
+            register_offense(branch)
+          end
+        end
       end
     end
   end

data/lib/rubocop/cop/style/redundant_condition.rb

@@ -247,7 +247,7 @@ module RuboCop
             "#{if_branch.receiver.source} #{if_branch.method_name} (#{argument_source}"
           elsif if_branch.true_type?
             condition = if_branch.parent.condition
-            return condition.source if condition.arguments.empty?
+            return condition.source if condition.arguments.empty? || condition.parenthesized?
 
             wrap_arguments_with_parens(condition)
           else

data/lib/rubocop/cop/style/redundant_parentheses.rb

@@ -149,7 +149,7 @@ module RuboCop
             return offense(begin_node, message)
           end
 
-          check_send(begin_node, node) if node.call_type?
+          check_send(begin_node, node) if call_node?(node)
         end
 
         # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity
@@ -219,7 +219,13 @@ module RuboCop
           !!config.for_enabled_cop('Style/ParenthesesAroundCondition')['AllowInMultilineConditions']
         end
 
+        def call_node?(node)
+          node.call_type? || (node.any_block_type? && node.braces? && !node.lambda_or_proc?)
+        end
+
         def check_send(begin_node, node)
+          node = node.send_node if node.any_block_type?
+
           return check_unary(begin_node, node) if node.unary_operation?
 
           return unless method_call_with_redundant_parentheses?(node)

data/lib/rubocop/cop/style/safe_navigation.rb

@@ -142,6 +142,7 @@ module RuboCop
         # @!method strip_begin(node)
         def_node_matcher :strip_begin, '{ (begin $!begin) $!(begin) }'
 
+        # rubocop:disable Metrics/AbcSize
         def on_if(node)
           return if allowed_if_condition?(node)
 
@@ -155,9 +156,11 @@ module RuboCop
           removal_ranges = [begin_range(node, body), end_range(node, body)]
 
           report_offense(node, method_chain, method_call, *removal_ranges) do |corrector|
+            corrector.replace(receiver, checked_variable.source) if checked_variable.csend_type?
             corrector.insert_before(method_call.loc.dot, '&') unless method_call.safe_navigation?
           end
         end
+        # rubocop:enable Metrics/AbcSize
 
         def on_and(node) # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength
           collect_and_clauses(node).each do |(lhs, lhs_operator_range), (rhs, _rhs_operator_range)|
@@ -259,6 +262,8 @@ module RuboCop
         end
 
         def dotless_operator_call?(method_call)
+          method_call = method_call.parent while method_call.parent.send_type?
+
           return false if method_call.loc.dot
 
           method_call.method?(:[]) || method_call.method?(:[]=) || method_call.operator_method?
@@ -333,8 +338,16 @@ module RuboCop
 
         def matching_call_nodes?(left, right)
           return false unless left && right.respond_to?(:call_type?)
+          return false unless left.call_type? && right.call_type?
+
+          # Compare receiver and method name, but ignore the difference between
+          # safe navigation method call (`&.`) and dot method call (`.`).
+          left_receiver, left_method, *left_args = left.children
+          right_receiver, right_method, *right_args = right.children
 
-          left.call_type? && right.call_type? && left.children == right.children
+          left_method == right_method &&
+            matching_nodes?(left_receiver, right_receiver) &&
+            left_args == right_args
         end
 
         def chain_length(method_chain, method)

data/lib/rubocop/cop/style/symbol_array.rb

@@ -81,7 +81,7 @@ module RuboCop
 
             content = *sym
             content = content.map { |c| c.is_a?(AST::Node) ? c.source : c }.join
-            content_without_delimiter_pairs = content.gsub(/(\[[^\s\[\]]*\])|(\([^\s\(\)]*\))/, '')
+            content_without_delimiter_pairs = content.gsub(/(\[[^\s\[\]]*\])|(\([^\s()]*\))/, '')
 
             content.include?(' ') || DELIMITERS.any? do |delimiter|
               content_without_delimiter_pairs.include?(delimiter)

data/lib/rubocop/cop/variable_force/variable.rb

@@ -79,7 +79,7 @@ module RuboCop
           parent = parent.parent if parent&.begin_type?
           return false if parent.nil?
 
-          parent.type?(:if, :while, :until) && parent.modifier_form?
+          parent.basic_conditional? && parent.modifier_form?
         end
 
         def capture_with_block!

data/lib/rubocop/cop/variable_force.rb

@@ -71,6 +71,8 @@ module RuboCop
         end
       end
 
+      BRANCH_NODES = %i[if case case_match rescue].freeze
+
       def variable_table
         @variable_table ||= VariableTable.new(self)
       end
@@ -236,11 +238,16 @@ module RuboCop
       end
 
       def process_loop(node)
-        if POST_CONDITION_LOOP_TYPES.include?(node.type)
+        if node.post_condition_loop?
           # See the comment at the end of file for this behavior.
           condition_node, body_node = *node
           process_node(body_node)
           process_node(condition_node)
+        elsif node.for_type?
+          # In `for item in items` the rightmost expression is evaluated first.
+          process_node(node.collection)
+          process_node(node.variable)
+          process_node(node.body) if node.body
         else
           process_children(node)
         end
@@ -353,16 +360,15 @@ module RuboCop
         end
       end
 
-      def reference_assignments(loop_assignments, node)
+      def reference_assignments(loop_assignments, loop_node)
         # If inside a branching statement, mark all as referenced.
         # Otherwise, mark only the last assignment as referenced.
         # Note that `rescue` must be considered as branching because of
         # the `retry` keyword.
-        if loop_assignments.first.node.each_ancestor(:if, :rescue, :case, :case_match).any?
-          loop_assignments.each { |assignment| assignment.reference!(node) }
-        else
-          loop_assignments.last&.reference!(node)
+        loop_assignments.each do |assignment|
+          assignment.reference!(loop_node) if assignment.node.each_ancestor(*BRANCH_NODES).any?
         end
+        loop_assignments.last&.reference!(loop_node)
       end
 
       def scanned_node?(node)

data/lib/rubocop/formatter/disabled_config_formatter.rb

@@ -4,7 +4,7 @@ module RuboCop
   module Formatter
     # This formatter displays a YAML configuration file where all cops that
     # detected any offenses are configured to not detect the offense.
-    class DisabledConfigFormatter < BaseFormatter
+    class DisabledConfigFormatter < BaseFormatter # rubocop:disable Metrics/ClassLength
       include PathUtil
 
       HEADING = <<~COMMENTS
@@ -17,6 +17,22 @@ module RuboCop
         # versions of RuboCop, may require this file to be generated again.
       COMMENTS
 
+      EXCLUDED_CONFIG_KEYS = %w[
+        AutoCorrect
+        Description
+        Enabled
+        Exclude
+        Include
+        Reference
+        References
+        Safe
+        SafeAutoCorrect
+        StyleGuide
+        VersionAdded
+        VersionChanged
+        VersionRemoved
+      ].freeze
+
       @config_to_allow_offenses = {}
       @detected_styles = {}
 
@@ -163,10 +179,7 @@ module RuboCop
       end
 
       def cop_config_params(default_cfg, cfg)
-        default_cfg.keys -
-          %w[Description StyleGuide Reference References Enabled Exclude Safe
-             SafeAutoCorrect VersionAdded VersionChanged VersionRemoved] -
-          cfg.keys
+        default_cfg.keys - EXCLUDED_CONFIG_KEYS - cfg.keys
       end
 
       def output_cop_param_comments(output_buffer, params, default_cfg)

data/lib/rubocop/lsp/routes.rb

@@ -51,7 +51,7 @@ module RuboCop
             capabilities: LanguageServer::Protocol::Interface::ServerCapabilities.new(
               document_formatting_provider: true,
               text_document_sync: LanguageServer::Protocol::Interface::TextDocumentSyncOptions.new(
-                change: LanguageServer::Protocol::Constant::TextDocumentSyncKind::FULL,
+                change: LanguageServer::Protocol::Constant::TextDocumentSyncKind::INCREMENTAL,
                 open_close: true
               )
             )
@@ -76,7 +76,12 @@ module RuboCop
 
       handle 'textDocument/didChange' do |request|
         params = request[:params]
-        result = diagnostic(params[:textDocument][:uri], params[:contentChanges][0][:text])
+        file_uri = params[:textDocument][:uri]
+        text = @text_cache[file_uri]
+        params[:contentChanges].each do |content|
+          text = change_text(text, content[:text], content[:range])
+        end
+        result = diagnostic(file_uri, text)
         @server.write(result)
       end
 
@@ -219,6 +224,30 @@ module RuboCop
         }
       end
 
+      def change_text(orig_text, text, range)
+        return text unless range
+
+        start_pos = text_pos(orig_text, range[:start])
+        end_pos = text_pos(orig_text, range[:end])
+        text_bin = orig_text.b
+        text_bin[start_pos...end_pos] = text.b
+        text_bin.force_encoding(orig_text.encoding)
+      end
+
+      def text_pos(text, range)
+        line = range[:line]
+        char = range[:character]
+        pos = 0
+        text.each_line.with_index do |l, i|
+          if i == line
+            pos += l.encode('utf-16be').b[0, char * 2].encode('utf-8', 'utf-16be').bytesize
+            return pos
+          end
+          pos += l.bytesize
+        end
+        pos
+      end
+
       def convert_file_uri_to_path(uri)
         URI.decode_www_form_component(uri.delete_prefix('file://'))
       end

data/lib/rubocop/result_cache.rb

@@ -198,20 +198,22 @@ module RuboCop
     end
 
     def rubocop_extra_features
-      lib_root = File.join(File.dirname(__FILE__), '..')
-      exe_root = File.join(lib_root, '..', 'exe')
+      @rubocop_extra_features ||= begin
+        lib_root = File.join(File.dirname(__FILE__), '..')
+        exe_root = File.join(lib_root, '..', 'exe')
 
-      # Make sure to use an absolute path to prevent errors on Windows
-      # when traversing the relative paths with symlinks.
-      exe_root = File.absolute_path(exe_root)
+        # Make sure to use an absolute path to prevent errors on Windows
+        # when traversing the relative paths with symlinks.
+        exe_root = File.absolute_path(exe_root)
 
-      # These are all the files we have `require`d plus everything in the
-      # exe directory. A change to any of them could affect the cop output
-      # so we include them in the cache hash.
-      source_files = $LOADED_FEATURES + Find.find(exe_root).to_a
-      source_files -= ResultCache.rubocop_required_features # Rely on gem versions
+        # These are all the files we have `require`d plus everything in the
+        # exe directory. A change to any of them could affect the cop output
+        # so we include them in the cache hash.
+        source_files = $LOADED_FEATURES + Find.find(exe_root).to_a
+        source_files -= ResultCache.rubocop_required_features # Rely on gem versions
 
-      source_files
+        source_files
+      end
     end
 
     # Return a hash of the options given at invocation, minus the ones that have

data/lib/rubocop/target_finder.rb

@@ -42,14 +42,12 @@ module RuboCop
       # Support Windows: Backslashes from command-line -> forward slashes
       base_dir = base_dir.gsub(File::ALT_SEPARATOR, File::SEPARATOR) if File::ALT_SEPARATOR
       all_files = find_files(base_dir, File::FNM_DOTMATCH)
-      # use file.include? for performance optimization
-      hidden_files = all_files.select { |file| file.include?(HIDDEN_PATH_SUBSTRING) }.sort
       base_dir_config = @config_store.for(base_dir)
 
-      target_files = if base_dir.include?(HIDDEN_PATH_SUBSTRING)
+      target_files = if hidden_path?(base_dir)
                        all_files.select { |file| ruby_file?(file) }
                      else
-                       all_files.select { |file| to_inspect?(file, hidden_files, base_dir_config) }
+                       all_files.select { |file| to_inspect?(file, base_dir_config) }
                      end
 
       target_files.sort_by!(&order)
@@ -74,18 +72,20 @@ module RuboCop
 
     private
 
-    def to_inspect?(file, hidden_files, base_dir_config)
+    def to_inspect?(file, base_dir_config)
       return false if base_dir_config.file_to_exclude?(file)
-      return true if !hidden_files.bsearch do |hidden_file|
-        file <=> hidden_file
-      end && ruby_file?(file)
+      return true if !hidden_path?(file) && ruby_file?(file)
 
       base_dir_config.file_to_include?(file)
     end
 
+    def hidden_path?(path)
+      path.include?(HIDDEN_PATH_SUBSTRING)
+    end
+
     def wanted_dir_patterns(base_dir, exclude_pattern, flags)
       # Escape glob characters in base_dir to avoid unwanted behavior.
-      base_dir = base_dir.gsub(/[\\\{\}\[\]\*\?]/) do |reserved_glob_character|
+      base_dir = base_dir.gsub(/[\\{}\[\]*?]/) do |reserved_glob_character|
         "\\#{reserved_glob_character}"
       end
 

data/lib/rubocop/version.rb

@@ -3,7 +3,7 @@
 module RuboCop
   # This module holds the RuboCop version information.
   module Version
-    STRING = '1.79.1'
+    STRING = '1.80.0'
 
     MSG = '%<version>s (using %<parser_version>s, ' \
           'rubocop-ast %<rubocop_ast_version>s, ' \

metadata

@@ -1,16 +1,15 @@
 --- !ruby/object:Gem::Specification
 name: rubocop
 version: !ruby/object:Gem::Version
-  version: 1.79.1
+  version: 1.80.0
 platform: ruby
 authors:
 - Bozhidar Batsov
 - Jonas Arvidsson
 - Yuji Nakayama
-autorequire:
 bindir: exe
 cert_chain: []
-date: 2025-07-31 00:00:00.000000000 Z
+date: 2025-08-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: json
@@ -1091,12 +1090,11 @@ licenses:
 - MIT
 metadata:
   homepage_uri: https://rubocop.org/
-  changelog_uri: https://github.com/rubocop/rubocop/releases/tag/v1.79.1
+  changelog_uri: https://github.com/rubocop/rubocop/releases/tag/v1.80.0
   source_code_uri: https://github.com/rubocop/rubocop/
-  documentation_uri: https://docs.rubocop.org/rubocop/1.79/
+  documentation_uri: https://docs.rubocop.org/rubocop/1.80/
   bug_tracker_uri: https://github.com/rubocop/rubocop/issues
   rubygems_mfa_required: 'true'
-post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -1111,8 +1109,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.3.7
-signing_key:
+rubygems_version: 3.6.2
 specification_version: 4
 summary: Automatic Ruby code style checking tool.
 test_files: []