rubocop 1.91.0 → 1.92.0

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

@@ -142,12 +142,6 @@ module RuboCop
           end
         end
 
-        def offending_prefixes_for(node, method_name)
-          predicate_prefixes.reject do |prefix|
-            allowed_method_name?(method_name, prefix) ||
-              (use_sorbet_sigs? && !sorbet_sig?(node, return_type: 'T::Boolean'))
-          end
-        end
         alias on_defs on_def
 
         def validate_config
@@ -162,6 +156,13 @@ module RuboCop
 
         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))
@@ -210,22 +211,6 @@ module RuboCop
         def method_definition_macro?(macro_name)
           cop_config['MethodDefinitionMacros'].include?(macro_name.to_s)
         end
-
-        # When `AllCops/UseProjectIndex` is enabled, methods that override a
-        # method defined by an ancestor elsewhere in the project are not
-        # reported: renaming an override breaks the inherited contract.
-        def overrides_inherited_method?(node)
-          return false unless project_index
-          return false unless (namespace_node = node.each_ancestor(:class, :module).first)
-
-          declaration = resolve_constant_in_index(namespace_node.identifier)
-          return false unless declaration.is_a?(Rubydex::Namespace)
-
-          scope = node.defs_type? ? indexed_singleton_of(declaration) : declaration
-          !scope.nil? && inherited_index_member?(scope, "#{node.method_name}()")
-        rescue StandardError
-          false
-        end
       end
     end
   end

data/lib/rubocop/cop/offense.rb

@@ -86,6 +86,9 @@ module RuboCop
 
       NO_LOCATION = PseudoSourceRange.new(1, 0, '', 0, 0).freeze
 
+      EMPTY_CORRECTIONS = [].freeze
+      private_constant :EMPTY_CORRECTIONS
+
       # @api public
       #
       # @!attribute [r] justification
@@ -96,9 +99,43 @@ module RuboCop
       #   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, justification: nil)
+                     status = :uncorrected, corrector = nil, justification: nil,
+                     corrections: nil, correction_safe: true)
         @severity = RuboCop::Cop::Severity.new(severity)
         @location = location
 
@@ -112,15 +149,21 @@ module RuboCop
         @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]
+        [@severity, @location, @message, @cop_name, @status, @justification, @corrections,
+         @correction_safe]
       end
 
       def marshal_load(array)
-        @severity, @location, @message, @cop_name, @status, @justification = 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
@@ -276,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

data/lib/rubocop/cop/registry.rb

@@ -43,7 +43,7 @@ module RuboCop
 
       def self.qualified_cop?(name)
         badge = Badge.parse(name)
-        global.qualify_badge(badge).first == badge
+        global.qualify_badge(badge).include?(badge)
       end
 
       attr_reader :options, :warnings

data/lib/rubocop/cop/security/json_load.rb

@@ -22,6 +22,13 @@ module RuboCop
       # passing the `create_additions` keyword argument emits a deprecation warning, with the
       # goal of being secure by default in the next major version 3.0.0.
       #
+      # NOTE: Before `json` gem version 2.17.0, `JSON.load` only takes options as its third
+      # argument. A hash passed as the second argument is taken as the `proc` argument, so
+      # its `create_additions` option is ignored. Which `json` version runs can't be told
+      # statically (the lockfile may resolve a newer one than the default gem loaded in
+      # production), so options passed as the second argument are always reported. Pass
+      # `nil` as the second argument instead.
+      #
       # @safety
       #   This cop's autocorrection is unsafe because it's potentially dangerous.
       #   If using a stream, like `JSON.load(open('file'))`, you will need to call
@@ -33,13 +40,16 @@ module RuboCop
       #   JSON.load('{}')
       #   JSON.restore('{}')
       #
+      #   # bad - ignored by `json` older than 2.17.0
+      #   JSON.load('{}', create_additions: false)
+      #
       #   # good
       #   JSON.parse('{}')
       #   JSON.unsafe_load('{}')
       #
       #   # good - explicit use of `create_additions` option
-      #   JSON.load('{}', create_additions: true)
-      #   JSON.load('{}', create_additions: false)
+      #   JSON.load('{}', nil, create_additions: true)
+      #   JSON.load('{}', nil, create_additions: false)
       #
       class JSONLoad < Base
         extend AutoCorrector
@@ -51,8 +61,10 @@ module RuboCop
         def_node_matcher :insecure_json_load, <<~PATTERN
           (
             send (const {nil? cbase} :JSON) ${:load :restore}
-            ...
-            !`(pair (sym :create_additions) _)
+            {
+              _ hash
+            | ... !`(pair (sym :create_additions) _)
+            }
           )
         PATTERN
 

data/lib/rubocop/cop/style/access_modifier_declarations.rb

@@ -187,11 +187,18 @@ module RuboCop
         def allowed?(node)
           !node.access_modifier? ||
             node.parent&.type?(:pair, :any_block) ||
+            dynamic_method_list?(node) ||
             allow_modifiers_on_symbols?(node) ||
             allow_modifiers_on_attrs?(node) ||
             allow_modifiers_on_alias_method?(node)
         end
 
+        # `private(*names)` with a list computed at runtime names no definition
+        # the modifier could be grouped with.
+        def dynamic_method_list?(node)
+          node.arguments.any?(&:splat_type?) && !access_modifier_with_symbol?(node)
+        end
+
         def autocorrect(corrector, node)
           case style
           when :group

data/lib/rubocop/cop/style/alias.rb

@@ -60,7 +60,7 @@ module RuboCop
             add_offense(node.loc.keyword, message: MSG_ALIAS) do |corrector|
               autocorrect(corrector, node)
             end
-          elsif node.children.none? { |arg| bareword?(arg) }
+          elsif node.children.all? { |arg| !bareword?(arg) && bareword_symbol?(arg) }
             add_offense_for_args(node) { |corrector| autocorrect(corrector, node) }
           end
         end
@@ -97,7 +97,7 @@ module RuboCop
 
         def add_offense_for_args(node, &block)
           existing_args  = node.children.map(&:source).join(' ')
-          preferred_args = node.children.map { |a| a.source[1..] }.join(' ')
+          preferred_args = node.children.map { |node| bareword_for(node) }.join(' ')
           arg_ranges     = node.children.map(&:source_range)
           msg            = format(MSG_SYMBOL_ARGS, prefer: preferred_args, current: existing_args)
           add_offense(arg_ranges.reduce(&:join), message: msg, &block)
@@ -138,6 +138,15 @@ module RuboCop
           !sym_node.source.start_with?(':') || sym_node.dsym_type?
         end
 
+        def bareword_symbol?(sym_node)
+          return false unless sym_node.sym_type?
+
+          value = sym_node.value.to_s
+          return true if value.match?(/\A[A-Za-z_]\w*[?!=]?\z/)
+
+          !sym_node.source.start_with?(':"', ":'") && !value.start_with?('@', '$')
+        end
+
         def correct_alias_method_to_alias(corrector, send_node)
           new, old = *send_node.arguments
           replacement = "alias #{identifier(new)} #{identifier(old)}"
@@ -153,17 +162,21 @@ module RuboCop
         end
 
         def correct_alias_with_symbol_args(corrector, node)
-          corrector.replace(node.new_identifier, node.new_identifier.source[1..])
-          corrector.replace(node.old_identifier, node.old_identifier.source[1..])
+          corrector.replace(node.new_identifier, bareword_for(node.new_identifier))
+          corrector.replace(node.old_identifier, bareword_for(node.old_identifier))
         end
 
         def identifier(node)
-          if node.sym_type?
+          if bareword_symbol?(node)
             ":#{node.children.first}"
           else
             node.source
           end
         end
+
+        def bareword_for(sym_node)
+          sym_node.value.to_s
+        end
       end
     end
   end

data/lib/rubocop/cop/style/ambiguous_endless_method_definition.rb

@@ -39,9 +39,9 @@ module RuboCop
         # @!method ambiguous_endless_method_body(node)
         def_node_matcher :ambiguous_endless_method_body, <<~PATTERN
           ^${
-            (if _ <def _>)
-            ({and or} def _)
-            ({while until} _ def)
+            (if _ <any_def _>)
+            ({and or} any_def _)
+            ({while until} _ any_def)
           }
         PATTERN
 
@@ -57,6 +57,7 @@ module RuboCop
             correct_to_multiline(corrector, node)
           end
         end
+        alias on_defs on_def
 
         private
 

data/lib/rubocop/cop/style/and_or.rb

@@ -48,6 +48,10 @@ module RuboCop
 
         MSG = 'Use `%<prefer>s` instead of `%<current>s`.'
 
+        def self.autocorrect_incompatible_with
+          [Style::MethodCallWithArgsParentheses, Style::ReturnNilInPredicateMethodDefinition]
+        end
+
         def on_and(node)
           process_logical_operator(node) if style == :always
         end

data/lib/rubocop/cop/style/arguments_forwarding.rb

@@ -153,7 +153,7 @@ module RuboCop
         BLOCK_MSG = 'Use anonymous block arguments forwarding (`&`).'
 
         def self.autocorrect_incompatible_with
-          [Naming::BlockForwarding, Style::MethodDefParentheses]
+          [Naming::BlockForwarding, Style::EndlessMethod, Style::MethodDefParentheses]
         end
 
         def on_def(node)
@@ -377,6 +377,7 @@ module RuboCop
         def add_parens_if_missing(node, corrector)
           return if parentheses?(node)
           return if node.send_type? && node.method?(:[])
+          return unless (@parenthesized_nodes ||= Set.new.compare_by_identity).add?(node)
 
           add_parentheses(node, corrector)
         end
@@ -499,6 +500,8 @@ module RuboCop
           end
 
           def offensive_block_forwarding?
+            return false if @send_node.block_literal?
+
             @block_arg ? forwarded_block_arg : allow_offense_for_no_block?
           end
 

data/lib/rubocop/cop/style/attr.rb

@@ -50,10 +50,9 @@ module RuboCop
         def autocorrect(corrector, node)
           attr_name, setter = *node.arguments
 
-          node_expr = node.source_range
-          attr_expr = attr_name.source_range
-
-          remove = range_between(attr_expr.end_pos, node_expr.end_pos) if setter&.boolean_type?
+          if setter&.boolean_type?
+            remove = range_between(attr_name.source_range.end_pos, setter.source_range.end_pos)
+          end
 
           corrector.replace(node.loc.selector, replacement_method(node))
           corrector.remove(remove) if remove

data/lib/rubocop/cop/style/bitwise_predicate.rb

@@ -66,16 +66,18 @@ module RuboCop
 
         # @!method bit_operation?(node)
         def_node_matcher :bit_operation?, <<~PATTERN
-          (begin
-            (send _ :& _))
+          {
+            (begin (send _ :& _))
+            (send _ :& _)
+          }
         PATTERN
 
         # rubocop:disable-next Metrics/AbcSize
         def on_send(node)
-          return unless node.receiver&.begin_type?
+          return unless bit_operation?(node.receiver)
           return unless (preferred_method = preferred_method(node))
 
-          bit_operation = node.receiver.children.first
+          bit_operation = node.receiver.begin_type? ? node.receiver.children.first : node.receiver
           lhs, _operator, rhs = *bit_operation
 
           preferred = if preferred_method == 'allbits?' && lhs.source == node.first_argument.source

data/lib/rubocop/cop/style/block_delimiters.rb

@@ -177,7 +177,7 @@ module RuboCop
         BRACES_REQUIRED_MESSAGE = "Brace delimiters `{...}` required for '%<method_name>s' method."
 
         def self.autocorrect_incompatible_with
-          [Style::RedundantBegin]
+          [Layout::SpaceBeforeBlockBraces, Style::MethodCallWithArgsParentheses, Style::RedundantBegin]
         end
 
         def on_send(node)
@@ -196,6 +196,8 @@ module RuboCop
           end
         end
         alias on_csend on_send
+        alias on_super on_send
+        alias on_yield on_send
 
         def on_block(node)
           return if part_of_ignored_node?(node)
@@ -292,7 +294,7 @@ module RuboCop
           corrector.replace(b, '{')
           corrector.replace(e, '}')
 
-          corrector.wrap(node.body, "begin\n", "\nend") if begin_required?(node)
+          wrap_body_with_begin(corrector, node.body) if begin_required?(node)
         end
 
         def whitespace_before?(range)
@@ -372,6 +374,7 @@ module RuboCop
         # rubocop:disable-next Metrics/CyclomaticComplexity -- inlined special_method checks to avoid double evaluation
         def proper_block_style?(node)
           return true if require_do_end?(node)
+          return true if collection_of_for_loop?(node)
 
           method_name = node.method_name
           return true if allowed_method?(method_name) || matches_allowed_pattern?(method_name)
@@ -398,6 +401,10 @@ module RuboCop
           !modifier_rescue?(body)
         end
 
+        def collection_of_for_loop?(node)
+          node.parent&.for_type? && node.parent.collection == node
+        end
+
         def modifier_rescue?(rescue_node)
           return false if rescue_node.body.nil? || rescue_node.else_branch
           return false unless rescue_node.resbody_branches.one?
@@ -438,11 +445,20 @@ module RuboCop
         end
 
         def correction_would_break_code?(node)
-          return false unless node.keywords?
+          return loop_condition?(node) if node.braces?
 
           node.send_node.arguments? && !node.send_node.parenthesized?
         end
 
+        # A `do` in the condition of `while` or `until` is taken as the start of
+        # the loop body. Inside the body of another block it is unambiguous again.
+        def loop_condition?(node)
+          ancestors = node.each_ancestor.take_while { |ancestor| !ancestor.any_block_type? }
+          [node, *ancestors].each_cons(2).any? do |child, parent|
+            parent.type?(:while, :until) && parent.condition.equal?(child)
+          end
+        end
+
         def functional_method?(method_name)
           functional_methods.include?(method_name)
         end
@@ -490,6 +506,16 @@ module RuboCop
           node.type?(:array, :range)
         end
 
+        def wrap_body_with_begin(corrector, body)
+          heredoc_ends = body.each_node(:any_str).select(&:heredoc?).map do |str|
+            str.loc.heredoc_end
+          end
+          body_end = [body.source_range, *heredoc_ends].max_by(&:end_pos)
+
+          corrector.insert_before(body, "begin\n")
+          corrector.insert_after(body_end, "\nend")
+        end
+
         def begin_required?(block_node)
           # If the block contains `rescue` or `ensure`, it needs to be wrapped in
           # `begin`...`end` when changing `do-end` to `{}`.

data/lib/rubocop/cop/style/case_like_if.rb

@@ -54,6 +54,10 @@ module RuboCop
 
         MSG = 'Convert `if-elsif` to `case-when`.'
 
+        def self.autocorrect_incompatible_with
+          [Style::IfInsideElse]
+        end
+
         def on_if(node)
           return unless should_check?(node)
 
@@ -224,10 +228,9 @@ module RuboCop
         end
 
         def branch_conditions(node)
-          conditions = []
-          while node&.if_type? && !node.ternary?
+          conditions = [node.condition]
+          while (node = node.else_branch)&.if_type? && node.elsif?
             conditions << node.condition
-            node = node.else_branch
           end
           conditions
         end

data/lib/rubocop/cop/style/class_and_module_children.rb

@@ -65,6 +65,12 @@ module RuboCop
         NESTED_MSG = 'Use nested module/class definitions instead of compact style.'
         COMPACT_MSG = 'Use compact module/class definition instead of nested style.'
 
+        # `Style/StructInheritance` turns a class definition into a constant assignment in
+        # the same pass, which the compacted `class` keyword would then precede.
+        def self.autocorrect_incompatible_with
+          [Style::StructInheritance]
+        end
+
         def on_class(node)
           return if node.parent_class && style_for_classes != :nested
 
@@ -117,7 +123,10 @@ module RuboCop
         end
 
         def heuristic_namespace_keyword(node)
-          class_definition = node.left_sibling&.each_node(:class)&.find do |class_node|
+          left_sibling = node.left_sibling
+          return 'module' unless left_sibling.is_a?(AST::Node)
+
+          class_definition = left_sibling.each_node(:class).find do |class_node|
             class_node.identifier == node.identifier.namespace
           end
 
@@ -194,33 +203,62 @@ module RuboCop
             "#{node.body.children.first.const_name}"
         end
 
-        # rubocop:disable-next Metrics/AbcSize
         def remove_end(corrector, body)
-          remove_begin_pos = if same_line?(body.loc.name, body.loc.end)
-                               body.loc.name.end_pos
-                             else
-                               body.loc.end.begin_pos - leading_spaces(body).size
-                             end
-          adjustment = processed_source.raw_source[remove_begin_pos] == ';' ? 0 : 1
-          range = range_between(remove_begin_pos, body.loc.end.end_pos + adjustment)
+          range = if same_line?(body.loc.name, body.loc.end)
+                    single_line_end_range(body)
+                  else
+                    multiline_end_range(body)
+                  end
 
           corrector.remove(range)
         end
 
-        def unindent(corrector, node)
-          return unless node.body.children.last
+        def single_line_end_range(body)
+          raw = processed_source.raw_source
+          pos = body.loc.end.begin_pos
+          pos -= 1 while raw[pos - 1] == ' '
+          pos -= 1 if raw[pos - 1] == ';'
+          range_between(pos, body.loc.end.end_pos)
+        end
 
-          last_child_leading_spaces = leading_spaces(node.body.children.last)
-          return if spaces_size(leading_spaces(node)) == spaces_size(last_child_leading_spaces)
+        def multiline_end_range(body)
+          remove_begin_pos = body.loc.end.begin_pos - leading_spaces(body).size
+          adjustment = processed_source.raw_source[remove_begin_pos] == ';' ? 0 : 1
+          range_between(remove_begin_pos, body.loc.end.end_pos + adjustment)
+        end
 
-          column_delta = configured_indentation_width - spaces_size(last_child_leading_spaces)
-          return if column_delta.zero?
+        def unindent(corrector, node)
+          column_delta = unindent_column_delta(node)
+          return unless column_delta&.negative?
+
+          range = unindentable_range(node.body)
+          return unless range
 
           AlignmentCorrector.correct(
-            corrector, processed_source, node, column_delta, tab_indentation: true
+            corrector, processed_source, range, column_delta, tab_indentation: true
           )
         end
 
+        def unindent_column_delta(node)
+          body = node.body.children.last
+          return unless body
+
+          node_indentation = spaces_size(leading_spaces(node))
+          body_indentation = spaces_size(leading_spaces(body))
+
+          node_indentation + configured_indentation_width - body_indentation
+        end
+
+        def unindentable_range(body)
+          first_line = body.loc.name.line + 1
+          last_line = body.loc.end.line - 1
+          return if first_line > last_line
+
+          buffer = processed_source.buffer
+          range_between(buffer.line_range(first_line).begin_pos,
+                        buffer.line_range(last_line).end_pos)
+        end
+
         def leading_spaces(node)
           node.source_range.source_line[/\A\s*/]
         end

data/lib/rubocop/cop/style/class_methods_definitions.rb

@@ -72,6 +72,7 @@ module RuboCop
           return unless def_self_style?
           return unless node.identifier.self_type?
           return unless all_methods_public?(node)
+          return unless def_nodes(node).all? { |def_node| no_code_after?(def_node.source_range) }
 
           add_offense(node, message: MSG_SCLASS) do |corrector|
             autocorrect_sclass(node, corrector)
@@ -112,6 +113,13 @@ module RuboCop
           end
         end
 
+        def no_code_after?(range)
+          trailing = processed_source.lines[range.last_line - 1][range.last_column..].to_s.strip
+          trailing = trailing.sub(/\A;+\s*/, '')
+
+          trailing.empty? || trailing.start_with?('#')
+        end
+
         def autocorrect_sclass(node, corrector)
           rewritten_defs = []