rubocop 1.90.0 → 1.91.0

data/lib/rubocop/config_validator.rb

@@ -11,7 +11,7 @@ module RuboCop
     COMMON_PARAMS = %w[Exclude Include Severity inherit_mode AutoCorrect StyleGuide Details
                        Enabled Reference References Safe SafeAutoCorrect].freeze
     # @api private
-    INTERNAL_PARAMS = %w[Description StyleGuide
+    INTERNAL_PARAMS = %w[Description StyleGuide Preview
                          VersionAdded VersionChanged VersionRemoved
                          Reference References Safe SafeAutoCorrect].freeze
     # @api private
@@ -21,7 +21,7 @@ module RuboCop
 
     # @api private
     CONFIG_CHECK_KEYS = %w[Enabled Safe SafeAutoCorrect AutoCorrect References].to_set.freeze
-    CONFIG_CHECK_DEPARTMENTS = %w[pending override_department].freeze
+    CONFIG_CHECK_DEPARTMENTS = %w[pending preview override_department].freeze
     CONFIG_CHECK_AUTOCORRECTS = %w[always contextual disabled].freeze
     private_constant :CONFIG_CHECK_KEYS, :CONFIG_CHECK_DEPARTMENTS
 
@@ -48,7 +48,7 @@ module RuboCop
 
       check_obsoletions
       alert_about_unrecognized_cops(invalid_cop_names)
-      validate_new_cops_parameter
+      validate_all_cops_parameters
       validate_parameter_names(valid_cop_names)
       validate_enforced_styles(valid_cop_names)
       validate_syntax_cop
@@ -170,6 +170,21 @@ module RuboCop
       validate_department_new_cops_parameters
     end
 
+    def validate_all_cops_parameters
+      validate_new_cops_parameter
+      validate_fail_level_parameter
+    end
+
+    def validate_fail_level_parameter
+      fail_level = @config.for_all_cops['FailLevel']
+      return if fail_level.nil? || Cop::Severity::NAMES.include?(fail_level.to_sym)
+
+      message = "invalid #{fail_level} for `FailLevel` found in #{smart_loaded_path}\n" \
+                "Valid choices are: #{Cop::Severity::NAMES.join(', ')}"
+
+      raise ValidationError, message
+    end
+
     def validate_all_cops_new_cops_parameter
       new_cop_parameter = @config.for_all_cops['NewCops']
       return if new_cop_parameter.nil? || NEW_COPS_VALUES.include?(new_cop_parameter)

data/lib/rubocop/cop/badge.rb

@@ -45,7 +45,7 @@ module RuboCop
 
       def hash
         # Do hashing manually to reduce Array allocations.
-        department.hash ^ cop_name.hash # rubocop:disable Security/CompoundHash
+        department.hash ^ cop_name.hash # rubocop:disable Security/CompoundHash -- hashing manually avoids the Array allocation
       end
 
       def match?(other)

data/lib/rubocop/cop/base.rb

@@ -49,7 +49,12 @@ module RuboCop
       InvestigationReport = Struct.new(:cop, :processed_source, :offenses, :corrector)
 
       # List of methods names to restrict calls for `on_send` / `on_csend`
-      RESTRICT_ON_SEND = Set[].freeze # rubocop:disable InternalAffairs/UselessRestrictOnSend
+      RESTRICT_ON_SEND = Set[].freeze # rubocop:disable InternalAffairs/UselessRestrictOnSend -- the base class default, which cops override
+
+      # Departments whose cops report above `convention` unless a cop says
+      # otherwise. The exceptions live in `config/default.yml` as an explicit
+      # `Severity`, such as the lint-like cops in `Bundler` and `Gemspec`.
+      DEPARTMENT_SEVERITIES = { Lint: :warning, Security: :warning, Metrics: :refactor }.freeze
 
       # List of cops that should not try to autocorrect at the same
       # time as this cop
@@ -288,6 +293,13 @@ module RuboCop
         @config.string_literals_frozen_by_default?
       end
 
+      # Whether the user opted in to unstable behavior, with `--preview` or
+      # `AllCops: Preview`. Cops branch on this to ship a change that is not
+      # ready to be the default yet.
+      def preview?
+        @config.preview?(@options)
+      end
+
       def relevant_file?(file)
         return false unless target_satisfies_all_gem_version_requirements?
         return true unless @config.clusivity_config_for_badge?(self.class.badge)
@@ -326,7 +338,7 @@ module RuboCop
 
       ### Reserved for Commissioner
 
-      # rubocop:disable Layout/ClassStructure
+      # rubocop:disable Layout/ClassStructure -- grouped under the Commissioner heading above
       # @api private
       def callbacks_needed
         self.class.callbacks_needed
@@ -561,7 +573,7 @@ module RuboCop
       end
 
       def default_severity
-        self.class.lint? ? :warning : :convention
+        DEPARTMENT_SEVERITIES.fetch(self.class.department, :convention)
       end
 
       def custom_severity

data/lib/rubocop/cop/correctors.rb

@@ -1,11 +1,11 @@
 # frozen_string_literal: true
 
 module RuboCop
-  module Cop # rubocop:disable Style/Documentation
+  module Cop # rubocop:disable Style/Documentation -- a namespace that only autoloads the correctors below
     # Autoloads corrector classes used by cops. Classes are autoloaded to reduce the number of
     # required classes because they're referenced only when autocorrection is performed.
 
-    # rubocop:disable Layout/LineLength
+    # rubocop:disable Layout/LineLength -- the autoload paths do not wrap
     autoload :AlignmentCorrector, 'rubocop/cop/correctors/alignment_corrector'
     autoload :ConditionCorrector, 'rubocop/cop/correctors/condition_corrector'
     autoload :EachToForCorrector, 'rubocop/cop/correctors/each_to_for_corrector'

data/lib/rubocop/cop/gemspec/require_mfa.rb

@@ -92,7 +92,7 @@ module RuboCop
           (str "true")
         PATTERN
 
-        def on_block(node) # rubocop:disable Metrics/MethodLength, InternalAffairs/NumblockHandler, InternalAffairs/ItblockHandler
+        def on_block(node) # rubocop:disable Metrics/MethodLength, InternalAffairs/NumblockHandler, InternalAffairs/ItblockHandler -- the gemspec block is matched by its named block variable
           gem_specification(node) do |block_var|
             metadata_value = metadata(node)
             mfa_value = mfa_value(metadata_value)

data/lib/rubocop/cop/generator.rb

@@ -147,7 +147,7 @@ module RuboCop
                                     badge: badge,
                                     version_added: version_added)
 
-        injector.inject do # rubocop:disable Lint/UnexpectedBlockArity
+        injector.inject do # rubocop:disable Lint/UnexpectedBlockArity -- this `inject` is the injector API, not `Enumerable#inject`
           output.puts(format(CONFIGURATION_ADDED_MESSAGE,
                              configuration_file_path: config_file_path))
         end

data/lib/rubocop/cop/internal_affairs/on_send_without_on_csend.rb

@@ -75,7 +75,7 @@ module RuboCop
           @on_csend_definition = node if node.new_identifier.value == :on_csend
         end
 
-        def on_send(node) # rubocop:disable InternalAffairs/OnSendWithoutOnCSend
+        def on_send(node) # rubocop:disable InternalAffairs/OnSendWithoutOnCSend -- this cop is what enforces the rule, and does not apply to itself
           return unless (new_identifier = node.first_argument)
           return unless new_identifier.basic_literal?
 

data/lib/rubocop/cop/layout/argument_alignment.rb

@@ -81,6 +81,8 @@ module RuboCop
           last_arg = node.last_argument
 
           if last_arg.hash_type? && !last_arg.braces?
+            return items if enforce_hash_argument_with_separator?
+
             items += last_arg.pairs
           else
             items << last_arg

data/lib/rubocop/cop/layout/comment_indentation.rb

@@ -64,10 +64,10 @@ module RuboCop
           autocorrect_one(corrector, comment)
         end
 
-        # Corrects all comment lines that occur immediately before the given
-        # comment and have the same indentation. This is to avoid a long chain
-        # of correcting, saving the file, parsing and inspecting again, and
-        # then correcting one more line, and so on.
+        # Corrects all preceding comment lines that have the same indentation
+        # and are separated from the given comment by nothing but blank lines.
+        # This is to avoid a long chain of correcting, saving the file, parsing
+        # and inspecting again, and then correcting one more line, and so on.
         def autocorrect_preceding_comments(corrector, comment)
           comments = processed_source.comments
           index = comments.index(comment)
@@ -82,7 +82,10 @@ module RuboCop
         def should_correct?(preceding_comment, reference_comment)
           loc = preceding_comment.loc
           ref_loc = reference_comment.loc
-          loc.line == ref_loc.line - 1 && loc.column == ref_loc.column
+          return false unless loc.column == ref_loc.column
+          return false unless own_line_comment?(preceding_comment)
+
+          ((loc.line + 1)...ref_loc.line).all? { |line| processed_source[line - 1].blank? }
         end
 
         def autocorrect_one(corrector, comment)

data/lib/rubocop/cop/layout/else_alignment.rb

@@ -93,6 +93,7 @@ module RuboCop
           when :def, :defs then base_for_method_definition(parent)
           when :kwbegin then parent.loc.begin
           when :block, :numblock, :itblock then start_line_range(parent)
+          when :class, :module, :sclass then parent.loc.keyword
           else node.loc.keyword
           end
         end

data/lib/rubocop/cop/layout/empty_lines_after_module_inclusion.rb

@@ -91,7 +91,7 @@ module RuboCop
         end
 
         def next_line_node(node)
-          return if node.parent.if_type?
+          return if node.parent.type?(:if, :rescue, :ensure)
 
           node.right_sibling
         end

data/lib/rubocop/cop/layout/first_array_element_indentation.rb

@@ -89,15 +89,16 @@ module RuboCop
               'in an array, relative to %<base_description>s.'
 
         def on_array(node)
-          return if style != :consistent && enforce_first_argument_with_fixed_indentation?
+          return unless node.loc.begin
+          return if autocorrect_incompatible_with_other_cops?(node, nil)
 
-          check(node, nil) if node.loc.begin
+          check(node, nil)
         end
 
         def on_send(node)
-          return if style != :consistent && enforce_first_argument_with_fixed_indentation?
-
           each_argument_node(node, :array) do |array_node, left_parenthesis|
+            next if autocorrect_incompatible_with_other_cops?(array_node, left_parenthesis)
+
             check(array_node, left_parenthesis)
           end
         end
@@ -105,6 +106,18 @@ module RuboCop
 
         private
 
+        def autocorrect_incompatible_with_other_cops?(array_node, left_parenthesis)
+          return false unless enforce_first_argument_with_fixed_indentation?
+          return true if style != :consistent
+
+          # `Layout/ArrayAlignment` does not align single-element arrays.
+          return false if array_node.children.size < 2
+
+          _base_column, indent_base_type =
+            indent_base(array_node.loc.begin, array_node.values.first, left_parenthesis)
+          indent_base_type != :start_of_line
+        end
+
         def autocorrect(corrector, node)
           AlignmentCorrector.correct(corrector, processed_source, node, @column_delta)
         end

data/lib/rubocop/cop/layout/first_parameter_indentation.rb

@@ -53,6 +53,7 @@ module RuboCop
         def on_def(node)
           return if node.arguments.empty?
           return if node.arguments.loc.begin.nil?
+          return if autocorrect_incompatible_with_other_cops?(node)
 
           check(node)
         end
@@ -60,6 +61,11 @@ module RuboCop
 
         private
 
+        def autocorrect_incompatible_with_other_cops?(node)
+          node.arguments.size >= 2 &&
+            style == :align_parentheses && enforce_parameter_with_fixed_indentation?
+        end
+
         def autocorrect(corrector, node)
           AlignmentCorrector.correct(corrector, processed_source, node, @column_delta)
         end
@@ -95,6 +101,11 @@ module RuboCop
             base_description: base_description
           )
         end
+
+        def enforce_parameter_with_fixed_indentation?
+          parameter_alignment_config = config.for_enabled_cop('Layout/ParameterAlignment')
+          parameter_alignment_config['EnforcedStyle'] == 'with_fixed_indentation'
+        end
       end
     end
   end

data/lib/rubocop/cop/layout/hash_alignment.rb

@@ -330,7 +330,11 @@ module RuboCop
         end
 
         def correct_no_value(corrector, key_delta, key)
-          adjust(corrector, key_delta, key)
+          adjust(corrector, clamped_key_delta(key_delta, key), key)
+        end
+
+        def clamped_key_delta(key_delta, key)
+          [key_delta, -key.column].max
         end
 
         def correct_key_value(corrector, delta, key, value, separator)
@@ -341,10 +345,7 @@ module RuboCop
           value_delta     = delta[:value]     || 0
           key_delta       = delta[:key]       || 0
 
-          key_column = key.column
-          key_delta = -key_column if key_delta < -key_column
-
-          adjust(corrector, key_delta, key)
+          adjust(corrector, clamped_key_delta(key_delta, key), key)
           adjust(corrector, separator_delta, separator)
           adjust(corrector, value_delta, value)
         end

data/lib/rubocop/cop/layout/indentation_width.rb

@@ -400,7 +400,7 @@ module RuboCop
           if body_node.rescue_type?
             check_rescue?(body_node)
           elsif body_node.ensure_type?
-            block_body, = *body_node # rubocop:disable InternalAffairs/NodeDestructuring
+            block_body, = *body_node # rubocop:disable InternalAffairs/NodeDestructuring -- `EnsureNode` has no accessor for the protected body
             if block_body&.rescue_type?
               check_rescue?(block_body)
             else
@@ -440,7 +440,7 @@ module RuboCop
                   begin_pos - indentation
                 end
 
-          pos = indentation >= 0 ? ind..begin_pos : begin_pos..ind
+          pos = ind <= begin_pos ? ind..begin_pos : begin_pos..ind
           range_between(pos.begin, pos.end)
         end
 

data/lib/rubocop/cop/layout/line_length.rb

@@ -104,6 +104,11 @@ module RuboCop
         alias on_defs on_def
 
         def on_new_investigation
+          @breakable_range_by_line_index = {}
+          @breakable_string_delimiters = {}
+          @endless_methods_by_line = {}
+          @heredocs = nil
+
           return unless processed_source.raw_source.include?(';')
 
           check_for_breakable_semicolons(processed_source)
@@ -288,7 +293,7 @@ module RuboCop
           source_range = node.source_range
           relevant_substr = largest_possible_string(node)
 
-          if (space_pos = relevant_substr.rindex(/\s/))
+          if (space_pos = breakable_space_position(node, relevant_substr))
             source_range.resize(space_pos + 1)
           elsif (escape_pos = relevant_substr.rindex(/\\(u[\da-f]{0,4}|x[\da-f]{0,2})?\z/))
             source_range.resize(escape_pos)
@@ -300,6 +305,19 @@ module RuboCop
           end
         end
 
+        def breakable_space_position(node, substr)
+          limit = string_content_length(node) - 1
+          space_pos = substr.rindex(/\s/)
+          space_pos = substr[0, limit].rindex(/\s/) if space_pos && space_pos + 1 > limit
+          space_pos
+        end
+
+        def string_content_length(node)
+          content_end = node.loc?(:end) ? node.loc.end.begin_pos : node.source_range.end_pos
+
+          content_end - node.source_range.begin_pos
+        end
+
         def breakable_dstr_begin_position(node)
           source_range = node.source_range
           source_range.begin_pos if source_range.column < max && source_range.last_column >= max

data/lib/rubocop/cop/layout/space_around_block_parameters.rb

@@ -5,7 +5,8 @@ module RuboCop
     module Layout
       # Checks the spacing inside and after block parameters pipes. Line breaks
       # inside parameter pipes are checked by `Layout/MultilineBlockLayout` and
-      # not by this cop.
+      # not by this cop. Spaces inside a lambda's parameter parentheses are left
+      # to `Layout/SpaceInsideParens` when that cop enforces a conflicting style.
       #
       # @example EnforcedStyleInsidePipes: no_space (default)
       #   # bad
@@ -29,12 +30,12 @@ module RuboCop
         include RangeHelp
         extend AutoCorrector
 
-        def on_block(node) # rubocop:disable InternalAffairs/NumblockHandler, InternalAffairs/ItblockHandler
+        def on_block(node) # rubocop:disable InternalAffairs/NumblockHandler, InternalAffairs/ItblockHandler -- checks spacing inside a block parameter list
           arguments = node.arguments
 
           return unless node.arguments? && pipes?(arguments)
 
-          check_inside_pipes(arguments)
+          check_inside_pipes(arguments) unless conflicting_space_inside_parens_style?(arguments)
           check_after_closing_pipe(arguments) if node.body
           check_each_arg(arguments)
         end
@@ -53,6 +54,16 @@ module RuboCop
           'EnforcedStyleInsidePipes'
         end
 
+        def conflicting_space_inside_parens_style?(arguments)
+          return false unless arguments.loc.begin.source == '('
+
+          case config.for_enabled_cop('Layout/SpaceInsideParens')['EnforcedStyle']
+          when 'no_space' then style == :space
+          when 'space', 'compact' then style == :no_space
+          else false
+          end
+        end
+
         def check_inside_pipes(arguments)
           case style
           when :no_space

data/lib/rubocop/cop/layout/space_around_operators.rb

@@ -258,7 +258,7 @@ module RuboCop
           return false unless allow_for_alignment?
           return false unless with_space.source.start_with?(EXCESSIVE_SPACE)
 
-          return !aligned_with_operator?(operator) unless type == :assignment
+          return !aligned_with_operator?(operator) unless grouped_alignment_type?(type)
 
           token            = Token.new(operator, nil, operator.source)
           align_preceding  = aligned_with_preceding_equals_operator(token)
@@ -269,6 +269,10 @@ module RuboCop
           aligned_with_subsequent_equals_operator(token) != :yes
         end
 
+        def grouped_alignment_type?(type)
+          type == :assignment || (type == :special_asgn && force_equal_sign_alignment?)
+        end
+
         def excess_trailing_space?(right_operand, with_space)
           with_space.source.end_with?(EXCESSIVE_SPACE) &&
             (!allow_for_alignment? || !aligned_with_something?(right_operand))

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

@@ -21,7 +21,9 @@ module RuboCop
       #
       # Constructor calls (`Foo.new`) and keyword-argument validation are out of
       # scope: only positional arity of explicitly defined singleton methods is
-      # checked.
+      # checked. `new` is skipped outright, because `Class#new` is not in the
+      # index: any `new` the index does find sits below it in the method
+      # resolution order, where Ruby would never reach it.
       #
       # @example
       #   # Given the project defines:
@@ -45,8 +47,7 @@ module RuboCop
         MSG = 'Wrong number of arguments to `%<method>s` (given %<given>d, expected %<expected>s).'
 
         def on_send(node)
-          return unless project_index
-          return unless node.receiver&.const_type?
+          return unless checkable_call?(node)
 
           shape = resolved_signature_shape(node)
           return unless shape
@@ -61,6 +62,10 @@ module RuboCop
 
         private
 
+        def checkable_call?(node)
+          project_index && node.receiver&.const_type? && !node.method?(:new)
+        end
+
         def message(node, given, min, max)
           format(MSG, method: node.method_name, given: given, expected: expected_range(min, max))
         end
@@ -77,9 +82,14 @@ module RuboCop
           nil
         end
 
+        # A call with an explicit receiver cannot reach a private method, so its
+        # signature says nothing about the call. This matters because `Object`
+        # closes the singleton ancestry of every constant, and a bare `def` at
+        # the top level of any file — what every block-based DSL produces — is a
+        # private instance method of `Object`.
         def singleton_signature_shape(declaration, method_name)
           member = indexed_singleton_member(declaration, "#{method_name}()")
-          return nil unless member
+          return nil unless member&.public?
 
           indexed_member_shape(member)
         end

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

@@ -106,6 +106,8 @@ module RuboCop
         def traverse_node(node, &block)
           # if the node is a block, any assignments are irrelevant
           return if node.any_block_type?
+          # an assignment inside `defined?` is never executed
+          return if node.defined_type?
 
           result = yield node if ASGN_TYPES.include?(node.type)
 

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

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-# rubocop:disable Lint/RedundantCopDisableDirective
-# rubocop:disable Style/DoubleCopDisableDirective
 module RuboCop
   module Cop
     module Lint
@@ -23,12 +21,11 @@ module RuboCop
       #   # good
       #   # rubocop:disable all
       #
-      #   # bad
+      #   # bad - only the first directive takes effect
       #   # rubocop:disable Layout/LineLength # rubocop:disable Style/Encoding
       #
       #   # good
-      #   # rubocop:disable Layout/LineLength
-      #   # rubocop:disable Style/Encoding
+      #   # rubocop:disable Layout/LineLength, Style/Encoding
       #
       #   # bad
       #   # rubocop:wrongmode Layout/LineLength
@@ -55,13 +52,19 @@ module RuboCop
       #   # rubocop:disable Layout/LineLength
       #
       class CopDirectiveSyntax < Base
+        extend AutoCorrector
+
         COMMON_MSG = 'Malformed directive comment detected.'
 
         MISSING_MODE_NAME_MSG = 'The mode name is missing.'
-        INVALID_MODE_NAME_MSG = 'The mode name must be one of `enable`, `disable`, `disable-next`, `todo`, `todo-next`, `push`, or `pop`.' # rubocop:disable Layout/LineLength
+        INVALID_MODE_NAME_MSG = 'The mode name must be one of `enable`, `disable`, `disable-next`, `enable-next`, `todo`, `todo-next`, `next`, `push`, or `pop`.' # rubocop:disable Layout/LineLength -- the message lists every mode and does not wrap
         MISSING_COP_NAME_MSG = 'The cop name is missing.'
+        MULTIPLE_DIRECTIVES_MSG = 'Only the first directive on a line takes effect. ' \
+                                  'List the cop names in a single directive instead.'
         MALFORMED_COP_NAMES_MSG = 'Cop names must be separated by commas. ' \
                                   'Comment in the directive must start with `--`.'
+        INVALID_SIGNED_ARGS_MSG = '`push` and `next` arguments must be `+`- or `-`-prefixed ' \
+                                  'cop names, and `pop` takes no arguments.'
         NEXT_DIRECTIVE_AT_EOL_MSG = 'A `-next` directive must be on its own line, above the ' \
                                     'statement it applies to.'
         INVALID_KEYWORD_MSG = 'The directive keyword must be `rubocop`, not `%<keyword>s`.'
@@ -89,7 +92,11 @@ module RuboCop
         private
 
         def check_directive(comment, directive_comment)
-          if directive_comment.malformed?
+          if (directives = multiple_directives(comment, directive_comment))
+            add_offense(comment, message: "#{COMMON_MSG} #{MULTIPLE_DIRECTIVES_MSG}") do |corrector|
+              merge_directives(corrector, comment, directives)
+            end
+          elsif directive_comment.malformed?
             add_offense(comment, message: offense_message(directive_comment))
           elsif misplaced_next_directive?(directive_comment)
             add_offense(comment, message: NEXT_DIRECTIVE_AT_EOL_MSG)
@@ -98,13 +105,72 @@ module RuboCop
           end
         end
 
-        # An EOL `disable-next` is not honored - it must fail loudly instead
-        # of silently doing nothing.
+        # Everything after the first directive in a comment is trailing text as
+        # far as the parser is concerned, so a second directive written on the
+        # same line disables nothing at all. A valid `--` reason may mention a
+        # directive as plain text, which should not be treated as another one.
+        def multiple_directives(comment, directive_comment)
+          matches = comment.text.to_enum(:scan, DirectiveComment::DIRECTIVE_COMMENT_REGEXP)
+                           .map { Regexp.last_match }
+          matches = filter_reason_matches(matches, directive_comment)
+
+          matches if matches.size > 1
+        end
+
+        def filter_reason_matches(matches, directive_comment)
+          return matches unless directive_comment.reason
+
+          [matches.first, *matches.drop(1).reject { |match| match.post_match.match?(/\S/) }]
+        end
+
+        def merge_directives(corrector, comment, directives)
+          return unless directives_adjacent?(comment, directives)
+          return unless (mode = merged_mode(directives))
+          return unless (cops = merged_cops(directives))
+
+          corrector.replace(comment, "# rubocop:#{mode} #{cops.join(', ')}")
+        end
+
+        # `all` covers every cop already, so folding it into a list of names
+        # would be a rewrite rather than a merge.
+        def merged_cops(directives)
+          cops = directives.flat_map { |match| match[2].to_s.split(',').map(&:strip) }
+          cops = cops.reject(&:empty?).uniq
+          cops unless cops.empty? || cops.include?('all')
+        end
+
+        # Anything written between the directives is a `--` reason or prose,
+        # and merging around it would either move it or drop it.
+        def directives_adjacent?(comment, directives)
+          text = comment.text
+          bounds = directives.map { |match| match.end(0) }
+                             .zip(directives.map { |match| match.begin(0) }[1..] + [text.length])
+          bounds.all? { |from, to| text[from...to].strip.empty? }
+        end
+
+        # `todo` is an alias of `disable`, so those two combine. Anything else
+        # (an `enable` beside a `disable`, or directives of different scopes)
+        # means different things per directive and can't be folded into one.
+        def merged_mode(directives)
+          modes = directives.map { |match| match[1] }.uniq
+          return modes.first if modes.size == 1
+          return modes.first if (modes - %w[disable todo]).empty?
+
+          nil
+        end
+
+        # An EOL next-statement directive is not honored - it must fail
+        # loudly instead of silently doing nothing.
         def misplaced_next_directive?(directive_comment)
-          directive_comment.disable_next? &&
+          next_statement_directive?(directive_comment) &&
             !processed_source.comment_config.comment_only_line?(directive_comment.line_number)
         end
 
+        def next_statement_directive?(directive_comment)
+          directive_comment.disable_next? || directive_comment.enable_next? ||
+            directive_comment.next?
+        end
+
         # rubocop:disable-next Metrics/MethodLength
         def offense_message(directive_comment)
           comment = directive_comment.comment
@@ -116,6 +182,8 @@ module RuboCop
                              INVALID_MODE_NAME_MSG
                            elsif directive_comment.missing_cop_name?
                              MISSING_COP_NAME_MSG
+                           elsif directive_comment.invalid_signed_args?
+                             INVALID_SIGNED_ARGS_MSG
                            else
                              MALFORMED_COP_NAMES_MSG
                            end
@@ -142,10 +210,10 @@ module RuboCop
         end
 
         def unknown_cop_name(directive_comment)
-          return if directive_comment.push? || directive_comment.pop? || directive_comment.all_cops?
+          return if directive_comment.pop? || directive_comment.all_cops?
 
           registry = directive_comment.cop_registry
-          directive_comment.raw_cop_names.find do |name|
+          directive_names(directive_comment).find do |name|
             next false if registry.department?(name)
 
             qualified = registry.qualified_cop_name(name, nil, warn: false)
@@ -153,6 +221,14 @@ module RuboCop
           end
         end
 
+        def directive_names(directive_comment)
+          if directive_comment.push? || directive_comment.next?
+            directive_comment.signed_args.values.flatten
+          else
+            directive_comment.raw_cop_names
+          end
+        end
+
         def unknown_cop_message(directive_comment, name)
           similar = NameSimilarity.find_similar_name(name, directive_comment.cop_registry.names)
           suggestion = similar ? " (did you mean `#{similar}`?)" : ''
@@ -162,5 +238,3 @@ module RuboCop
     end
   end
 end
-# rubocop:enable Lint/RedundantCopDisableDirective
-# rubocop:enable Style/DoubleCopDisableDirective