rubocop 1.71.1 → 1.88.2

data/lib/rubocop/config_validator.rb

@@ -9,16 +9,16 @@ module RuboCop
 
     # @api private
     COMMON_PARAMS = %w[Exclude Include Severity inherit_mode AutoCorrect StyleGuide Details
-                       Enabled].freeze
+                       Enabled Reference References Safe SafeAutoCorrect].freeze
     # @api private
     INTERNAL_PARAMS = %w[Description StyleGuide
                          VersionAdded VersionChanged VersionRemoved
-                         Reference Safe SafeAutoCorrect].freeze
+                         Reference References Safe SafeAutoCorrect].freeze
     # @api private
     NEW_COPS_VALUES = %w[pending disable enable].freeze
 
     # @api private
-    CONFIG_CHECK_KEYS = %w[Enabled Safe SafeAutoCorrect AutoCorrect].to_set.freeze
+    CONFIG_CHECK_KEYS = %w[Enabled Safe SafeAutoCorrect AutoCorrect References].to_set.freeze
     CONFIG_CHECK_DEPARTMENTS = %w[pending override_department].freeze
     CONFIG_CHECK_AUTOCORRECTS = %w[always contextual disabled].freeze
     private_constant :CONFIG_CHECK_KEYS, :CONFIG_CHECK_DEPARTMENTS
@@ -118,6 +118,7 @@ module RuboCop
       invalid_cop_names.each do |name|
         # There could be a custom cop with this name. If so, don't warn
         next if Cop::Registry.global.contains_cop_matching?([name])
+        next if ConfigObsoletion.deprecated_cop_name?(name)
 
         # Special case for inherit_mode, which is a directive that we keep in
         # the configuration (even though it's not a cop), because it's easier
@@ -259,8 +260,7 @@ module RuboCop
       end
     end
 
-    # rubocop:disable Metrics/PerceivedComplexity, Metrics/CyclomaticComplexity
-    def check_cop_config_value(hash, parent = nil)
+    def check_cop_config_value(hash, parent = nil) # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
       hash.each do |key, value|
         check_cop_config_value(value, key) if value.is_a?(Hash)
 
@@ -270,6 +270,8 @@ module RuboCop
           supposed_values = 'a boolean'
         elsif key == 'AutoCorrect' && !CONFIG_CHECK_AUTOCORRECTS.include?(value)
           supposed_values = '`always`, `contextual`, `disabled`, or a boolean'
+        elsif key == 'References'
+          supposed_values = 'an array of strings'
         else
           next
         end
@@ -277,7 +279,6 @@ module RuboCop
         raise ValidationError, param_error_message(parent, key, value, supposed_values)
       end
     end
-    # rubocop:enable Metrics/PerceivedComplexity, Metrics/CyclomaticComplexity
 
     # FIXME: Handling colors in exception messages like this is ugly.
     def param_error_message(parent, key, value, supposed_values)

data/lib/rubocop/cop/autocorrect_logic.rb

@@ -35,8 +35,8 @@ module RuboCop
         # `false` is the same as `disabled` for backward compatibility.
         return false if ['disabled', false].include?(cop_config['AutoCorrect'])
 
-        # When LSP is enabled, it is considered as editing source code,
-        # and autocorrection with `AutoCorrect: contextual` will not be performed.
+        # When LSP is enabled or the `--editor-mode` option is on, it is considered as editing
+        # source code, and autocorrection with `AutoCorrect: contextual` will not be performed.
         return false if contextual_autocorrect? && LSP.enabled?
 
         # :safe_autocorrect is a derived option based on several command-line
@@ -50,7 +50,8 @@ module RuboCop
 
       def disable_offense(offense_range)
         unbreakable_range = multiline_ranges(offense_range)&.find do |range|
-          range_overlaps_offense?(offense_range, range)
+          offense_range.overlaps?(range) &&
+            eol_comment_would_be_inside_literal?(offense_range, range)
         end
 
         if unbreakable_range
@@ -75,22 +76,28 @@ module RuboCop
       end
 
       def disable_offense_with_eol_or_surround_comment(range)
-        eol_comment = " # rubocop:todo #{cop_name}"
-        needed_line_length = (range.source_line + eol_comment).length
-
-        if needed_line_length <= max_line_length
-          disable_offense_at_end_of_line(range_of_first_line(range), eol_comment)
-        else
+        if line_with_eol_comment_too_long?(range)
           disable_offense_before_and_after(range_by_lines(range))
+        else
+          disable_offense_at_end_of_line(range_of_first_line(range))
         end
       end
 
-      def range_overlaps_offense?(offense_range, range)
-        offense_range.begin_pos > range.begin_pos && range.overlaps?(offense_range)
+      def eol_comment_would_be_inside_literal?(offense_range, literal_range)
+        return true if line_with_eol_comment_too_long?(offense_range)
+
+        offense_line = offense_range.line
+        offense_line >= literal_range.first_line && offense_line < literal_range.last_line
+      end
+
+      def line_with_eol_comment_too_long?(range)
+        return false unless max_line_length
+
+        (range.source_line + eol_comment).length > max_line_length
       end
 
       def surrounding_heredoc?(node)
-        node.type?(:str, :dstr, :xstr) && node.heredoc?
+        node.any_str_type? && node.heredoc?
       end
 
       def heredoc_range(node)
@@ -102,7 +109,7 @@ module RuboCop
       end
 
       def string_continuation?(node)
-        node.type?(:str, :dstr, :xstr) && node.source.match?(/\\\s*$/)
+        node.any_str_type? && node.source.match?(/\\\s*$/)
       end
 
       def multiline_string?(node)
@@ -129,13 +136,19 @@ module RuboCop
       end
 
       def max_line_length
+        return unless config.cop_enabled?('Layout/LineLength')
+
         config.for_cop('Layout/LineLength')['Max'] || 120
       end
 
-      def disable_offense_at_end_of_line(range, eol_comment)
+      def disable_offense_at_end_of_line(range)
         Corrector.new(range).insert_after(range, eol_comment)
       end
 
+      def eol_comment
+        " # rubocop:todo #{cop_name}"
+      end
+
       def disable_offense_before_and_after(range_by_lines)
         range_with_newline = range_by_lines.resize(range_by_lines.size + 1)
         leading_whitespace = range_by_lines.source_line[/^\s*/]

data/lib/rubocop/cop/base.rb

@@ -41,6 +41,7 @@ module RuboCop
       include AutocorrectLogic
 
       attr_reader :config, :processed_source
+      attr_accessor :project_index
 
       # Reports of an investigation.
       # Immutable
@@ -306,7 +307,9 @@ module RuboCop
       def ready
         return self if self.class.support_multiple_source?
 
-        self.class.new(@config, @options)
+        self.class.new(@config, @options).tap do |fresh|
+          fresh.project_index = @project_index
+        end
       end
 
       ### Reserved for Cop::Cop
@@ -328,12 +331,11 @@ module RuboCop
       # @api private
       def self.callbacks_needed
         @callbacks_needed ||= public_instance_methods.select do |m|
-          # OPTIMIZE: Check method existence first to make fewer `start_with?` calls.
-          # At the time of writing this comment, this excludes 98 of ~104 methods.
-          # `start_with?` with two string arguments instead of a regex is faster
-          # in this specific case as well.
-          !Base.method_defined?(m) && # exclude standard "callbacks" like 'on_begin_investigation'
-            m.start_with?('on_', 'after_')
+          # OPTIMIZE: `start_with?` with two string arguments instead of a regex
+          # is faster in this specific case.
+          m.start_with?('on_', 'after_') &&
+            # exclude standard "callbacks" like 'on_new_investigation' unless refined
+            instance_method(m).owner != Base
         end
       end
       # rubocop:enable Layout/ClassStructure
@@ -416,7 +418,10 @@ module RuboCop
       ### Actually private methods
 
       def reset_investigation
-        @currently_disabled_lines = @current_offenses = @processed_source = @current_corrector = nil
+        @currently_disabled_lines = nil
+        @current_offenses = nil
+        @processed_source = nil
+        @current_corrector = nil
       end
 
       # @return [Symbol, Corrector] offense status
@@ -492,8 +497,23 @@ module RuboCop
         patterns = cop_config[parameter]
         return default_result unless patterns
 
-        patterns = FilePatterns.from(patterns)
-        patterns.match?(config.path_relative_to_config(file)) || patterns.match?(file)
+        file_patterns = FilePatterns.from(patterns)
+        relative_file_path = config.path_relative_to_config(file)
+        return true if file_patterns.match?(relative_file_path)
+
+        if parameter == 'Include' && !relative_file_path.start_with?('..')
+          matches_absolute_include_pattern?(patterns, file)
+        else
+          file_patterns.match?(file)
+        end
+      end
+
+      def matches_absolute_include_pattern?(patterns, file)
+        absolute_file_path = absolute?(file) ? file : File.expand_path(file)
+        patterns.any? do |pattern|
+          (absolute?(pattern.to_s) || pattern.to_s.start_with?('..')) &&
+            match_path?(pattern, absolute_file_path)
+        end
       end
 
       def enabled_line?(line_number)
@@ -524,15 +544,21 @@ module RuboCop
       end
 
       def range_for_original(range)
+        buffer = @current_original.buffer
+        return range if @current_offset.zero? && range.source_buffer.equal?(buffer)
+
         ::Parser::Source::Range.new(
-          @current_original.buffer,
+          buffer,
           range.begin_pos + @current_offset,
           range.end_pos + @current_offset
         )
       end
 
       def target_satisfies_all_gem_version_requirements?
-        self.class.gem_requirements.all? do |gem_name, version_req|
+        gem_requirements = self.class.gem_requirements
+        return true if gem_requirements.empty?
+
+        gem_requirements.all? do |gem_name, version_req|
           all_gem_versions_in_target = @config.gem_versions_in_target
           next false unless all_gem_versions_in_target
 

data/lib/rubocop/cop/bundler/gem_comment.rb

@@ -128,8 +128,8 @@ module RuboCop
         end
 
         def ignored_gem?(node)
-          ignored_gems = Array(cop_config['IgnoredGems'])
-          ignored_gems.include?(node.first_argument.value)
+          allowed_gems = Array(cop_config['AllowedGems'])
+          allowed_gems.include?(node.first_argument.value)
         end
 
         def checked_options_present?(node)
@@ -163,7 +163,9 @@ module RuboCop
         def gem_options(node)
           return [] unless node.last_argument&.hash_type?
 
-          node.last_argument.keys.map(&:value)
+          # Only literal keys carry an option name to check; a non-literal key
+          # (e.g. a variable or method call) has no `value` and must be skipped.
+          node.last_argument.keys.filter_map { |key| key.value if key.type?(:sym, :str) }
         end
       end
     end

data/lib/rubocop/cop/bundler/gem_version.rb

@@ -7,48 +7,48 @@ module RuboCop
       # ref, or tag) are either required or forbidden.
       #
       # @example EnforcedStyle: required (default)
-      #  # bad
-      #  gem 'rubocop'
+      #   # bad
+      #   gem 'rubocop'
       #
-      #  # good
-      #  gem 'rubocop', '~> 1.12'
+      #   # good
+      #   gem 'rubocop', '~> 1.12'
       #
-      #  # good
-      #  gem 'rubocop', '>= 1.10.0'
+      #   # good
+      #   gem 'rubocop', '>= 1.10.0'
       #
-      #  # good
-      #  gem 'rubocop', '>= 1.5.0', '< 1.10.0'
+      #   # good
+      #   gem 'rubocop', '>= 1.5.0', '< 1.10.0'
       #
-      #  # good
-      #  gem 'rubocop', branch: 'feature-branch'
+      #   # good
+      #   gem 'rubocop', branch: 'feature-branch'
       #
-      #  # good
-      #  gem 'rubocop', ref: '74b5bfbb2c4b6fd6cdbbc7254bd7084b36e0c85b'
+      #   # good
+      #   gem 'rubocop', ref: '74b5bfbb2c4b6fd6cdbbc7254bd7084b36e0c85b'
       #
-      #  # good
-      #  gem 'rubocop', tag: 'v1.17.0'
+      #   # good
+      #   gem 'rubocop', tag: 'v1.17.0'
       #
       # @example EnforcedStyle: forbidden
-      #  # good
-      #  gem 'rubocop'
+      #   # good
+      #   gem 'rubocop'
       #
-      #  # bad
-      #  gem 'rubocop', '~> 1.12'
+      #   # bad
+      #   gem 'rubocop', '~> 1.12'
       #
-      #  # bad
-      #  gem 'rubocop', '>= 1.10.0'
+      #   # bad
+      #   gem 'rubocop', '>= 1.10.0'
       #
-      #  # bad
-      #  gem 'rubocop', '>= 1.5.0', '< 1.10.0'
+      #   # bad
+      #   gem 'rubocop', '>= 1.5.0', '< 1.10.0'
       #
-      #  # bad
-      #  gem 'rubocop', branch: 'feature-branch'
+      #   # bad
+      #   gem 'rubocop', branch: 'feature-branch'
       #
-      #  # bad
-      #  gem 'rubocop', ref: '74b5bfbb2c4b6fd6cdbbc7254bd7084b36e0c85b'
+      #   # bad
+      #   gem 'rubocop', ref: '74b5bfbb2c4b6fd6cdbbc7254bd7084b36e0c85b'
       #
-      #  # bad
-      #  gem 'rubocop', tag: 'v1.17.0'
+      #   # bad
+      #   gem 'rubocop', tag: 'v1.17.0'
       #
       class GemVersion < Base
         include ConfigurableEnforcedStyle

data/lib/rubocop/cop/bundler/ordered_gems.rb

@@ -43,9 +43,8 @@ module RuboCop
         def on_new_investigation
           return if processed_source.blank?
 
-          gem_declarations(processed_source.ast)
-            .each_cons(2) do |previous, current|
-            next unless consecutive_lines(previous, current)
+          gem_declarations(processed_source.ast).each_cons(2) do |previous, current|
+            next unless consecutive_lines?(previous, current)
             next unless case_insensitive_out_of_order?(gem_name(current), gem_name(previous))
 
             register_offense(previous, current)

data/lib/rubocop/cop/commissioner.rb

@@ -64,14 +64,16 @@ module RuboCop
         r = '#' unless RESTRICTED_CALLBACKS.include?(method_name) # has Restricted?
         c = '#' if NO_CHILD_NODES.include?(node_type) # has Children?
 
+        # The `after_` calls are guarded because barely any cop defines an `after_`
+        # callback, and the guard is cheaper than the method call it avoids.
         class_eval(<<~RUBY, __FILE__, __LINE__ + 1)
-                  def on_#{node_type}(node)                               # def on_send(node)
-                    trigger_responding_cops(:on_#{node_type}, node)       #   trigger_responding_cops(:on_send, node)
-              #{r}  trigger_restricted_cops(:on_#{node_type}, node)       #   trigger_restricted_cops(:on_send, node)
-          #{c}      super(node)                                           #   super(node)
-          #{c}      trigger_responding_cops(:after_#{node_type}, node)    #   trigger_responding_cops(:after_send, node)
-          #{c}#{r}  trigger_restricted_cops(:after_#{node_type}, node)    #   trigger_restricted_cops(:after_send, node)
-                  end                                                     # end
+                  def on_#{node_type}(node)                                                                                # def on_send(node)
+                    trigger_responding_cops(:on_#{node_type}, node)                                                        #   trigger_responding_cops(:on_send, node)
+              #{r}  trigger_restricted_cops(:on_#{node_type}, node)                                                        #   trigger_restricted_cops(:on_send, node)
+          #{c}      super(node)                                                                                            #   super(node)
+          #{c}      trigger_responding_cops(:after_#{node_type}, node) if @callbacks[:after_#{node_type}]                  #   trigger_responding_cops(:after_send, node) if @callbacks[:after_send]
+          #{c}#{r}  trigger_restricted_cops(:after_#{node_type}, node) unless @restricted_map[:after_#{node_type}].empty?  #   trigger_restricted_cops(:after_send, node) unless @restricted_map[:after_send].empty?
+                  end                                                                                                      # end
         RUBY
       end
 
@@ -81,13 +83,13 @@ module RuboCop
 
         begin_investigation(processed_source, offset: offset, original: original)
         if processed_source.valid_syntax?
-          invoke(:on_new_investigation, @cops)
+          invoke(:on_new_investigation, @callbacks[:on_new_investigation])
           invoke_with_argument(:investigate, @forces, processed_source)
 
           walk(processed_source.ast) unless @cops.empty?
-          invoke(:on_investigation_end, @cops)
+          invoke(:on_investigation_end, @callbacks[:on_investigation_end])
         else
-          invoke(:on_other_file, @cops)
+          invoke(:on_other_file, @callbacks[:on_other_file])
         end
         reports = @cops.map { |cop| cop.send(:complete_investigation) }
         InvestigationReport.new(processed_source, reports, @errors)
@@ -157,7 +159,7 @@ module RuboCop
       end
 
       def invoke(callback, cops)
-        cops.each { |cop| with_cop_error_handling(cop) { cop.send(callback) } }
+        cops&.each { |cop| with_cop_error_handling(cop) { cop.send(callback) } }
       end
 
       def invoke_with_argument(callback, cops, arg)

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

@@ -16,6 +16,9 @@ module RuboCop
           return unless node
 
           @processed_source = processed_source
+          # Disable autocorrection for tabs as it requires special handling
+          return if using_tabs?
+
           expr = node.respond_to?(:loc) ? node.source_range : node
           return if block_comment_within?(expr)
 
@@ -29,10 +32,14 @@ module RuboCop
         def align_end(corrector, processed_source, node, align_to)
           @processed_source = processed_source
           whitespace = whitespace_range(node)
-          return false unless whitespace.source.strip.empty?
-
           column = alignment_column(align_to)
-          corrector.replace(whitespace, ' ' * column)
+          indentation = indentation_string(column)
+
+          if whitespace.source.strip.empty?
+            corrector.replace(whitespace, indentation)
+          else
+            corrector.insert_after(whitespace, "\n#{indentation}")
+          end
         end
 
         private
@@ -54,7 +61,7 @@ module RuboCop
         def inside_string_ranges(node)
           return [] unless node.is_a?(Parser::AST::Node)
 
-          node.each_node(:str, :dstr, :xstr).filter_map { |n| inside_string_range(n) }
+          node.each_node(:any_str).filter_map { |n| inside_string_range(n) }
         end
 
         def inside_string_range(node)
@@ -73,9 +80,7 @@ module RuboCop
         #   nil.
         # - The source map of `__FILE__` responds to neither :begin nor :end.
         def delimited_string_literal?(node)
-          loc = node.location
-
-          loc.respond_to?(:begin) && loc.begin && loc.respond_to?(:end) && loc.end
+          node.loc?(:begin) && node.loc?(:end)
         end
 
         def block_comment_within?(expr)
@@ -119,6 +124,20 @@ module RuboCop
             align_to.column
           end
         end
+
+        def indentation_string(column)
+          if using_tabs?
+            "\t" * column
+          else
+            ' ' * column
+          end
+        end
+
+        def using_tabs?
+          config = processed_source.config
+          indentation_style = config.for_cop('Layout/IndentationStyle')['EnforcedStyle']
+          indentation_style == 'tabs'
+        end
       end
     end
   end

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

@@ -16,7 +16,7 @@ module RuboCop
 
         def negated_condition(node)
           condition = node.condition
-          condition = condition.children.first while condition.begin_type?
+          condition = condition.children.last while condition.begin_type?
           condition
         end
       end

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

@@ -27,7 +27,7 @@ module RuboCop
         if block_node.arguments?
           format(CORRECTION_WITH_ARGUMENTS,
                  collection: collection_node.source,
-                 variables: argument_node.children.first.source)
+                 variables: argument_node.children.map(&:source).join(', '))
         else
           format(CORRECTION_WITHOUT_ARGUMENTS, enumerable: collection_node.source)
         end

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/correctors/lambda_literal_to_method_corrector.rb

@@ -86,7 +86,13 @@ module RuboCop
       end
 
       def lambda_arg_string
-        arguments.children.map(&:source).join(', ')
+        # Block-local (shadow) arguments are separated from regular arguments by a
+        # `;`; joining everything with `,` would turn them into extra parameters
+        # and change the lambda's arity.
+        regular, shadow = arguments.children.partition { |arg| !arg.shadowarg_type? }
+        arg_string = regular.map(&:source).join(', ')
+        arg_string += "; #{shadow.map(&:source).join(', ')}" unless shadow.empty?
+        arg_string
       end
 
       def needs_separating_space?

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

@@ -59,11 +59,7 @@ module RuboCop
       end
 
       def content_if_comment_present(corrector, node)
-        range = range_with_surrounding_space(
-          children(node).last.source_range,
-          side: :right
-        ).end.resize(1)
-        if range.source == '#'
+        if processed_source.comment_at_line(children(node).last.last_line)
           select_content_to_be_inserted_after_last_element(corrector, node)
         else
           node.loc.end.source

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

@@ -18,7 +18,14 @@ module RuboCop
           current_range = declaration_with_comment(node)
           previous_range = declaration_with_comment(previous_declaration)
 
-          ->(corrector) { corrector.swap(current_range, previous_range) }
+          lambda do |corrector|
+            if current_range.source.end_with?("\n")
+              corrector.swap(current_range, previous_range)
+            else
+              corrector.insert_before(previous_range, "#{current_range.source}\n")
+              corrector.remove(current_range)
+            end
+          end
         end
 
         private

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

@@ -10,8 +10,10 @@ module RuboCop
         COMMA_REGEXP = /(?<=\))\s*,/.freeze
 
         def correct(corrector, node)
-          corrector.remove(node.loc.begin)
-          corrector.remove(node.loc.end)
+          buffer = node.source_range.source_buffer
+          corrector.remove(range_with_surrounding_space(range: node.loc.begin, buffer: buffer,
+                                                        side: :right, whitespace: true))
+          remove_close_paren(corrector, node, buffer)
           handle_orphaned_comma(corrector, node)
 
           return unless ternary_condition?(node) && next_char_is_question_mark?(node)
@@ -21,6 +23,38 @@ module RuboCop
 
         private
 
+        # When the line above `)` ends with a comment and a chained call follows `)`,
+        # crossing the newline would pull the chain into the comment. Preserve the newline.
+        def remove_close_paren(corrector, node, buffer)
+          newlines = !comment_above_close_paren_swallows_chain?(node, buffer)
+          corrector.remove(range_with_surrounding_space(range: node.loc.end, buffer: buffer,
+                                                        side: :left, newlines: newlines))
+        end
+
+        def comment_above_close_paren_swallows_chain?(node, buffer)
+          last_child = node.children.last
+          return false unless last_child
+
+          body_end = last_child.source_range.end_pos
+          close_paren_begin = node.loc.end.begin_pos
+          return false if body_end >= close_paren_begin
+
+          source_between = buffer.source[body_end...close_paren_begin]
+          return false unless source_between.match?(/#[^\n]*\n/)
+
+          chained_after_close_paren?(node)
+        end
+
+        def chained_after_close_paren?(node)
+          close_paren = node.loc.end
+          line_text = close_paren.source_line
+          after_paren = line_text[(close_paren.column + 1)..]
+          return false if after_paren.nil?
+
+          trimmed = after_paren.lstrip
+          !trimmed.empty? && !trimmed.start_with?('#')
+        end
+
         def ternary_condition?(node)
           node.parent&.if_type? && node.parent.ternary?
         end

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

@@ -97,8 +97,8 @@ module RuboCop
         if delimiters.first != delimiters.last
           # With different delimiters (eg. `[]`, `()`), if there are the same
           # number of each, escaping is not necessary
-          delimiter_counts = delimiters.each_with_object({}) do |delimiter, counts|
-            counts[delimiter] = content.count(delimiter)
+          delimiter_counts = delimiters.to_h do |delimiter|
+            [delimiter, content.count(delimiter)]
           end
 
           return content if delimiter_counts[delimiters.first] == delimiter_counts[delimiters.last]

data/lib/rubocop/cop/correctors.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop # rubocop:disable Style/Documentation
+    # Autoloads corrector classes used by cops. Classes are autoloaded to reduce the number of
+    # required classes because they're referenced only when autocorrection is performed.
+
+    # rubocop:disable Layout/LineLength
+    autoload :AlignmentCorrector, 'rubocop/cop/correctors/alignment_corrector'
+    autoload :ConditionCorrector, 'rubocop/cop/correctors/condition_corrector'
+    autoload :EachToForCorrector, 'rubocop/cop/correctors/each_to_for_corrector'
+    autoload :EmptyLineCorrector, 'rubocop/cop/correctors/empty_line_corrector'
+    autoload :ForToEachCorrector, 'rubocop/cop/correctors/for_to_each_corrector'
+    autoload :IfThenCorrector, 'rubocop/cop/correctors/if_then_corrector'
+    autoload :LambdaLiteralToMethodCorrector, 'rubocop/cop/correctors/lambda_literal_to_method_corrector'
+    autoload :LineBreakCorrector, 'rubocop/cop/correctors/line_break_corrector'
+    autoload :MultilineLiteralBraceCorrector, 'rubocop/cop/correctors/multiline_literal_brace_corrector'
+    autoload :OrderedGemCorrector, 'rubocop/cop/correctors/ordered_gem_corrector'
+    autoload :ParenthesesCorrector, 'rubocop/cop/correctors/parentheses_corrector'
+    autoload :PercentLiteralCorrector, 'rubocop/cop/correctors/percent_literal_corrector'
+    autoload :PunctuationCorrector, 'rubocop/cop/correctors/punctuation_corrector'
+    autoload :RequireLibraryCorrector, 'rubocop/cop/correctors/require_library_corrector'
+    autoload :SpaceCorrector, 'rubocop/cop/correctors/space_corrector'
+    autoload :StringLiteralCorrector, 'rubocop/cop/correctors/string_literal_corrector'
+    autoload :UnusedArgCorrector, 'rubocop/cop/correctors/unused_arg_corrector'
+    # rubocop:enable Layout/LineLength
+  end
+end