rubocop 1.71.1 → 1.92.0

data/lib/rubocop/cop/naming/{predicate_name.rb → predicate_prefix.rb}

@@ -17,6 +17,15 @@ module RuboCop
       # they end with a `?`. These methods should be changed to remove the
       # prefix.
       #
+      # When `UseSorbetSigs` is set to true (optional), the cop will only report
+      # offenses if the method has a Sorbet `sig` with a return type of
+      # `T::Boolean`. Dynamic methods are not supported with this configuration.
+      #
+      # When `AllCops/UseProjectIndex` is enabled and the `rubydex` gem is
+      # installed, methods that override a method defined by an ancestor
+      # elsewhere in the project are not reported, since renaming an override
+      # breaks the inherited contract.
+      #
       # @example NamePrefix: ['is_', 'has_', 'have_'] (default)
       #   # bad
       #   def is_even(value)
@@ -58,6 +67,30 @@ module RuboCop
       #   def is_even?(value)
       #   end
       #
+      # @example UseSorbetSigs: false (default)
+      #   # bad
+      #   sig { returns(String) }
+      #   def is_this_thing_on
+      #     "yes"
+      #   end
+      #
+      #   # good - Sorbet signature is not evaluated
+      #   sig { returns(String) }
+      #   def is_this_thing_on?
+      #     "yes"
+      #   end
+      #
+      # @example UseSorbetSigs: true
+      #   # bad
+      #   sig { returns(T::Boolean) }
+      #   def odd(value)
+      #   end
+      #
+      #   # good
+      #   sig { returns(T::Boolean) }
+      #   def odd?(value)
+      #   end
+      #
       # @example MethodDefinitionMacros: ['define_method', 'define_singleton_method'] (default)
       #   # bad
       #   define_method(:is_even) { |value| }
@@ -72,12 +105,13 @@ module RuboCop
       #   # good
       #   def_node_matcher(:even?) { |value| }
       #
-      class PredicateName < Base
+      class PredicatePrefix < Base
+        include ProjectIndexHelp
         include AllowedMethods
 
         # @!method dynamic_method_define(node)
         def_node_matcher :dynamic_method_define, <<~PATTERN
-          (send nil? #method_definition_macros
+          (send nil? #method_definition_macro?
             (sym $_)
             ...)
         PATTERN
@@ -96,17 +130,18 @@ module RuboCop
         end
 
         def on_def(node)
-          predicate_prefixes.each do |prefix|
-            method_name = node.method_name.to_s
-
-            next if allowed_method_name?(method_name, prefix)
+          method_name = node.method_name.to_s
+          offending_prefixes = offending_prefixes_for(node, method_name)
+          return if offending_prefixes.empty? || overrides_inherited_method?(node)
 
+          offending_prefixes.each do |prefix|
             add_offense(
               node.loc.name,
               message: message(method_name, expected_name(method_name, prefix))
             )
           end
         end
+
         alias on_defs on_def
 
         def validate_config
@@ -114,13 +149,31 @@ module RuboCop
             next if predicate_prefixes.include?(forbidden_prefix)
 
             raise ValidationError, <<~MSG.chomp
-              The `Naming/PredicateName` cop is misconfigured. Prefix #{forbidden_prefix} must be included in NamePrefix because it is included in ForbiddenPrefixes.
+              The `Naming/PredicatePrefix` cop is misconfigured. Prefix #{forbidden_prefix} must be included in NamePrefix because it is included in ForbiddenPrefixes.
             MSG
           end
         end
 
         private
 
+        def offending_prefixes_for(node, method_name)
+          prefixes = predicate_prefixes.reject { |p| allowed_method_name?(method_name, p) }
+          return prefixes if prefixes.empty? || !use_sorbet_sigs?
+
+          sorbet_sig?(node, return_type: 'T::Boolean') ? prefixes : []
+        end
+
+        # @!method sorbet_return_type(node)
+        def_node_matcher :sorbet_return_type, <<~PATTERN
+          (block (send nil? :sig) args (send _ :returns $_type))
+        PATTERN
+
+        def sorbet_sig?(node, return_type: nil)
+          return false unless (type = sorbet_return_type(node.left_sibling))
+
+          type.source == return_type
+        end
+
         def allowed_method_name?(method_name, prefix)
           !(method_name.start_with?(prefix) && # cheap check to avoid allocating Regexp
               method_name.match?(/^#{prefix}[^0-9]/)) ||
@@ -151,7 +204,11 @@ module RuboCop
           cop_config['NamePrefix']
         end
 
-        def method_definition_macros(macro_name)
+        def use_sorbet_sigs?
+          cop_config['UseSorbetSigs']
+        end
+
+        def method_definition_macro?(macro_name)
           cop_config['MethodDefinitionMacros'].include?(macro_name.to_s)
         end
       end

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Naming
-      # Makes sure that rescued exceptions variables are named as
+      # Makes sure that rescued exception variables are named as
       # expected.
       #
       # The `PreferredName` config option takes a `String`. It represents
@@ -95,11 +95,14 @@ module RuboCop
 
         def autocorrect(corrector, node, range, offending_name, preferred_name)
           corrector.replace(range, preferred_name)
-          correct_node(corrector, node.body, offending_name, preferred_name)
+          # Once the exception variable is reassigned, later references point to a
+          # different value, so stop correcting after the reassignment - both in the
+          # body and in the code following the `begin`/`rescue`.
+          return if correct_node(corrector, node.body, offending_name, preferred_name)
           return unless (kwbegin_node = node.parent.each_ancestor(:kwbegin).first)
 
           kwbegin_node.right_siblings.each do |child_node|
-            correct_node(corrector, child_node, offending_name, preferred_name)
+            break if correct_node(corrector, child_node, offending_name, preferred_name)
           end
         end
 
@@ -113,7 +116,9 @@ module RuboCop
           end
         end
 
-        # rubocop:disable Metrics/MethodLength
+        # Returns the reassignment node once the exception variable is reassigned (a truthy
+        # signal to stop correcting later references), or `nil` when no reassignment is found.
+        # rubocop:disable-next Metrics/MethodLength
         def correct_node(corrector, node, offending_name, preferred_name)
           return unless node
 
@@ -131,11 +136,11 @@ module RuboCop
 
             if child_node.type?(:masgn, :lvasgn)
               correct_reassignment(corrector, child_node, offending_name, preferred_name)
-              break
+              return child_node
             end
           end
+          nil
         end
-        # rubocop:enable Metrics/MethodLength
 
         # If the exception variable is reassigned, that assignment needs to be corrected.
         # Further `lvar` nodes will not be corrected though since they now refer to a

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

@@ -3,8 +3,15 @@
 module RuboCop
   module Cop
     module Naming
-      # Makes sure that all variables use the configured style,
-      # snake_case or camelCase, for their names.
+      # Checks that the configured style (snake_case or camelCase) is used for all variable names.
+      # This includes local variables, instance variables, class variables, method arguments
+      # (positional, keyword, rest or block), and block arguments.
+      #
+      # The cop can also be configured to forbid using specific names for variables, using
+      # `ForbiddenIdentifiers` or `ForbiddenPatterns`. In addition to the above, this applies
+      # to global variables as well.
+      #
+      # Method definitions and method calls are not affected by this cop.
       #
       # @example EnforcedStyle: snake_case (default)
       #   # bad
@@ -26,24 +33,45 @@ module RuboCop
       #
       # @example AllowedPatterns: ['_v\d+\z']
       #   # good (with EnforcedStyle: camelCase)
-      #   :release_v1
+      #   release_v1 = true
+      #
+      # @example ForbiddenIdentifiers: ['fooBar']
+      #   # bad (in all cases)
+      #   fooBar = 1
+      #   @fooBar = 1
+      #   @@fooBar = 1
+      #   $fooBar = 1
+      #
+      # @example ForbiddenPatterns: ['_v\d+\z']
+      #   # bad (in all cases)
+      #   release_v1 = true
+      #   @release_v1 = true
+      #   @@release_v1 = true
+      #   $release_v1 = true
       #
       class VariableName < Base
         include AllowedIdentifiers
         include ConfigurableNaming
         include AllowedPattern
+        include ForbiddenIdentifiers
+        include ForbiddenPattern
 
         MSG = 'Use %<style>s for variable names.'
+        MSG_FORBIDDEN = '`%<identifier>s` is forbidden, use another name instead.'
 
         def valid_name?(node, name, given_style = style)
           super || matches_allowed_pattern?(name)
         end
 
         def on_lvasgn(node)
-          return unless node.name
-          return if allowed_identifier?(node.name)
+          return unless (name = node.name)
+          return if allowed_identifier?(name)
 
-          check_name(node, node.name, node.loc.name)
+          if forbidden_name?(name)
+            register_forbidden_name(node)
+          else
+            check_name(node, name, node.loc.name)
+          end
         end
         alias on_ivasgn    on_lvasgn
         alias on_cvasgn    on_lvasgn
@@ -56,11 +84,28 @@ module RuboCop
         alias on_blockarg  on_lvasgn
         alias on_lvar      on_lvasgn
 
+        # Only forbidden names are checked for global variable assignment
+        def on_gvasgn(node)
+          return unless (name = node.name)
+          return unless forbidden_name?(name)
+
+          register_forbidden_name(node)
+        end
+
         private
 
+        def forbidden_name?(name)
+          forbidden_identifier?(name) || forbidden_pattern?(name)
+        end
+
         def message(style)
           format(MSG, style: style)
         end
+
+        def register_forbidden_name(node)
+          message = format(MSG_FORBIDDEN, identifier: node.name)
+          add_offense(node.loc.name, message: message)
+        end
       end
     end
   end

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

@@ -132,7 +132,9 @@ module RuboCop
 
         def on_sym(node)
           @node = node
-          return if allowed_identifier?(node.value)
+
+          # Prism parses a quoted empty hash key (`{ "": value }`) as an empty symbol node.
+          return if node.value.empty? || allowed_identifier?(node.value)
 
           check_name(node, node.value, node) if cop_config['CheckSymbols']
         end

data/lib/rubocop/cop/naming.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # Cops for the `Naming` department. The department's cops are registered for lazy loading
+    # and their files are loaded on demand.
+    module Naming
+      extend LazyLoader
+
+      register_cop :AccessorMethodName, "#{__dir__}/naming/accessor_method_name"
+      register_cop :AsciiIdentifiers, "#{__dir__}/naming/ascii_identifiers"
+      register_cop :BlockForwarding, "#{__dir__}/naming/block_forwarding"
+      register_cop :BlockParameterName, "#{__dir__}/naming/block_parameter_name"
+      register_cop :ClassAndModuleCamelCase, "#{__dir__}/naming/class_and_module_camel_case"
+      register_cop :ConstantName, "#{__dir__}/naming/constant_name"
+      register_cop :FileName, "#{__dir__}/naming/file_name"
+      register_cop :HeredocDelimiterCase, "#{__dir__}/naming/heredoc_delimiter_case"
+      register_cop :HeredocDelimiterNaming, "#{__dir__}/naming/heredoc_delimiter_naming"
+      register_cop :InclusiveLanguage, "#{__dir__}/naming/inclusive_language"
+      register_cop :MemoizedInstanceVariableName, "#{__dir__}/naming/memoized_instance_variable_name"
+      register_cop :MethodName, "#{__dir__}/naming/method_name"
+      register_cop :MethodParameterName, "#{__dir__}/naming/method_parameter_name"
+      register_cop :BinaryOperatorParameterName, "#{__dir__}/naming/binary_operator_parameter_name"
+      register_cop :PredicateMethod, "#{__dir__}/naming/predicate_method"
+      register_cop :PredicatePrefix, "#{__dir__}/naming/predicate_prefix"
+      register_cop :RescuedExceptionsVariableName, "#{__dir__}/naming/rescued_exceptions_variable_name"
+      register_cop :VariableName, "#{__dir__}/naming/variable_name"
+      register_cop :VariableNumber, "#{__dir__}/naming/variable_number"
+    end
+  end
+end

data/lib/rubocop/cop/offense.rb

@@ -66,6 +66,13 @@ module RuboCop
         alias_method :last_line, :line
         alias_method :last_column, :column
 
+        attr_reader :source_buffer
+
+        def initialize(line, column, source_line, begin_pos, end_pos)
+          super
+          @source_buffer = Parser::Source::Buffer.new('(pseudo)', source: source_line)
+        end
+
         def column_range
           column...last_column
         end
@@ -79,18 +86,88 @@ module RuboCop
 
       NO_LOCATION = PseudoSourceRange.new(1, 0, '', 0, 0).freeze
 
+      EMPTY_CORRECTIONS = [].freeze
+      private_constant :EMPTY_CORRECTIONS
+
+      # @api public
+      #
+      # @!attribute [r] justification
+      #
+      # @return [String, nil]
+      #   the reason given on the directive that suppressed this offense
+      #   (the text after `--`), or `nil` when the offense is not suppressed
+      #   or the directive carries no reason
+      attr_reader :justification
+
+      # @api public
+      #
+      # @!attribute [r] corrections
+      #
+      # @return [Array<Correction>]
+      #   the individual edits that autocorrecting this offense would make, in
+      #   source order. Empty when the offense has no correction. Unlike
+      #   {#corrector}, this survives serialization, so it is available on a
+      #   cache hit and in parallel runs.
+      attr_reader :corrections
+
+      # @api public
+      #
+      # @!attribute [r] correction_safe
+      #
+      # @return [Boolean]
+      #   whether autocorrection would apply {#corrections} in a normal `-a`
+      #   run. A cop marked `Safe: false` or `SafeAutoCorrect: false` still
+      #   builds its correction, but only `-A` applies it, so a consumer that
+      #   applies edits itself has to make the same distinction.
+      attr_reader :correction_safe
+
+      # A single edit of an autocorrection: the source range it replaces and
+      # the text it replaces it with. An insertion has an empty range, a
+      # removal an empty replacement.
+      #
+      # @api public
+      Correction = Struct.new(:begin_pos, :end_pos, :replacement) do
+        def length
+          end_pos - begin_pos
+        end
+      end
+
       # @api private
       def initialize(severity, location, message, cop_name, # rubocop:disable Metrics/ParameterLists
-                     status = :uncorrected, corrector = nil)
+                     status = :uncorrected, corrector = nil, justification: nil,
+                     corrections: nil, correction_safe: true)
         @severity = RuboCop::Cop::Severity.new(severity)
         @location = location
+
+        # Pre-compute the position eagerly because the offense is frozen and
+        # `location.line` / `location.column` are expensive to compute; sorting
+        # many offenses calls them repeatedly through `#<=>`.
+        @line = location.line
+        @column = location.column
         @message = message.freeze
         @cop_name = cop_name.freeze
         @status = status
         @corrector = corrector
+        @justification = justification.freeze
+        @corrections = (corrections || corrections_from(corrector)).freeze
+        @correction_safe = correction_safe
         freeze
       end
 
+      def marshal_dump
+        [@severity, @location, @message, @cop_name, @status, @justification, @corrections,
+         @correction_safe]
+      end
+
+      def marshal_load(array)
+        @severity, @location, @message, @cop_name, @status, @justification, @corrections,
+          @correction_safe = array
+        @corrections ||= EMPTY_CORRECTIONS
+        @correction_safe = true if @correction_safe.nil?
+        @line = @location.line
+        @column = @location.column
+      end
+
       # @api public
       #
       # @!attribute [r] correctable?
@@ -98,8 +175,10 @@ module RuboCop
       # @return [Boolean]
       #   whether this offense can be automatically corrected via autocorrect.
       #   This includes todo comments, for example when requested with `--disable-uncorrectable`.
+      #   An offense suppressed by a directive comment is not correctable -
+      #   autocorrect will not touch it.
       def correctable?
-        @status != :unsupported
+        @status != :unsupported && @status != :disabled
       end
 
       # @api public
@@ -139,7 +218,8 @@ module RuboCop
       # @return [Parser::Source::Range]
       #   the range of the code that is highlighted
       def highlighted_area
-        Parser::Source::Range.new(source_line, column, column + column_length)
+        source_buffer = Parser::Source::Buffer.new(location.source_buffer.name, source: source_line)
+        Parser::Source::Range.new(source_buffer, column, column + column_length)
       end
 
       # @api private
@@ -151,14 +231,10 @@ module RuboCop
       end
 
       # @api private
-      def line
-        location.line
-      end
+      attr_reader :line
 
       # @api private
-      def column
-        location.column
-      end
+      attr_reader :column
 
       # @api private
       def source_line
@@ -203,6 +279,16 @@ module RuboCop
         column + 1
       end
 
+      # @api private
+      #
+      # The minimum value of `real_column` is 1, so the minimum value of
+      # `real_last_column` is also 1. A non-zero `last_column` is used as is,
+      # because the 0-based end-exclusive column is the same as the 1-based
+      # column of the last character.
+      def real_last_column
+        last_column.zero? ? 1 : last_column
+      end
+
       # @api public
       #
       # @return [Boolean]
@@ -233,6 +319,19 @@ module RuboCop
         end
         0
       end
+
+      private
+
+      # Extracted eagerly rather than on demand because the offense is frozen,
+      # and because a corrector cannot be serialized - the cache and parallel
+      # workers would otherwise hand back offenses that have lost their edits.
+      def corrections_from(corrector)
+        return EMPTY_CORRECTIONS unless corrector
+
+        corrector.as_replacements.map do |range, replacement|
+          Correction.new(range.begin_pos, range.end_pos, replacement.freeze).freeze
+        end
+      end
     end
   end
 end