rubocop 1.71.1 → 1.91.0

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

@@ -3,9 +3,9 @@
 module RuboCop
   module Cop
     module Lint
-      # Warns the usage of unsafe number conversions. Unsafe
-      # number conversion can cause unexpected error if auto type conversion
-      # fails. Cop prefer parsing with number class instead.
+      # Warns against the usage of unsafe number conversions. Unsafe
+      # number conversion can cause an unexpected error if auto type conversion
+      # fails. The cop prefers parsing with a number class instead.
       #
       # Conversion with `Integer`, `Float`, etc. will raise an `ArgumentError`
       # if given input that is not numeric (eg. an empty string), whereas
@@ -14,10 +14,10 @@ module RuboCop
       # always correct to raise if a value is not numeric.
       #
       # NOTE: Some values cannot be converted properly using one of the `Kernel`
-      # method (for instance, `Time` and `DateTime` values are allowed by this
+      # methods (for instance, `Time` and `DateTime` values are allowed by this
       # cop by default). Similarly, Rails' duration methods do not work well
       # with `Integer()` and can be allowed with `AllowedMethods`. By default,
-      # there are no methods to allowed.
+      # there are no allowed methods.
       #
       # @safety
       #   Autocorrection is unsafe because it is not guaranteed that the
@@ -66,7 +66,7 @@ module RuboCop
       #   # good
       #   10.minutes.to_i
       #
-      # @example IgnoredClasses: [Time, DateTime] (default)
+      # @example AllowedClasses: [Time, DateTime] (default)
       #
       #   # good
       #   Time.now.to_datetime.to_i
@@ -117,11 +117,11 @@ module RuboCop
 
             message = format(
               MSG,
-              current: "#{receiver.source}.#{to_method}",
+              current: current_method(node, receiver, to_method),
               corrected_method: correct_method(node, receiver)
             )
             add_offense(node, message: message) do |corrector|
-              next if part_of_ignored_node?(node)
+              next if safe_navigation?(node) || part_of_ignored_node?(node)
 
               corrector.replace(node, correct_method(node, node.receiver))
 
@@ -156,13 +156,22 @@ module RuboCop
           "{ |i| #{body} }"
         end
 
+        def current_method(node, receiver, to_method)
+          operator = node.csend_type? ? '&.' : '.'
+          "#{receiver.source}#{operator}#{to_method}"
+        end
+
         def remove_parentheses(corrector, node)
           corrector.replace(node.loc.begin, ' ')
           corrector.remove(node.loc.end)
         end
 
+        def safe_navigation?(node)
+          node.csend_type? || node.each_descendant(:csend).any?
+        end
+
         def allow_receiver?(receiver)
-          if receiver.numeric_type? || (receiver.send_type? &&
+          if receiver.numeric_type? || (receiver.call_type? &&
             (conversion_method?(receiver.method_name) ||
             allowed_method_name?(receiver.method_name)))
             true
@@ -188,7 +197,7 @@ module RuboCop
         end
 
         def ignored_classes
-          cop_config.fetch('IgnoredClasses', [])
+          cop_config.fetch('AllowedClasses', [])
         end
 
         def ignored_class?(name)

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

@@ -16,7 +16,7 @@ module RuboCop
       #   ruby 3.0.0p0 (2020-12-25 revision 95aff21468) [x86_64-darwin19]
       #   -e:1: _1 is reserved for numbered parameter
       #
-      # NOTE: The parametered parameters are from `_1` to `_9`. This cop checks `_0`, and over `_10`
+      # NOTE: The numbered parameters are from `_1` to `_9`. This cop checks `_0`, and over `_10`
       # as well to prevent confusion.
       #
       # @example

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

@@ -15,6 +15,13 @@ module RuboCop
       # can't determine the type of `x`. If `x` is an `Array` or `String`, it doesn't perform
       # a numeric operation.
       #
+      # @safety
+      #   This cop is unsafe because the autocorrection drops the operands, which
+      #   discards any side effects of evaluating them and can change behavior when
+      #   the result is not actually constant. For example, `x / x` raises
+      #   `ZeroDivisionError` when `x` is `0`, and returns `Float::NAN` (not `1`)
+      #   when `x` is `0.0`; replacing it with `1` silences that.
+      #
       # @example
       #
       #   # bad
@@ -45,6 +52,7 @@ module RuboCop
       #
       class NumericOperationWithConstantResult < Base
         extend AutoCorrector
+
         MSG = 'Numeric operation with a constant result detected.'
         RESTRICT_ON_SEND = %i[* / **].freeze
 
@@ -57,6 +65,9 @@ module RuboCop
                          '(op-asgn (lvasgn $_lhs) $_operation ({int lvar} $_rhs))'
 
         def on_send(node)
+          # Safe navigation short-circuits to `nil` when the receiver is `nil`, so the
+          # result is not constant and replacing it with `0`/`1` would change behavior.
+          return if node.csend_type?
           return unless (lhs, operation, rhs = operation_with_constant_result?(node))
           return unless (result = constant_result?(lhs, operation, rhs))
 

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

@@ -30,7 +30,7 @@ module RuboCop
           return unless node.lhs&.casgn_type?
 
           add_offense(node.loc.operator) do |corrector|
-            next if node.each_ancestor(:def, :defs).any?
+            next if node.each_ancestor(:any_def).any?
 
             corrector.replace(node.loc.operator, '=')
           end

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

@@ -38,23 +38,23 @@ module RuboCop
         def on_new_investigation
           return if processed_source.buffer.source.empty?
 
-          encoding_line, frozen_string_literal_line = magic_comment_lines
+          encoding_line, other_magic_comment_line = magic_comment_lines
 
-          return unless encoding_line && frozen_string_literal_line
-          return if encoding_line < frozen_string_literal_line
+          return unless encoding_line && other_magic_comment_line
+          return if encoding_line < other_magic_comment_line
 
           range = processed_source.buffer.line_range(encoding_line + 1)
 
           add_offense(range) do |corrector|
-            autocorrect(corrector, encoding_line, frozen_string_literal_line)
+            autocorrect(corrector, encoding_line, other_magic_comment_line)
           end
         end
 
         private
 
-        def autocorrect(corrector, encoding_line, frozen_string_literal_line)
+        def autocorrect(corrector, encoding_line, other_magic_comment_line)
           range1 = processed_source.buffer.line_range(encoding_line + 1)
-          range2 = processed_source.buffer.line_range(frozen_string_literal_line + 1)
+          range2 = processed_source.buffer.line_range(other_magic_comment_line + 1)
 
           corrector.replace(range1, range2.source)
           corrector.replace(range2, range1.source)
@@ -66,7 +66,7 @@ module RuboCop
           leading_magic_comments.each.with_index do |comment, index|
             if comment.encoding_specified?
               lines[0] = index
-            elsif comment.frozen_string_literal_specified?
+            elsif comment.valid?
               lines[1] = index
             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)
@@ -119,10 +134,6 @@ module RuboCop
         def regexp_receiver?(send_node)
           send_node.receiver&.regexp_type?
         end
-
-        def nth_ref_receiver?(send_node)
-          send_node.receiver&.nth_ref_type?
-        end
       end
     end
   end

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
@@ -63,19 +79,9 @@ module RuboCop
         end
 
         def spaces_before_left_parenthesis(node)
-          receiver = node.receiver
-          receiver_length = if receiver
-                              receiver.source.length
-                            else
-                              0
-                            end
-          without_receiver = node.source[receiver_length..]
-
-          # Escape question mark if any.
-          method_regexp = Regexp.escape(node.method_name)
-
-          match = without_receiver.match(/^\s*&?\.?\s*#{method_regexp}(\s+)\(/)
-          match ? match.captures[0].length : 0
+          return 0 if node.parenthesized? || !node.first_argument.source.start_with?('(')
+
+          node.first_argument.source_range.begin_pos - node.loc.selector.end_pos
         end
 
         def space_range(expr, space_length)

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

@@ -3,15 +3,18 @@
 module RuboCop
   module Cop
     module Lint
-      # Checks for `raise` or `fail` statements which are
-      # raising `Exception` class.
+      # Checks for `raise` or `fail` statements which raise `Exception` or
+      # `Exception.new`. Use `StandardError` or a specific exception class instead.
       #
-      # You can specify a module name that will be an implicit namespace
-      # using `AllowedImplicitNamespaces` option. The cop cause a false positive
-      # for namespaced `Exception` when a namespace is omitted. This option can
-      # prevent the false positive by specifying a namespace to be omitted for
-      # `Exception`. Alternatively, make `Exception` a fully qualified class
-      # name with an explicit namespace.
+      # If you have defined your own namespaced `Exception` class, it is possible
+      # to configure the cop to allow it by setting `AllowedImplicitNamespaces` to
+      # an array with the names of the namespaces to allow. By default, this is set to
+      # `['Gem']`, which allows `Gem::Exception` to be raised without an explicit namespace.
+      # If not allowed, a false positive may be registered if `raise Exception` is called
+      # within the namespace.
+      #
+      # Alternatively, use a fully qualified name with `raise`/`fail`
+      # (eg. `raise Namespace::Exception`).
       #
       # @safety
       #   This cop is unsafe because it will change the exception class being
@@ -20,15 +23,31 @@ module RuboCop
       # @example
       #   # bad
       #   raise Exception, 'Error message here'
+      #   raise Exception.new('Error message here')
       #
       #   # good
       #   raise StandardError, 'Error message here'
+      #   raise MyError.new, 'Error message here'
+      #
+      # @example AllowedImplicitNamespaces: ['Gem'] (default)
+      #   # bad - `Foo` is not an allowed implicit namespace
+      #   module Foo
+      #     def self.foo
+      #       raise Exception # This is qualified to `Foo::Exception`.
+      #     end
+      #   end
       #
-      # @example AllowedImplicitNamespaces: ['Gem']
       #   # good
       #   module Gem
       #     def self.foo
-      #       raise Exception # This exception means `Gem::Exception`.
+      #       raise Exception # This is qualified to `Gem::Exception`.
+      #     end
+      #   end
+      #
+      #   # good
+      #   module Foo
+      #     def self.foo
+      #       raise Foo::Exception
       #     end
       #   end
       class RaiseException < Base
@@ -76,7 +95,7 @@ module RuboCop
           if parent.module_type?
             namespace = parent.identifier.source
 
-            return allow_implicit_namespaces.include?(namespace)
+            return true if allow_implicit_namespaces.include?(namespace)
           end
 
           implicit_namespace?(parent)

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

@@ -4,7 +4,7 @@ module RuboCop
   module Cop
     module Lint
       # Checks for `rand(1)` calls.
-      # Such calls always return `0`.
+      # Such calls always return `0`, and so do `rand(-1)`, `rand(1.0)`, and `rand(-1.0)`.
       #
       # @example
       #

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 -- the examples below read as real directives
 module RuboCop
   module Cop
     module Lint
@@ -104,31 +104,93 @@ 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 ignore_offense?(line_range)
-            next if expected_final_disable?(cop, line_range)
-
-            comment = processed_source.comment_at_line(line_range.begin)
-            redundant = if all_disabled?(comment)
-                          find_redundant_all(line_range, line_ranges[line_range_index + 1])
-                        elsif department_disabled?(cop, comment)
-                          find_redundant_department(cop, line_range)
-                        else
-                          find_redundant_cop(cop, line_range)
-                        end
+            next if should_skip_line_range?(cop, line_range)
+
+            comment = directive_comment(line_range)
+            next if skip_directive?(comment)
 
+            next_range = line_ranges[line_range_index + 1]
+            redundant = find_redundant_directive(cop, comment, line_range, next_range)
             yield comment, redundant if redundant
           end
         end
 
-        # rubocop:disable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+        def should_skip_line_range?(cop, line_range)
+          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 next-statement directive with no statement attached (or misplaced
+        # at the end of a code line) affects nothing, so it is redundant by
+        # definition.
+        def each_detached_next_directive
+          processed_source.comment_config.detached_next_directives.each do |directive|
+            names = if directive.next?
+                      directive.signed_args.values.flatten
+                    else
+                      directive.raw_cop_names
+                    end
+            names.each { |cop| yield directive.comment, cop }
+          end
+        end
+
+        def skip_directive?(comment)
+          # A cop disabled in the configuration is represented by a synthetic directive that
+          # has no comment in the source, so there is nothing to report or to remove.
+          # Its range starts at `CONFIG_DISABLED_LINE_RANGE_MIN` and runs to the end of the file,
+          # but a `pop` splits it, and the pieces in between are bounded on both sides.
+          return true if comment.is_a?(CommentConfig::ConfigDisabledCopDirectiveComment)
+
+          directive = DirectiveComment.new(comment)
+          directive.push? || directive.pop? || directive.next?
+        end
+
+        def find_redundant_directive(cop, comment, line_range, next_range)
+          if all_disabled?(comment)
+            find_redundant_all(line_range, next_range)
+          elsif department_disabled?(cop, comment)
+            find_redundant_department(cop, line_range)
+          else
+            find_redundant_cop(cop, line_range)
+          end
+        end
+
+        # 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)
@@ -138,13 +200,13 @@ 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
-            # to disable a few select cops first and then all cops further
-            # down in the code.
-            next if all_disabled?(comment)
+            # `push`/`next` signed arguments are not analyzed for redundancy
+            # (yet), and comments disabling all cops don't count since it's
+            # reasonable to disable a few select cops first and then all cops
+            # further down in the code.
+            next if comment.nil? || skip_directive?(comment) || all_disabled?(comment)
 
             redundant =
               if department_disabled?(cop, comment)
@@ -156,7 +218,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 }
@@ -184,7 +245,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)
@@ -227,17 +292,33 @@ module RuboCop
         end
 
         def add_offense_for_entire_comment(comment, cops)
-          location = DirectiveComment.new(comment).range
+          directive = DirectiveComment.new(comment)
+          location = directive.range
           cop_names = cops.sort.map { |c| describe(c) }.join(', ')
 
-          add_offense(location, message: message(cop_names)) do |corrector|
-            range = comment_range_with_surrounding_space(location, comment.source_range)
+          # 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.
+          message = message(cop_names, enabling: directive.enable_next?)
+          if any_unknown_cop?(cops) || misplaced_next_directive?(comment)
+            return add_offense(location, message: message)
+          end
 
-            if leave_free_comment?(comment, range)
-              corrector.replace(range, ' # ')
-            else
-              corrector.remove(range)
-            end
+          add_offense(location, message: message) do |corrector|
+            remove_entire_comment(corrector, comment)
+          end
+        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
 
@@ -247,14 +328,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? || directive.next? || directive.enable_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, '')
 
@@ -269,7 +371,10 @@ module RuboCop
         end
 
         def matching_range(haystack, needle)
-          offset = haystack.source.index(needle)
+          # Match the cop name as a whole token so a shorter name is not found inside a
+          # longer one that shares its prefix (e.g. `Lint/AmbiguousOperator` in
+          # `Lint/AmbiguousOperatorPrecedence`).
+          offset = haystack.source.index(/#{Regexp.escape(needle)}(?!\w)/)
           return unless offset
 
           offset += haystack.begin_pos
@@ -286,7 +391,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
 
@@ -299,8 +410,8 @@ module RuboCop
           similar ? "`#{cop}` (did you mean `#{similar}`?)" : "`#{cop}` (unknown cop)"
         end
 
-        def message(cop_names)
-          "Unnecessary disabling of #{cop_names}."
+        def message(cop_names, enabling: false)
+          "Unnecessary #{enabling ? 'enabling' : 'disabling'} of #{cop_names}."
         end
 
         def all_cop_names
@@ -327,4 +438,3 @@ module RuboCop
     end
   end
 end
-# rubocop:enable Lint/RedundantCopDisableDirective