rubocop 1.91.0 → 1.92.2

data/lib/rubocop/cop/mixin/pattern_matching_help.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # Common functionality for checking whether a node is used in a pattern of
+    # pattern matching, where only some expressions are allowed.
+    module PatternMatchingHelp
+      PATTERN_TYPES = %i[
+        array_pattern array_pattern_with_tail begin const_pattern find_pattern hash_pattern
+        match_alt match_as pair
+      ].freeze
+
+      private
+
+      def in_pattern?(node)
+        child = node
+
+        node.each_ancestor do |ancestor|
+          case ancestor.type
+          when :in_pattern
+            return ancestor.pattern.equal?(child)
+          when :match_pattern, :match_pattern_p
+            return ancestor.children[1].equal?(child)
+          when *PATTERN_TYPES
+            child = ancestor
+          else
+            return false
+          end
+        end
+
+        false
+      end
+    end
+  end
+end

data/lib/rubocop/cop/mixin/preceding_following_alignment.rb

@@ -174,8 +174,13 @@ module RuboCop
           #                ^
           tokens = remove_equals_in_def(tokens, processed_source)
 
-          # Only attempt to align the first = on each line
-          Set.new(tokens.uniq(&:line))
+          # Only attempt to align the first = on each line. An `=` that comes after a comparison
+          # on its line is left out as well: whether a line is aligned is judged by its first
+          # assignment or comparison operator, so such an `=` could never be found aligned
+          # and `Layout/SpaceAroundOperators` would keep undoing the padding added for it.
+          Set.new(tokens.uniq(&:line).select do |token|
+            first_operator_on_line(token.line).equal?(token)
+          end)
         end
       end
 
@@ -270,6 +275,16 @@ module RuboCop
 
         asgn_tokens.reject { |t| eqls_to_ignore.include?(t.begin_pos) }
       end
+
+      def first_operator_on_line(line)
+        @first_operator_by_line ||= processed_source.tokens.each_with_object({}) do |token, by_line|
+          next unless ASSIGNMENT_OR_COMPARISON_TOKENS.include?(token.type)
+
+          by_line[token.line] ||= token
+        end
+
+        @first_operator_by_line[line]
+      end
     end
   end
 end

data/lib/rubocop/cop/mixin/project_index_help.rb

@@ -119,6 +119,21 @@ module RuboCop
         end
       end
 
+      # Whether the `def`/`defs` node overrides a method defined by an ancestor
+      # of its enclosing class or module elsewhere in the project.
+      def overrides_inherited_method?(def_node)
+        return false unless project_index
+        return false unless (namespace_node = def_node.each_ancestor(:class, :module).first)
+
+        declaration = resolve_constant_in_index(namespace_node.identifier)
+        return false unless declaration.is_a?(Rubydex::Namespace)
+
+        scope = def_node.defs_type? ? indexed_singleton_of(declaration) : declaration
+        !scope.nil? && inherited_index_member?(scope, "#{def_node.method_name}()")
+      rescue StandardError
+        false
+      end
+
       # Whether every link of the declaration's ancestry is resolved in the
       # index: no definition of any ancestor has an unresolved superclass or
       # mixin reference. Unresolved links silently vanish from `ancestors`,

data/lib/rubocop/cop/mixin/reparsed_equivalence.rb

@@ -51,15 +51,25 @@ module RuboCop
       # regardless of size (for cops where verification is the offense logic).
       def verified_by_reparse(items, oversized: :report)
         scope_groups(items).flat_map do |scope, group|
-          if (oversized == :report && verification_too_large?(scope)) ||
-             (group.size > 1 && corrections_verify?(scope, group))
+          if oversized == :report && verification_too_large?(scope)
             group
           else
-            group.select { |item| corrections_verify?(scope, [item]) }
+            verified_subset(scope, group)
           end
         end
       end
 
+      # Verifies a group with a single reparse and bisects it when that fails,
+      # so a few significant items among many cost a logarithmic number of
+      # reparses rather than one each.
+      def verified_subset(scope, group)
+        return group if corrections_verify?(scope, group)
+        return [] if group.one?
+
+        half = group.size / 2
+        verified_subset(scope, group.take(half)) + verified_subset(scope, group.drop(half))
+      end
+
       # Whether the exact correction for `item` produces source that still
       # parses, without requiring an equivalent AST. For corrections that
       # intentionally change the tree.

data/lib/rubocop/cop/mixin/statement_modifier.rb

@@ -7,6 +7,8 @@ module RuboCop
       include LineLengthHelp
       include AllowedPattern
 
+      SPACE_INSIDE_PARENS_STYLES = %w[space compact].freeze
+
       private
 
       def single_line_as_modifier?(node)
@@ -42,7 +44,10 @@ module RuboCop
       def modifier_fits_on_single_line?(node)
         return true unless max_line_length
 
-        line_length(line_in_modifier_form(node)) <= max_line_length
+        length = line_length(line_in_modifier_form(node))
+        length += 2 if parenthesize?(node) && space_inside_parens?
+
+        length <= max_line_length
       end
 
       def line_in_modifier_form(node)
@@ -52,6 +57,14 @@ module RuboCop
         "#{code_before}#{to_modifier_form(node)}#{code_after(node)}"
       end
 
+      def space_inside_parens?
+        return false unless config.cop_enabled?('Layout/SpaceInsideParens')
+
+        style = config.for_cop('Layout/SpaceInsideParens')['EnforcedStyle']
+
+        SPACE_INSIDE_PARENS_STYLES.include?(style)
+      end
+
       # Whether an existing line is acceptable to `Layout/LineLength`,
       # exemptions (the cop disabled at that line, an allowed pattern, an
       # allowed cop directive, an allowed URI) included. Only for judging
@@ -96,15 +109,22 @@ module RuboCop
         [parenthesized, first_line_comment(node)].compact.join(' ')
       end
 
+      # rubocop:disable-next Metrics/AbcSize
       def if_body_source(if_body)
-        if if_body.call_type? && !if_body.method?(:[]=) && omitted_value_in_last_hash_arg?(if_body)
+        if unparenthesized_call_with_omitted_value?(if_body)
           "#{method_source(if_body)}(#{if_body.arguments.map(&:source).join(', ')})"
+        elsif (value = wrapped_value(if_body))
+          prefix = if_body.source_range.begin.join(value.source_range.begin).source
+          suffix = value.source_range.end.join(if_body.source_range.end).source
+
+          "#{prefix}#{if_body_source(value)}#{suffix}"
         else
           if_body.source
         end
       end
 
-      def omitted_value_in_last_hash_arg?(if_body)
+      def unparenthesized_call_with_omitted_value?(if_body)
+        return false if !if_body.call_type? || if_body.method?(:[]=) || if_body.parenthesized?
         return false unless (last_argument = if_body.last_argument)
 
         last_argument.hash_type? && last_argument.pairs.last&.value_omission?
@@ -116,6 +136,14 @@ module RuboCop
         if_body.source_range.begin.join(end_range).source
       end
 
+      def wrapped_value(if_body)
+        if if_body.type?(:return, :next, :break)
+          if_body.first_argument if if_body.arguments.one?
+        elsif if_body.type?(:lvasgn, :ivasgn, :cvasgn, :gvasgn, :casgn)
+          if_body.expression
+        end
+      end
+
       def first_line_comment(node)
         comment = processed_source.comment_at_line(node.first_line)
         return unless comment
@@ -137,9 +165,15 @@ module RuboCop
         parent = node.parent
         return false if parent.nil?
         return true if parent.assignment? || parent.operator_keyword?
-        return true if %i[array pair].include?(parent.type)
+        return true if parent.type?(:array, :pair, :call, :yield, :super)
+
+        ternary_branch_or_endless_method_body?(parent)
+      end
+
+      def ternary_branch_or_endless_method_body?(parent)
+        return parent.ternary? if parent.if_type?
 
-        node.parent.send_type?
+        parent.any_def_type? && parent.endless?
       end
 
       def comment_disables_cop?(comment)

data/lib/rubocop/cop/mixin/trailing_comma.rb

@@ -163,7 +163,7 @@ module RuboCop
 
       def put_comma(items, kind)
         last_item = items.last
-        return if last_item.block_pass_type?
+        return if last_item.type?(:block_pass, :forwarded_args)
 
         range = autocorrect_range(last_item)
         msg = format(MSG, command: 'Put a', unit: format(kind, article: 'a multiline'))

data/lib/rubocop/cop/mixin/visibility_help.rb

@@ -63,9 +63,10 @@ module RuboCop
         (send nil? VISIBILITY_SCOPES def)
       PATTERN
 
+      # A modifier applies to every symbol it is given, not only to a sole argument.
       # @!method visibility_inline_on_method_name?(node, method_name:)
       def_node_matcher :visibility_inline_on_method_name?, <<~PATTERN
-        (send nil? VISIBILITY_SCOPES (sym %method_name))
+        (send nil? VISIBILITY_SCOPES <(sym %method_name) ...>)
       PATTERN
     end
   end

data/lib/rubocop/cop/mixin.rb

@@ -32,6 +32,7 @@ module RuboCop
     autoload :AnnotationComment, "#{__dir__}/mixin/annotation_comment"
     autoload :EmptyParameter, "#{__dir__}/mixin/empty_parameter"
     autoload :EndKeywordAlignment, "#{__dir__}/mixin/end_keyword_alignment"
+    autoload :EndlessMethodBodyHelp, "#{__dir__}/mixin/endless_method_body_help"
     autoload :EndlessMethodRewriter, "#{__dir__}/mixin/endless_method_rewriter"
     autoload :EnforceSuperclass, "#{__dir__}/mixin/enforce_superclass"
     autoload :FirstElementLineBreak, "#{__dir__}/mixin/first_element_line_break"
@@ -64,6 +65,7 @@ module RuboCop
     autoload :OnNormalIfUnless, "#{__dir__}/mixin/on_normal_if_unless"
     autoload :OrderedGemNode, "#{__dir__}/mixin/ordered_gem_node"
     autoload :Parentheses, "#{__dir__}/mixin/parentheses"
+    autoload :PatternMatchingHelp, "#{__dir__}/mixin/pattern_matching_help"
     autoload :PercentArray, "#{__dir__}/mixin/percent_array"
     autoload :PercentLiteral, "#{__dir__}/mixin/percent_literal"
     autoload :PrecedingFollowingAlignment, "#{__dir__}/mixin/preceding_following_alignment"

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

@@ -80,22 +80,6 @@ module RuboCop
             node.arguments.one? &&
             node.first_argument.arg_type?
         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/naming/block_forwarding.rb

@@ -63,7 +63,7 @@ module RuboCop
 
         def self.autocorrect_incompatible_with
           [
-            Lint::AmbiguousOperator, Style::ArgumentsForwarding,
+            Lint::AmbiguousOperator, Style::ArgumentsForwarding, Style::EndlessMethod,
             Style::ExplicitBlockArgument, Style::MethodDefParentheses
           ]
         end

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

@@ -35,7 +35,7 @@ module RuboCop
         MSG = 'Use %<style>s heredoc delimiters.'
 
         def on_heredoc(node)
-          return if correct_case_delimiters?(node)
+          return if correct_case_delimiters?(node) || corrected_delimiter_in_body?(node)
 
           add_offense(node.loc.heredoc_end) do |corrector|
             expr = node.source_range
@@ -52,7 +52,14 @@ module RuboCop
         end
 
         def correct_case_delimiters?(node)
-          delimiter_string(node) == correct_delimiters(delimiter_string(node))
+          delimiters = delimiter_string(node)
+          delimiters == correct_delimiters(delimiters)
+        end
+
+        def corrected_delimiter_in_body?(node)
+          corrected = correct_delimiters(delimiter_string(node))
+
+          node.loc.heredoc_body.source.each_line.any? { |line| line.strip == corrected }
         end
 
         def correct_delimiters(source)

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

@@ -43,9 +43,11 @@ module RuboCop
 
           return false unless /\w/.match?(delimiters)
 
-          forbidden_delimiters.none? do |forbidden_delimiter|
-            Regexp.new(forbidden_delimiter).match?(delimiters)
-          end
+          forbidden_delimiter_regexps.none? { |regexp| regexp.match?(delimiters) }
+        end
+
+        def forbidden_delimiter_regexps
+          @forbidden_delimiter_regexps ||= forbidden_delimiters.map { |d| Regexp.new(d) }
         end
 
         def forbidden_delimiters

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/naming/rescued_exceptions_variable_name.rb

@@ -128,7 +128,7 @@ module RuboCop
             if child_node.lvar_type?
               parent_node = child_node.parent
               if parent_node.respond_to?(:value_omission?) && parent_node.value_omission?
-                corrector.insert_after(parent_node.loc.operator, " #{preferred_name}")
+                corrector.replace(parent_node.loc.operator, ": #{preferred_name}")
               else
                 corrector.replace(child_node, preferred_name)
               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

@@ -132,10 +132,11 @@ module RuboCop
       #     private alias_method :qux, :foo
       #
       #   end
-      class AccessModifierDeclarations < Base
+      class AccessModifierDeclarations < Base # rubocop:disable Metrics/ClassLength
         extend AutoCorrector
 
         include ConfigurableEnforcedStyle
+        include EndlessMethodBodyHelp
         include RangeHelp
 
         GROUP_STYLE_MESSAGE = [
@@ -169,6 +170,10 @@ module RuboCop
             (send nil? :alias_method _ _))
         PATTERN
 
+        def self.autocorrect_incompatible_with
+          [Style::EndlessMethod, Style::SingleLineMethods]
+        end
+
         def on_send(node)
           return if allowed?(node)
 
@@ -187,11 +192,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
@@ -241,10 +253,33 @@ module RuboCop
 
             access_modifier_is_inlined?(node) && !right_siblings_same_inline_method?(node)
           else
-            access_modifier_is_not_inlined?(node) && select_grouped_def_nodes(node).any?
+            access_modifier_is_not_inlined?(node) && inlinable?(select_grouped_def_nodes(node))
           end
         end
 
+        def inlinable?(def_nodes)
+          return false if def_nodes.empty?
+
+          def_nodes.none? { |def_node| def_node.endless? && body_unsafe_to_inline?(def_node.body) }
+        end
+
+        def body_unsafe_to_inline?(body)
+          return true if body.each_node(:any_block).any? { |block| do_end_block?(block) }
+
+          target_ruby_version < 4.0 && command_body?(body)
+        end
+
+        def do_end_block?(block)
+          block.keywords? && !block.send_node.lambda_literal?
+        end
+
+        def command_body?(body)
+          body = body.body while body.rescue_type?
+          return true if body.send_type? && body.prefix_not? && !body.parenthesized?
+
+          command_call?(body)
+        end
+
         def correctable_group_offense?(node)
           return false unless group_style?
           return false if allowed?(node)