rubocop 1.89.0 → 1.90.0

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

@@ -27,6 +27,13 @@ module RuboCop
       # alone is not reported, since the index does not see gems or the
       # standard library.
       #
+      # For the same reason, a namespace whose root segment names a gem in the
+      # bundle (`Flipper` for the `flipper` gem) is left alone: a project that
+      # reopens it (`module Flipper; module Adapters; ...`) makes it resolve in
+      # the index, while the members the gem itself defines stay invisible and
+      # would look like typos. Enabling `AllCops/ProjectIndexIncludesGems`
+      # indexes those sources and restores the check.
+      #
       # Names that appear as symbols or inside string literals in the same
       # file are never reported, since they usually belong to runtime
       # definitions the index cannot see (`stub_const`, `const_set`,
@@ -129,26 +136,61 @@ module RuboCop
         end
 
         def constant_typo_suggestion(node)
-          return nil if literal_names.include?(node.short_name.to_s)
-
           namespace = resolve_constant_in_index(node.namespace)
           return nil unless namespace.is_a?(Rubydex::Namespace)
           return nil if namespace.find_member(node.short_name.to_s)
+          return nil unless complete_index_members?(namespace)
+          return nil if literal_names.include?(node.short_name.to_s)
 
           spell_check(node.short_name, constant_member_names(namespace))
         rescue StandardError
           nil
         end
 
+        # Whether the index can be trusted to list everything the namespace
+        # defines. A name missing from an incomplete member list is not
+        # evidence of a typo, so both gaps have to be ruled out first:
+        # an ancestor that does not resolve may contribute the name, and so
+        # may a gem that reopens the namespace.
+        def complete_index_members?(declaration)
+          fully_resolved_index_ancestry?(declaration) && !gem_owned_namespace?(declaration)
+        end
+
+        # Whether the namespace's root segment names a gem in the bundle,
+        # which is then free to define members the index never sees: gem
+        # sources are only indexed when `AllCops/ProjectIndexIncludesGems`
+        # is enabled. A project that reopens such a namespace to add its own
+        # members (`module Flipper; module Adapters; ...`) makes it resolve
+        # in the index while most of what it holds stays invisible.
+        def gem_owned_namespace?(declaration)
+          return false if config.for_all_cops['ProjectIndexIncludesGems']
+
+          root = declaration.name.to_s.split('::').first.to_s
+          bundled_gem_namespaces.include?(root.downcase)
+        end
+
+        # Gem names normalized towards the constant they conventionally
+        # provide: `flipper` for `Flipper`, `activerecord` for `ActiveRecord`.
+        def bundled_gem_namespaces
+          @bundled_gem_namespaces ||= bundled_gem_names.to_set { |name| name.delete('-_').downcase }
+        end
+
+        # The bundle's gems except those sourced from a local path, whose code
+        # lives in the project and is indexed like the rest of it — among them
+        # the project's own gem, which its lockfile lists in the `PATH` section.
+        def bundled_gem_names
+          (config.gem_versions_in_target || {}).keys - (config.path_sourced_gems_in_target || [])
+        end
+
         # Writers are indexed under the reader's name, so setter calls are
         # verified and spell-checked through the base name.
         def method_typo_suggestion(node)
           setter = setter_call?(node)
           base = setter ? node.method_name.to_s.delete_suffix('=') : node.method_name.to_s
-          return nil if literal_names.include?(base)
 
           declaration = unknown_method_owner(node, base)
           return nil unless declaration
+          return nil if literal_names.include?(base)
 
           suggestion = spell_check(base, method_member_names(declaration))
           suggestion && setter ? "#{suggestion}=" : suggestion
@@ -156,13 +198,15 @@ module RuboCop
           nil
         end
 
-        # The receiver's declaration when it resolves in the index, its whole
-        # ancestry is resolved, and the method is not found — nil otherwise.
+        # The receiver's declaration when it resolves in the index, everything
+        # it can inherit or be reopened with is visible there, and the method
+        # is not found — nil otherwise.
         def unknown_method_owner(node, base)
           declaration = resolve_constant_in_index(node.receiver)
           return nil unless declaration.is_a?(Rubydex::Namespace)
           return nil if responds_in_index?(declaration, node.method_name.to_s, base)
           return nil unless fully_resolved_index_ancestry?(declaration)
+          return nil if gem_owned_namespace?(declaration)
 
           declaration
         end
@@ -191,7 +235,10 @@ module RuboCop
               if literal.sym_type?
                 names << literal.value.to_s
               else
-                literal.value.scan(LITERAL_IDENTIFIER_PATTERN) { |token| names << token }
+                # `scan` raises on binary string literals with invalid byte sequences.
+                value = literal.value
+                value = value.scrub unless value.valid_encoding?
+                value.scan(LITERAL_IDENTIFIER_PATTERN) { |token| names << token }
               end
             end
         end

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

@@ -53,6 +53,8 @@ module RuboCop
         end
 
         def after_send(node)
+          return if backrefs_unaffected?(node)
+
           @valid_ref = nil
 
           if regexp_first_argument?(node)
@@ -111,6 +113,19 @@ module RuboCop
                        end
         end
 
+        # A call such as `hash[:key]` or `array[0]` cannot involve a regexp match:
+        # a non-string literal cannot act as a pattern (whereas `sub`, `gsub`,
+        # and `match` treat a string one as a pattern and do set backreferences),
+        # and `$~` is frame-local, so a user-defined method cannot change
+        # the caller's backreferences either.
+        def backrefs_unaffected?(send_node)
+          first_argument = send_node.first_argument
+          return false unless first_argument&.basic_literal?
+          return false if first_argument.str_type?
+
+          !regexp_receiver?(send_node)
+        end
+
         def regexp_first_argument?(send_node)
           send_node.first_argument&.regexp_type? \
             && REGEXP_ARGUMENT_METHODS.include?(send_node.method_name)

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

@@ -2,7 +2,7 @@
 
 # The Lint/RedundantCopDisableDirective cop needs to be disabled so as
 # to be able to provide a (bad) example of a redundant disable.
-# rubocop:disable Lint/RedundantCopDisableDirective
+# rubocop:disable-next Lint/RedundantCopDisableDirective
 module RuboCop
   module Cop
     module Lint
@@ -104,17 +104,35 @@ module RuboCop
         end
 
         def each_redundant_disable(&block)
+          each_detached_next_directive(&block)
+
           cop_disabled_line_ranges.each do |cop, line_ranges|
+            # A pending cop that is not enabled in this run produces no
+            # offenses, so its directives cannot be judged - they typically
+            # prepare the code for the moment the cop gets enabled.
+            next if pending_cop_not_run?(cop)
+
             each_already_disabled(cop, line_ranges, &block)
             each_line_range(cop, line_ranges, &block)
           end
         end
 
+        def pending_cop_not_run?(cop)
+          # `Config#for_cop` corrects wrongly-namespaced names, but a name that
+          # is not registered as written never suppresses anything, so it is
+          # reported as unknown rather than exempted via the corrected cop.
+          return false unless all_cop_names.include?(cop)
+
+          cop_cfg = config.for_cop(cop)
+          cop_cfg['Enabled'] == 'pending' &&
+            !processed_source.registry.enabled_pending_cop?(cop_cfg, config, cop)
+        end
+
         def each_line_range(cop, line_ranges)
           line_ranges.each_with_index do |line_range, line_range_index|
             next if should_skip_line_range?(cop, line_range)
 
-            comment = processed_source.comment_at_line(line_range.begin)
+            comment = directive_comment(line_range)
             next if skip_directive?(comment)
 
             next_range = line_ranges[line_range_index + 1]
@@ -127,6 +145,24 @@ module RuboCop
           ignore_offense?(line_range) || expected_final_disable?(cop, line_range)
         end
 
+        # A range opened by a `disable-next` directive starts at the statement,
+        # not at the directive comment above it, so ask the range itself.
+        def directive_comment(line_range)
+          if line_range.respond_to?(:directive)
+            line_range.directive.comment
+          else
+            processed_source.comment_at_line(line_range.begin)
+          end
+        end
+
+        # A `disable-next` with no statement attached (or misplaced at the end
+        # of a code line) suppresses nothing, so it is redundant by definition.
+        def each_detached_next_directive
+          processed_source.comment_config.detached_next_directives.each do |directive|
+            directive.raw_cop_names.each { |cop| yield directive.comment, cop }
+          end
+        end
+
         def skip_directive?(comment)
           directive = DirectiveComment.new(comment)
           directive.push? || directive.pop?
@@ -142,7 +178,7 @@ module RuboCop
           end
         end
 
-        # rubocop:disable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+        # rubocop:disable-next Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
         def each_already_disabled(cop, line_ranges)
           line_ranges.each_cons(2) do |previous_range, range|
             next if ignore_offense?(range)
@@ -152,7 +188,7 @@ module RuboCop
             # whether there are offenses or not.
             next unless followed_ranges?(previous_range, range)
 
-            comment = processed_source.comment_at_line(range.begin)
+            comment = directive_comment(range)
 
             next unless comment
             # Comments disabling all cops don't count since it's reasonable
@@ -170,7 +206,6 @@ module RuboCop
             yield comment, redundant if redundant
           end
         end
-        # rubocop:enable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
 
         def find_redundant_cop(cop, range)
           cop_offenses = offenses_to_check.select { |offense| offense.cop_name == cop }
@@ -198,7 +233,11 @@ module RuboCop
         end
 
         def range_with_offense?(range, offenses = offenses_to_check)
-          offenses.none? { |offense| range.cover?(offense.line) }
+          # An offense is covered when the disabled range overlaps any line of
+          # its span, mirroring how offenses are suppressed.
+          offenses.none? do |offense|
+            offense.line <= range.end && offense.location.last_line >= range.begin
+          end
         end
 
         def all_disabled?(comment)
@@ -244,14 +283,28 @@ module RuboCop
           location = DirectiveComment.new(comment).range
           cop_names = cops.sort.map { |c| describe(c) }.join(', ')
 
+          # An unknown cop may just not be loaded in this run (e.g. a custom
+          # cop whose configuration failed to load) - removing its directive
+          # would destroy something that cannot be restored, so only report.
+          # A misplaced EOL `disable-next` should be moved, not deleted.
+          if any_unknown_cop?(cops) || misplaced_next_directive?(comment)
+            return add_offense(location, message: message(cop_names))
+          end
+
           add_offense(location, message: message(cop_names)) do |corrector|
-            range = comment_range_with_surrounding_space(location, comment.source_range)
+            remove_entire_comment(corrector, comment)
+          end
+        end
 
-            if leave_free_comment?(comment, range)
-              corrector.replace(range, ' # ')
-            else
-              corrector.remove(range)
-            end
+        def remove_entire_comment(corrector, comment)
+          # Take the `--` reason with the directive; `leave_free_comment?` keeps anything else.
+          directive_range = DirectiveComment.new(comment).range_with_reason
+          range = comment_range_with_surrounding_space(directive_range, comment.source_range)
+
+          if leave_free_comment?(comment, range)
+            corrector.replace(range, ' # ')
+          else
+            corrector.remove(range)
           end
         end
 
@@ -261,14 +314,35 @@ module RuboCop
           ranges = cop_ranges.map { |_, r| r }
 
           cop_ranges.each do |cop, range|
-            cop_name = describe(cop)
-            add_offense(range, message: message(cop_name)) do |corrector|
-              range = directive_range_in_list(range, ranges)
-              corrector.remove(range)
-            end
+            add_offense_for_cop_in_list(cop, range, ranges)
+          end
+        end
+
+        def add_offense_for_cop_in_list(cop, range, ranges)
+          cop_name = describe(cop)
+          return add_offense(range, message: message(cop_name)) if unknown_cop?(cop)
+
+          add_offense(range, message: message(cop_name)) do |corrector|
+            corrector.remove(directive_range_in_list(range, ranges))
           end
         end
 
+        def any_unknown_cop?(cops)
+          cops.any? { |cop| unknown_cop?(cop) }
+        end
+
+        def misplaced_next_directive?(comment)
+          directive = DirectiveComment.new(comment)
+          directive.disable_next? &&
+            !processed_source.comment_config.comment_only_line?(directive.line_number)
+        end
+
+        def unknown_cop?(cop)
+          return false if cop == 'all' || department_marker?(cop)
+
+          !all_cop_names.include?(cop)
+        end
+
         def leave_free_comment?(comment, range)
           free_comment = comment.text.gsub(range.source.strip, '')
 
@@ -303,7 +377,13 @@ module RuboCop
 
         SIMILAR_COP_NAMES_CACHE = Hash.new do |hash, cop_name|
           hash[:all_cop_names] = Registry.global.names unless hash.key?(:all_cop_names)
-          hash[cop_name] = NameSimilarity.find_similar_name(cop_name, hash[:all_cop_names])
+          # A registered cop with the same base name is a better suggestion
+          # than anything spelling similarity can find - the most common
+          # mistake is qualifying a cop with the wrong department.
+          basename = "/#{cop_name.split('/').last}"
+          same_basename = hash[:all_cop_names].find { |name| name.end_with?(basename) }
+          hash[cop_name] =
+            same_basename || NameSimilarity.find_similar_name(cop_name, hash[:all_cop_names])
         end
         private_constant :SIMILAR_COP_NAMES_CACHE
 
@@ -344,4 +424,3 @@ module RuboCop
     end
   end
 end
-# rubocop:enable Lint/RedundantCopDisableDirective

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

@@ -30,21 +30,55 @@ module RuboCop
       #   foo = "1"
       #   # rubocop:enable all
       #   baz
+      #
+      #   # bad
+      #   foo = 1
+      #   # rubocop:pop
+      #
+      #   # good
+      #   # rubocop:push -Style/StringLiterals
+      #   foo = "1"
+      #   # rubocop:pop
       class RedundantCopEnableDirective < Base
         include RangeHelp
         include SurroundingSpace
         extend AutoCorrector
 
         MSG = 'Unnecessary enabling of %<cop>s.'
+        MSG_ORPHAN_POP = 'Unnecessary `rubocop:pop` without a matching `rubocop:push`.'
 
         def on_new_investigation
-          return if processed_source.blank? || !processed_source.raw_source.include?('enable')
+          return if processed_source.blank?
 
+          source = processed_source.raw_source
+          check_extra_enables if source.include?('enable')
+          check_orphan_pops if source.include?('pop')
+        end
+
+        private
+
+        def check_extra_enables
           offenses = processed_source.comment_config.extra_enabled_comments
           offenses.each { |comment, cop_names| register_offense(comment, cop_names) }
         end
 
-        private
+        def check_orphan_pops
+          push_depth = 0
+          processed_source.comments.each do |comment|
+            directive = DirectiveComment.new(comment)
+            if directive.push?
+              push_depth += 1
+            elsif directive.pop?
+              push_depth.zero? ? register_orphan_pop(directive) : push_depth -= 1
+            end
+          end
+        end
+
+        def register_orphan_pop(directive)
+          add_offense(directive.range, message: MSG_ORPHAN_POP) do |corrector|
+            corrector.remove(range_with_surrounding_space(directive.range, side: :right))
+          end
+        end
 
         def register_offense(comment, cop_names)
           directive = DirectiveComment.new(comment)
@@ -55,15 +89,21 @@ module RuboCop
               range_of_offense(comment, name),
               message: format(MSG, cop: all_or_name(name))
             ) do |corrector|
-              if directive.match?(cop_names)
-                corrector.remove(range_with_surrounding_space(directive.range, side: :right))
-              else
-                corrector.remove(range_with_comma(comment, name))
-              end
+              corrector.remove(removal_range(directive, comment, cop_names, name))
             end
           end
         end
 
+        # When every cop on the directive is redundant the whole comment goes, `--` reason
+        # included; otherwise just the one cop is spliced out of the list.
+        def removal_range(directive, comment, cop_names, name)
+          if directive.match?(cop_names)
+            range_with_surrounding_space(directive.range_with_reason, side: :right)
+          else
+            range_with_comma(comment, name)
+          end
+        end
+
         def range_of_offense(comment, name)
           start_pos = comment_start(comment) + cop_name_indention(comment, name)
           range_between(start_pos, start_pos + name.size)

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

@@ -63,7 +63,7 @@ module RuboCop
 
         private
 
-        # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+        # rubocop:disable-next Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
         def redundant_feature?(feature_name)
           feature_name == 'enumerator' ||
             (target_ruby_version >= 2.1 && feature_name == 'thread') ||
@@ -73,7 +73,6 @@ module RuboCop
             (target_ruby_version >= 3.2 && feature_name == 'set') ||
             (target_ruby_version >= 4.0 && feature_name == 'pathname')
         end
-        # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
       end
     end
   end

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

@@ -208,7 +208,7 @@ module RuboCop
           add_offense(range) { |corrector| corrector.replace(range, '.') }
         end
 
-        # rubocop:disable Metrics/AbcSize
+        # rubocop:disable-next Metrics/AbcSize
         def on_or(node)
           conversion_with_default?(node) do |send_node|
             range = send_node.loc.dot.begin.join(node.source_range.end)
@@ -221,7 +221,6 @@ module RuboCop
             end
           end
         end
-        # rubocop:enable Metrics/AbcSize
 
         private
 

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

@@ -139,7 +139,7 @@ module RuboCop
           grandparent.array_type? && grandparent.children.size > 1
         end
 
-        # rubocop:disable Metrics/AbcSize
+        # rubocop:disable-next Metrics/AbcSize
         def replacement_range_and_content(node)
           variable = node.children.first
           expression = node.source_range
@@ -157,7 +157,6 @@ module RuboCop
             [node.loc.operator, '']
           end
         end
-        # rubocop:enable Metrics/AbcSize
 
         def array_splat?(node)
           node.children.first.array_type?

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

@@ -192,7 +192,7 @@ module RuboCop
           (hash (pair (sym :exception) false))
         PATTERN
 
-        # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity
+        # rubocop:disable-next Metrics/AbcSize, Metrics/CyclomaticComplexity
         def on_send(node)
           return if node.arguments.any? || hash_or_set_with_block?(node)
 
@@ -208,7 +208,6 @@ module RuboCop
             corrector.remove(node.loc.dot.join(node.loc.end || node.loc.selector))
           end
         end
-        # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity
         alias on_csend on_send
 
         private

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

@@ -33,7 +33,7 @@ module RuboCop
         MSG_EACH_WITH_INDEX = 'Use `each` instead of `each_with_index`.'
         MSG_WITH_INDEX = 'Remove redundant `with_index`.'
 
-        # rubocop:disable Metrics/AbcSize
+        # rubocop:disable-next Metrics/AbcSize
         def on_block(node)
           return unless node.receiver
           return if node.method?(:with_index) && !node.receiver.receiver
@@ -50,7 +50,6 @@ module RuboCop
             end
           end
         end
-        # rubocop:enable Metrics/AbcSize
 
         alias on_numblock on_block
         alias on_itblock on_block

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

@@ -45,7 +45,7 @@ module RuboCop
           }
         PATTERN
 
-        # rubocop:disable Metrics/AbcSize
+        # rubocop:disable-next Metrics/AbcSize
         def on_send(node)
           return unless require_safe_navigation?(node)
 
@@ -63,7 +63,6 @@ module RuboCop
             end
           end
         end
-        # rubocop:enable Metrics/AbcSize
 
         private
 

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

@@ -85,7 +85,7 @@ module RuboCop
           end
         end
 
-        # rubocop:disable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+        # rubocop:disable-next Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
         def find_consistent_parts(grouped_operands)
           csend_in_and, csend_in_or, send_in_and, send_in_or = most_left_indices(grouped_operands)
 
@@ -99,7 +99,6 @@ module RuboCop
             ['.', csend_in_or]
           end
         end
-        # rubocop:enable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
 
         def already_appropriate_call?(operand, dot_op)
           return true if operand.safe_navigation? && dot_op == '&.'
@@ -126,7 +125,7 @@ module RuboCop
           end
         end
 
-        # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+        # rubocop:disable-next Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
         def most_left_indices(grouped_operands)
           indices = { csend_in_and: nil, csend_in_or: nil, send_in_and: nil, send_in_or: nil }
 
@@ -139,7 +138,6 @@ module RuboCop
 
           indices.values
         end
-        # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
 
         def operand_in_and?(node)
           return true if node.parent.and_type?