rubocop 1.89.0 → 1.91.0

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

@@ -24,7 +24,7 @@ module RuboCop
         MSG = 'Literal interpolation detected.'
         COMPOSITE = %i[array hash pair irange erange].freeze
 
-        # rubocop:disable Metrics/AbcSize
+        # rubocop:disable-next Metrics/AbcSize
         def on_interpolation(begin_node)
           final_node = begin_node.children.last
           return unless offending?(final_node)
@@ -50,7 +50,6 @@ module RuboCop
             corrector.replace(final_node.parent, replacement)
           end
         end
-        # rubocop:enable Metrics/AbcSize
 
         private
 
@@ -74,7 +73,7 @@ module RuboCop
           node.array_type? && grandparent.regexp_type?
         end
 
-        # rubocop:disable Metrics/MethodLength, Metrics/CyclomaticComplexity
+        # rubocop:disable-next Metrics/MethodLength, Metrics/CyclomaticComplexity
         def autocorrected_value(node)
           case node.type
           when :int
@@ -95,7 +94,6 @@ module RuboCop
             node.source.gsub('"', '\"')
           end
         end
-        # rubocop:enable Metrics/MethodLength, Metrics/CyclomaticComplexity
 
         def handle_special_regexp_chars(begin_node, value)
           parent_node = begin_node.parent
@@ -155,7 +153,7 @@ module RuboCop
           "{#{hash_string}}"
         end
 
-        # rubocop:disable Metrics/MethodLength, Metrics/AbcSize
+        # rubocop:disable-next Metrics/MethodLength, Metrics/AbcSize
         def autocorrected_value_in_hash(node)
           case node.type
           when :int
@@ -174,7 +172,6 @@ module RuboCop
             node.source.gsub('"', '\"')
           end
         end
-        # rubocop:enable Metrics/MethodLength, Metrics/AbcSize
 
         # Does node print its own source when converted to a string?
         def prints_as_self?(node)

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

@@ -0,0 +1,185 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # Checks for magic comments placed where Ruby silently ignores them.
+      #
+      # The `encoding` magic comment is only honored on the first line of a file,
+      # or on the second line when the first line is a shebang. Anywhere else it
+      # is silently ignored - even directly below another comment or a blank line.
+      #
+      # Other magic comments (such as `frozen_string_literal`) are honored
+      # anywhere before the first token of code, but are ignored after any code,
+      # with a warning emitted only when running Ruby with `-w`.
+      #
+      # A magic comment misplaced ahead of a shebang also renders the shebang
+      # ineffective, since a shebang is only recognized on the first line.
+      #
+      # NOTE: An `encoding` comment that is only preceded by other magic
+      # comments is not flagged by this cop; that case is handled by
+      # `Lint/OrderedMagicComments`. `shareable_constant_value` is never
+      # flagged, as Ruby intentionally allows it mid-file with block scoping.
+      #
+      # @safety
+      #   This cop's autocorrection is unsafe because moving the magic comment
+      #   to its effective position activates it, which changes runtime
+      #   behavior (e.g. the source encoding or string mutability).
+      #
+      # @example
+      #   # bad
+      #   # Documentation comment
+      #   # encoding: ascii-8bit
+      #   puts 'hello'
+      #
+      #   # good
+      #   # encoding: ascii-8bit
+      #   # Documentation comment
+      #   puts 'hello'
+      #
+      #   # bad
+      #   require 'foo'
+      #   # frozen_string_literal: true
+      #
+      #   # good
+      #   # frozen_string_literal: true
+      #   require 'foo'
+      #
+      #   # bad
+      #   # frozen_string_literal: true
+      #   #!/usr/bin/env ruby
+      #   puts 'hello'
+      #
+      #   # good
+      #   #!/usr/bin/env ruby
+      #   # frozen_string_literal: true
+      #   puts 'hello'
+      class MisplacedMagicComment < Base
+        include RangeHelp
+        extend AutoCorrector
+
+        MSG_ENCODING = 'The `encoding` magic comment is ignored unless placed on the first ' \
+                       'line (or below a shebang on the first line).'
+        MSG_AFTER_CODE = 'The `%<directive>s` magic comment is ignored after any code.'
+        MSG_ABOVE_SHEBANG = 'A magic comment above a shebang renders the shebang ineffective.'
+
+        def on_new_investigation
+          return if processed_source.buffer.source.empty?
+
+          check_magic_comment_above_shebang
+          processed_source.comments.each { |comment| check_comment(comment) }
+        end
+
+        private
+
+        def check_comment(comment)
+          return unless magic_comment_shaped?(comment.text)
+
+          magic_comment = MagicComment.parse(comment.text)
+          return unless magic_comment.valid?
+
+          if magic_comment.encoding_specified?
+            return unless known_encoding?(magic_comment.encoding)
+
+            check_encoding_comment(comment)
+          elsif magic_comment.frozen_string_literal_specified?
+            check_top_block_comment(comment, 'frozen_string_literal')
+          end
+        end
+
+        # The Emacs and Vim regexps in `MagicComment` match anywhere inside a
+        # comment, which would flag documentation that merely quotes a magic
+        # comment (e.g. `#   # -*- coding: UTF-8 -*-`). Require the magic
+        # comment to start right after the `#`.
+        def magic_comment_shaped?(text)
+          /\A#(?![^#]*#)/.match?(text)
+        end
+
+        # Prose that happens to open with `Encoding:` parses as an encoding
+        # comment (`# Encoding: force given encoding` yields `force`). Ruby
+        # ignores a misplaced encoding comment entirely, so a name no encoding
+        # answers to means the line is a comment, not a directive.
+        def known_encoding?(name)
+          Encoding.find(name)
+          true
+        rescue ArgumentError
+          false
+        end
+
+        def shebang?
+          processed_source.lines.first.to_s.start_with?('#!')
+        end
+
+        # First line that may carry an effective encoding comment.
+        def effective_encoding_line
+          shebang? ? 2 : 1
+        end
+
+        def first_code_token
+          @first_code_token ||= processed_source.sorted_tokens.find { |token| !token.comment? }
+        end
+
+        def check_encoding_comment(comment)
+          line = comment.source_range.line
+          return if line == effective_encoding_line && comment_starts_line?(comment)
+          # Leave `# frozen_string_literal: true` + `# encoding: x` runs at the
+          # very top to Lint/OrderedMagicComments, which already reorders them.
+          return if preceded_only_by_magic_comments?(comment)
+
+          add_offense(comment, message: MSG_ENCODING) do |corrector|
+            move_comment(corrector, comment, effective_encoding_line)
+          end
+        end
+
+        def check_top_block_comment(comment, directive)
+          return unless first_code_token
+          return unless comment.source_range.begin_pos > first_code_token.begin_pos
+
+          message = format(MSG_AFTER_CODE, directive: directive)
+          add_offense(comment, message: message) do |corrector|
+            move_comment(corrector, comment, effective_encoding_line)
+          end
+        end
+
+        def check_magic_comment_above_shebang
+          shebang_comment = processed_source.comments.find do |comment|
+            comment.source_range.line > 1 && comment.text.start_with?('#!') &&
+              comment.source_range.column.zero?
+          end
+          return unless shebang_comment
+          # Only flag when what precedes the shebang is magic comments -
+          # a `#!` comment deep inside a file is not an intended shebang.
+          return unless preceded_only_by_magic_comments?(shebang_comment)
+
+          add_offense(shebang_comment, message: MSG_ABOVE_SHEBANG)
+        end
+
+        def preceded_only_by_magic_comments?(comment)
+          (1...comment.source_range.line).all? do |line_number|
+            text = processed_source.lines[line_number - 1]
+            (line_number == 1 && text.start_with?('#!')) || MagicComment.parse(text).valid?
+          end
+        end
+
+        def comment_starts_line?(comment)
+          processed_source.lines[comment.source_range.line - 1].lstrip.start_with?('#')
+        end
+
+        def move_comment(corrector, comment, target_line)
+          removal_range = if comment_starts_line?(comment)
+                            range_by_whole_lines(comment.source_range, include_final_newline: true)
+                          else
+                            range_with_surrounding_space(comment.source_range, side: :left)
+                          end
+          corrector.remove(removal_range)
+          target_range = processed_source.buffer.line_range(target_line)
+          if comment.source_range.line < target_line
+            corrector.insert_after(target_range, "\n#{comment.text}")
+          else
+            corrector.insert_before(target_range, "#{comment.text}\n")
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-# rubocop:disable Lint/RedundantCopDisableDirective
+# rubocop:disable-next Lint/RedundantCopDisableDirective -- the examples below read as real directives
 module RuboCop
   module Cop
     module Lint
@@ -55,7 +55,7 @@ module RuboCop
       class MissingCopEnableDirective < Base
         include RangeHelp
 
-        MSG = 'Re-enable %<cop>s %<type>s with `# rubocop:enable` after disabling it.'
+        MSG = 'Re-enable %<cop>s %<type>s with `%<directive>s` after disabling it.'
         MSG_BOUND = 'Re-enable %<cop>s %<type>s within %<max_range>s lines after disabling it.'
 
         def on_new_investigation
@@ -72,7 +72,12 @@ module RuboCop
 
         def each_missing_enable
           processed_source.disabled_line_ranges.each do |cop, line_ranges|
-            line_ranges.each { |line_range| yield cop, line_range }
+            line_ranges.each do |line_range|
+              # A `disable-next` scope closes itself with its statement.
+              next if line_range.respond_to?(:directive) && line_range.directive.disable_next?
+
+              yield cop, line_range
+            end
           end
         end
 
@@ -80,17 +85,22 @@ module RuboCop
           # This has to remain a strict inequality to handle
           # the case when max_range is Float::INFINITY
           return true if line_range.max - line_range.min < max_range + 2
+          # A name that is not registered as written (e.g. a wrongly-namespaced
+          # cop) suppresses nothing; `Lint/RedundantCopDisableDirective` reports
+          # it, so demanding its re-enablement would only add noise.
+          return true unless Registry.global.names.include?(cop)
+
+          expected_open_range?(cop, line_range)
+        end
+
+        def expected_open_range?(cop, line_range)
           # This cop is disabled in the config, it is not expected to be re-enabled
           return true if line_range.min == CommentConfig::CONFIG_DISABLED_LINE_RANGE_MIN
 
-          cop_class = RuboCop::Cop::Registry.global.find_by_cop_name cop
-          if cop_class &&
+          cop_class = RuboCop::Cop::Registry.global.find_by_cop_name(cop)
+          !!(cop_class &&
              !processed_source.registry.enabled?(cop_class, config) &&
-             line_range.max == Float::INFINITY
-            return true
-          end
-
-          false
+             line_range.max == Float::INFINITY)
         end
 
         def max_range
@@ -98,13 +108,17 @@ module RuboCop
         end
 
         def message(cop, comment, type = 'cop')
+          directive = DirectiveComment.new(comment)
           if department_enabled?(cop, comment)
             type = 'department'
             cop = cop.split('/').first
           end
 
           if max_range == Float::INFINITY
-            format(MSG, cop: cop, type: type)
+            # A range opened by `rubocop:push` is closed by `rubocop:pop`,
+            # not by `rubocop:enable`.
+            enabling_directive = directive.push? ? '# rubocop:pop' : '# rubocop:enable'
+            format(MSG, cop: cop, type: type, directive: enabling_directive)
           else
             format(MSG_BOUND, cop: cop, type: type, max_range: max_range)
           end
@@ -117,4 +131,3 @@ module RuboCop
     end
   end
 end
-# rubocop:enable Lint/RedundantCopDisableDirective

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/nested_method_definition.rb

@@ -95,7 +95,7 @@ module RuboCop
         MSG = 'Method definitions must not be nested. Use `lambda` instead.'
 
         def on_def(node)
-          subject, = *node # rubocop:disable InternalAffairs/NodeDestructuring
+          subject, = *node # rubocop:disable InternalAffairs/NodeDestructuring -- the first child differs between `def` and `defs`
           return if node.defs_type? && allowed_subject_type?(subject)
 
           def_ancestor = node.each_ancestor(:any_def).first

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

@@ -67,7 +67,7 @@ module RuboCop
 
         # NOTE: itblock is not handled because this cop is limited to Ruby <= 2.7
         # via `maximum_target_ruby_version`, so itblock nodes (Ruby 3.4+) are never encountered.
-        def on_block(node) # rubocop:disable InternalAffairs/ItblockHandler
+        def on_block(node) # rubocop:disable InternalAffairs/ItblockHandler -- limited to Ruby <= 2.7, where `it` blocks do not exist
           return unless node.body
           return unless unsorted_dir_loop?(node.send_node)
 

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/parentheses_as_grouped_expression.rb

@@ -46,13 +46,29 @@ module RuboCop
 
         def valid_first_argument?(first_arg)
           first_arg.operator_keyword? || first_arg.hash_type? || ternary_expression?(first_arg) ||
-            compound_range?(first_arg)
+            compound_range?(first_arg) || invalid_bare_argument?(first_arg)
         end
 
         def compound_range?(first_arg)
           first_arg.range_type? && first_arg.parenthesized_call?
         end
 
+        def invalid_bare_argument?(node)
+          node = node.children.first while node&.begin_type? && node.children.one?
+          return false unless node
+
+          keyword_operator?(node) || modifier_expression?(node)
+        end
+
+        def keyword_operator?(node)
+          (node.operator_keyword? && node.semantic_operator?) ||
+            node.rescue_type? || (node.send_type? && node.prefix_not?)
+        end
+
+        def modifier_expression?(node)
+          node.type?(:if, :while, :until) && node.modifier_form?
+        end
+
         def chained_calls?(node)
           first_argument = node.first_argument
           first_argument.call_type? && (node.children.last&.children&.count || 0) > 1