rubocop 1.90.0 → 1.91.0

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

@@ -435,7 +435,7 @@ module RuboCop
 
         def anon_block_scope_id(anon_block)
           parent = anon_block.parent
-          return unless parent&.type?(:any_block, :begin, :call, :casgn, :any_def)
+          return unless parent&.type?(:any_block, :begin, :call, :casgn, :ivasgn, :any_def)
 
           if (receiver = scope_receiver(parent, anon_block))
             "#{receiver.source}.#{parent.method_name}"

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

@@ -63,7 +63,7 @@ module RuboCop
       class EmptyBlock < Base
         MSG = 'Empty block detected.'
 
-        def on_block(node) # rubocop:disable InternalAffairs/NumblockHandler, InternalAffairs/ItblockHandler
+        def on_block(node) # rubocop:disable InternalAffairs/NumblockHandler, InternalAffairs/ItblockHandler -- an empty block has no parameters to number
           return if node.body
           return if allow_empty_lambdas? && node.lambda_or_proc?
           return if cop_config['AllowComments'] && allow_comment?(node)

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

@@ -48,7 +48,7 @@ module RuboCop
           add_offense(node.lhs) do |corrector|
             # Don't autocorrect `'foo' && return` because having `return` as
             # the leftmost node can lead to a void value expression syntax error.
-            next if node.rhs.type?(:return, :break, :next)
+            next if void_value_expression?(node.rhs)
 
             corrector.replace(node, node.rhs.source)
           end
@@ -60,7 +60,7 @@ module RuboCop
           add_offense(node.lhs) do |corrector|
             # Don't autocorrect `'foo' && return` because having `return` as
             # the leftmost node can lead to a void value expression syntax error.
-            next if node.rhs.type?(:return, :break, :next)
+            next if void_value_expression?(node.rhs)
 
             corrector.replace(node, node.rhs.source)
           end
@@ -175,6 +175,12 @@ module RuboCop
 
         private
 
+        def void_value_expression?(node)
+          node = node.children.last while node&.begin_type?
+
+          node&.type?(:return, :break, :next)
+        end
+
         def check_for_literal(node)
           cond = condition(node)
           if cond.literal?

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

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

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

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-# rubocop:disable-next Lint/RedundantCopDisableDirective
+# rubocop:disable-next Lint/RedundantCopDisableDirective -- the examples below read as real directives
 module RuboCop
   module Cop
     module Lint

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

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

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

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

data/lib/rubocop/cop/lint/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

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-next Lint/RedundantCopDisableDirective
+# rubocop:disable-next Lint/RedundantCopDisableDirective -- the examples below read as real directives
 module RuboCop
   module Cop
     module Lint
@@ -155,17 +155,29 @@ module RuboCop
           end
         end
 
-        # A `disable-next` with no statement attached (or misplaced at the end
-        # of a code line) suppresses nothing, so it is redundant by definition.
+        # 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|
-            directive.raw_cop_names.each { |cop| yield directive.comment, cop }
+            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.push? || directive.pop? || directive.next?
         end
 
         def find_redundant_directive(cop, comment, line_range, next_range)
@@ -190,11 +202,11 @@ module RuboCop
 
             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)
@@ -280,18 +292,20 @@ 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(', ')
 
           # 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(cop_names))
+            return add_offense(location, message: message)
           end
 
-          add_offense(location, message: message(cop_names)) do |corrector|
+          add_offense(location, message: message) do |corrector|
             remove_entire_comment(corrector, comment)
           end
         end
@@ -333,7 +347,7 @@ module RuboCop
 
         def misplaced_next_directive?(comment)
           directive = DirectiveComment.new(comment)
-          directive.disable_next? &&
+          (directive.disable_next? || directive.next? || directive.enable_next?) &&
             !processed_source.comment_config.comment_only_line?(directive.line_number)
         end
 
@@ -396,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

data/lib/rubocop/cop/lint.rb

@@ -76,6 +76,7 @@ module RuboCop
       register_cop :LiteralAssignmentInCondition, "#{__dir__}/lint/literal_assignment_in_condition"
       register_cop :LiteralInInterpolation, "#{__dir__}/lint/literal_in_interpolation"
       register_cop :Loop, "#{__dir__}/lint/loop"
+      register_cop :MisplacedMagicComment, "#{__dir__}/lint/misplaced_magic_comment"
       register_cop :MissingCopEnableDirective, "#{__dir__}/lint/missing_cop_enable_directive"
       register_cop :MissingSuper, "#{__dir__}/lint/missing_super"
       register_cop :MixedCaseRange, "#{__dir__}/lint/mixed_case_range"

data/lib/rubocop/cop/migration/department_name.rb

@@ -2,7 +2,7 @@
 
 # Lint/RedundantCopDisableDirective needs to be disabled so as
 # to be able to provide examples of rubocop:disable comments.
-# rubocop:disable-next Lint/RedundantCopDisableDirective
+# rubocop:disable-next Lint/RedundantCopDisableDirective -- the examples below read as real directives
 module RuboCop
   module Cop
     module Migration

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

@@ -66,7 +66,7 @@ module RuboCop
       end
 
       # @deprecated Use processed_source.line_with_comment?(line)
-      def end_of_line_comment(line) # rubocop:disable Naming/PredicateMethod
+      def end_of_line_comment(line) # rubocop:disable Naming/PredicateMethod -- a deprecated shim kept under its original name
         warn Rainbow(<<~WARNING).yellow, uplevel: 1
           `end_of_line_comment` is deprecated. Use `processed_source.line_with_comment?` instead.
         WARNING

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

@@ -45,7 +45,7 @@ module RuboCop
         match.captures
       end
 
-      KEYWORDS_REGEX_CACHE = {} # rubocop:disable Style/MutableConstant
+      KEYWORDS_REGEX_CACHE = {} # rubocop:disable Style/MutableConstant -- a cache, written to at runtime
       private_constant :KEYWORDS_REGEX_CACHE
 
       def regex

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

@@ -55,7 +55,7 @@ module RuboCop
       # Common functionality for checking alignment of hash values.
       module ValueAlignment
         def checkable_layout?(node)
-          !node.pairs_on_same_line? && !node.mixed_delimiters?
+          !node.pairs_on_same_line? && !node.mixed_delimiters? && alignable_values?(node)
         end
 
         def deltas(first_pair, current_pair)
@@ -68,6 +68,16 @@ module RuboCop
 
         private
 
+        def alignable_values?(node)
+          return false if node.pairs.first.value_omission?
+
+          node.pairs.none? { |pair| value_on_later_line?(pair) }
+        end
+
+        def value_on_later_line?(pair)
+          pair.value && pair.key.last_line != pair.value.first_line
+        end
+
         def separator_delta(first_pair, current_pair, key_delta)
           if current_pair.hash_rocket?
             hash_rocket_delta(first_pair, current_pair) - key_delta

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

@@ -87,13 +87,17 @@ module RuboCop
       def ignore_mixed_hash_shorthand_syntax?(hash_node)
         target_ruby_version <= 3.0 ||
           !%w[consistent either_consistent].include?(enforced_shorthand_syntax) ||
-          !hash_node.hash_type?
+          !hash_node.hash_type? || hash_rockets_enforced?(hash_node)
       end
 
       def ignore_hash_shorthand_syntax?(pair_node)
         target_ruby_version <= 3.0 || enforced_shorthand_syntax == 'either' ||
           %w[consistent either_consistent].include?(enforced_shorthand_syntax) ||
-          !pair_node.parent.hash_type?
+          !pair_node.parent.hash_type? || hash_rockets_enforced?(pair_node.parent)
+      end
+
+      def hash_rockets_enforced?(hash_node)
+        style == :hash_rockets || force_hash_rockets?(hash_node.pairs)
       end
 
       def enforced_shorthand_syntax

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

@@ -38,7 +38,7 @@ module RuboCop
          (block (send _ :each_with_object (hash)) ...)}
       PATTERN
 
-      def on_block(node) # rubocop:disable InternalAffairs/NumblockHandler, InternalAffairs/ItblockHandler
+      def on_block(node) # rubocop:disable InternalAffairs/NumblockHandler, InternalAffairs/ItblockHandler -- the patterns matched here all name their block parameters
         on_bad_each_with_object(node) do |*match|
           handle_possible_offense(node, match, 'each_with_object')
         end

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

@@ -182,7 +182,18 @@ module RuboCop
       # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity
       # rubocop:disable Metrics/PerceivedComplexity, Metrics/MethodLength
       def relevant_assignment_lines(line_range)
-        relevant_lines(line_range) { |line_number| assignment_lines.include?(line_number) }
+        relevant_lines(line_range, interrupting_operator_lines) do |line_number|
+          assignment_lines.include?(line_number)
+        end
+      end
+
+      def interrupting_operator_lines
+        @interrupting_operator_lines ||=
+          processed_source.tokens.each_with_object(Set.new) do |token, lines|
+            next unless ASSIGNMENT_OR_COMPARISON_TOKENS.include?(token.type)
+
+            lines << token.line unless assignment_lines.include?(token.line)
+          end
       end
 
       def alignment_lines(line_number)

data/lib/rubocop/cop/mixin.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 module RuboCop
-  module Cop # rubocop:disable Style/Documentation
+  module Cop # rubocop:disable Style/Documentation -- a namespace that only autoloads the mixins below
     # Autoloads mixin modules included by cops. Mixins are autoloaded to reduce the number of
     # requires because they're used only when the relevant cop class is loaded.
 
@@ -14,7 +14,7 @@ module RuboCop
     autoload :AllowedReceivers, "#{__dir__}/mixin/allowed_receivers"
     autoload :ForbiddenIdentifiers, "#{__dir__}/mixin/forbidden_identifiers"
     autoload :ForbiddenPattern, "#{__dir__}/mixin/forbidden_pattern"
-    autoload :AutoCorrector, "#{__dir__}/mixin/auto_corrector" # rubocop:todo Naming/InclusiveLanguage
+    autoload :AutoCorrector, "#{__dir__}/mixin/auto_corrector" # rubocop:todo Naming/InclusiveLanguage -- the file is named `auto_corrector.rb`
     autoload :CheckAssignment, "#{__dir__}/mixin/check_assignment"
     autoload :CheckLineBreakable, "#{__dir__}/mixin/check_line_breakable"
     autoload :CheckSingleLineSuitability, "#{__dir__}/mixin/check_single_line_suitability"

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

@@ -62,7 +62,10 @@ module RuboCop
         MSG = 'Use %<style>s block forwarding.'
 
         def self.autocorrect_incompatible_with
-          [Lint::AmbiguousOperator, Style::ArgumentsForwarding, Style::ExplicitBlockArgument]
+          [
+            Lint::AmbiguousOperator, Style::ArgumentsForwarding,
+            Style::ExplicitBlockArgument, Style::MethodDefParentheses
+          ]
         end
 
         def on_def(node)

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

@@ -38,7 +38,7 @@ module RuboCop
       class BlockParameterName < Base
         include UncommunicativeName
 
-        def on_block(node) # rubocop:disable InternalAffairs/NumblockHandler, InternalAffairs/ItblockHandler
+        def on_block(node) # rubocop:disable InternalAffairs/NumblockHandler, InternalAffairs/ItblockHandler -- there are no parameter names to check
           return unless node.arguments?
 
           check(node, node.arguments)

data/lib/rubocop/cop/registry.rb

@@ -280,6 +280,12 @@ module RuboCop
         config.enabled_new_cop?(cop_name)
       end
 
+      # Preview cops are opt-in and stay silent otherwise, so unlike pending cops
+      # they are never reported as needing a decision.
+      def enabled_preview_cop?(cop_cfg, config)
+        cop_cfg.fetch('Enabled') == 'preview' && config.preview?(@options)
+      end
+
       def names
         clear_enrollment_queue
         @cops_by_badge.keys.map(&:to_s)
@@ -420,7 +426,9 @@ module RuboCop
         # caching which expects cop names or cop classes as keys.
         cfg = config.for_cop(cop_name)
 
-        cop_enabled = cfg.fetch('Enabled') == true || enabled_pending_cop?(cfg, config, cop_name)
+        cop_enabled = cfg.fetch('Enabled') == true ||
+                      enabled_pending_cop?(cfg, config, cop_name) ||
+                      enabled_preview_cop?(cfg, config)
 
         if options.fetch(:safe, false)
           cop_enabled && cfg.fetch('Safe', true)

data/lib/rubocop/cop/severity.rb

@@ -21,6 +21,18 @@ module RuboCop
       #   any of `:info`, `:refactor`, `:convention`, `:warning`, `:error` or `:fatal`.
       attr_reader :name
 
+      # The lowest severity that makes a run fail: `--fail-level` when given,
+      # otherwise `AllCops: FailLevel`. `autocorrect` is a pseudo level on the
+      # command line that gates on corrections instead, so it leaves the
+      # threshold at the configured one.
+      def self.minimum_to_fail(options, config)
+        name = options[:fail_level]
+        if name.nil? || name == :autocorrect
+          name = (config&.for_all_cops&.[]('FailLevel') || :refactor).to_sym
+        end
+        new(name)
+      end
+
       def self.name_from_code(code)
         name = code.to_sym
         CODE_TABLE[name] || name

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

@@ -316,7 +316,7 @@ module RuboCop
         end
 
         def select_grouped_def_nodes(node)
-          node.right_siblings.take_while do |sibling|
+          node.right_siblings.compact.take_while do |sibling|
             !(sibling.send_type? && sibling.bare_access_modifier_declaration?)
           end.select(&:def_type?)
         end
@@ -347,7 +347,8 @@ module RuboCop
         end
 
         def remove_modifier_node_within_begin(corrector, modifier_node, begin_node)
-          def_node = begin_node.children[begin_node.children.index(modifier_node) + 1]
+          modifier_index = begin_node.children.find_index { |child| child.equal?(modifier_node) }
+          def_node = begin_node.children[modifier_index + 1]
           # Stop the removal range at the first comment that precedes the def, if
           # any exist. Without this, comments between the modifier and the def are
           # dropped because they fall inside the removed range.

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

@@ -202,7 +202,7 @@ module RuboCop
           rest_arg, kwrest_arg, block_arg = *forwardable_args
           registered_block_arg_offense = false
 
-          send_classifications.each do |send_node, c, forward_rest, forward_kwrest, forward_block_arg| # rubocop:disable Layout/LineLength
+          send_classifications.each do |send_node, c, forward_rest, forward_kwrest, forward_block_arg| # rubocop:disable Layout/LineLength -- the block parameter list does not wrap
             if !forward_rest && !forward_kwrest && c != :all_anonymous
               if allow_anonymous_forwarding_in_block?(forward_block_arg)
                 register_forward_block_arg_offense(!forward_rest, node.arguments, block_arg)
@@ -232,7 +232,7 @@ module RuboCop
 
           rest_arg, kwrest_arg, block_arg = *forwardable_args
 
-          send_classifications.each do |send_node, _c, forward_rest, forward_kwrest, forward_block_arg| # rubocop:disable Layout/LineLength
+          send_classifications.each do |send_node, _c, forward_rest, forward_kwrest, forward_block_arg| # rubocop:disable Layout/LineLength -- the block parameter list does not wrap
             if allow_anonymous_forwarding_in_block?(forward_rest)
               register_forward_args_offense(def_node.arguments, rest_arg)
               register_forward_args_offense(send_node, forward_rest)