rubocop 1.89.0 → 1.91.0

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

@@ -175,10 +175,19 @@ module RuboCop
         end
 
         def ancestor_namespaces(node)
-          node
-            .each_ancestor(:class, :module)
-            .map { |ancestor| ancestor.identifier.short_name }
-            .reverse
+          ancestors = node.each_ancestor(:class, :module).reverse_each
+
+          ancestors.with_object([]) do |ancestor, namespaces|
+            append_namespaces(namespaces, ancestor.identifier)
+          end
+        end
+
+        # Compact definitions (e.g. `module A::B`) contribute every path segment,
+        # and an absolute one (e.g. `module ::A::B`) discards the enclosing namespaces.
+        def append_namespaces(namespaces, identifier)
+          namespaces.clear if identifier.absolute?
+          namespaces.concat(identifier_namespaces(identifier))
+          namespaces << identifier.short_name
         end
 
         def unconditional_definition?(node)
@@ -188,14 +197,11 @@ module RuboCop
         end
 
         def definition_name(node)
-          identifier = node.identifier
+          namespaces = ancestor_namespaces(node)
+          append_namespaces(namespaces, node.identifier)
+          constant = namespaces.pop
 
-          if identifier.namespace&.cbase_type?
-            fully_qualified_name_for([], identifier.short_name)
-          else
-            namespaces = ancestor_namespaces(node) + identifier_namespaces(identifier)
-            fully_qualified_name_for(namespaces, identifier.short_name)
-          end
+          fully_qualified_name_for(namespaces, constant)
         end
 
         def identifier_namespaces(identifier)

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
@@ -42,29 +39,139 @@ module RuboCop
       #   # good
       #   # rubocop:disable Layout/LineLength -- comment
       #
+      #   # bad
+      #   # rucocop:disable Layout/LineLength
+      #
+      #   # good
+      #   # rubocop:disable Layout/LineLength
+      #
+      #   # bad
+      #   # rubocop:disable Layout/LineLenght
+      #
+      #   # good
+      #   # 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`, `todo`, `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`.'
+        UNKNOWN_COP_MSG = 'Unknown cop name `%<name>s`%<suggestion>s.'
+
+        # A comment that looks like an attempted directive: any keyword
+        # followed by a colon and a valid mode name.
+        NEAR_MISS_KEYWORD_REGEXP = /
+          \A\#+\s*(?<keyword>[A-Za-z][\w-]*)\s*:\s*
+          (?:#{DirectiveComment::MODES_PATTERN})\b
+        /x.freeze
 
         def on_new_investigation
           processed_source.comments.each do |comment|
             directive_comment = DirectiveComment.new(comment)
-            next unless directive_comment.start_with_marker?
-            next unless directive_comment.malformed?
-
-            message = offense_message(directive_comment)
-            add_offense(comment, message: message)
+            if directive_comment.start_with_marker?
+              check_directive(comment, directive_comment)
+            elsif (keyword = near_miss_keyword(comment))
+              message = format("#{COMMON_MSG} #{INVALID_KEYWORD_MSG}", keyword: keyword)
+              add_offense(comment, message: message)
+            end
           end
         end
 
         private
 
-        # rubocop:disable Metrics/MethodLength
+        def check_directive(comment, directive_comment)
+          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)
+          elsif (name = unknown_cop_name(directive_comment))
+            add_offense(comment, message: unknown_cop_message(directive_comment, name))
+          end
+        end
+
+        # 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)
+          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
           after_marker = comment.text.sub(DirectiveComment::DIRECTIVE_MARKER_REGEXP, '')
@@ -75,16 +182,59 @@ 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
 
           "#{COMMON_MSG} #{additional_msg}"
         end
-        # rubocop:enable Metrics/MethodLength
+
+        def near_miss_keyword(comment)
+          match = comment.text.match(NEAR_MISS_KEYWORD_REGEXP)
+          return unless match
+
+          keyword = match[:keyword]
+          return if keyword == 'rubocop'
+
+          keyword if similar_to_rubocop?(keyword)
+        end
+
+        def similar_to_rubocop?(keyword)
+          return true if keyword.casecmp?('rubocop')
+          # `DidYouMean` is not always available - see `NameSimilarity`.
+          return false unless defined?(DidYouMean::Levenshtein)
+
+          DidYouMean::Levenshtein.distance(keyword.downcase, 'rubocop') <= 2
+        end
+
+        def unknown_cop_name(directive_comment)
+          return if directive_comment.pop? || directive_comment.all_cops?
+
+          registry = directive_comment.cop_registry
+          directive_names(directive_comment).find do |name|
+            next false if registry.department?(name)
+
+            qualified = registry.qualified_cop_name(name, nil, warn: false)
+            !registry.contains_cop_matching?([qualified])
+          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}`?)" : ''
+          format(UNKNOWN_COP_MSG, name: name, suggestion: suggestion)
+        end
       end
     end
   end
 end
-# rubocop:enable Lint/RedundantCopDisableDirective
-# rubocop:enable Style/DoubleCopDisableDirective

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

@@ -150,10 +150,19 @@ module RuboCop
           false
         end
 
+        # Enumerated in a single pass that stops at the first non-deprecated
+        # definition, since materializing every definition of a declaration
+        # that is almost never deprecated dominates the cop's cost.
         def deprecated?(declaration)
-          definitions = declaration.definitions.to_a
+          any = false
 
-          definitions.any? && definitions.all?(&:deprecated?)
+          declaration.definitions.each do |definition|
+            return false unless definition.deprecated?
+
+            any = true
+          end
+
+          any
         end
 
         # References from a definition that is itself documented as deprecated

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

@@ -19,7 +19,22 @@ module RuboCop
       # file is wrapped in a conditional, so a platform-specific redefinition in
       # another file may still be reported. Aliasing the method to itself (see above)
       # before redefining marks the redefinition as intentional and is respected
-      # across files.
+      # across files. With `AllCops/ActiveSupportExtensionsEnabled: true`, Active
+      # Support's redefinition markers (`silence_redefinition_of_method` and
+      # `redefine_method`) are honored the same way.
+      #
+      # NOTE: Methods defined with `define_method` are not recorded in the project
+      # index, so a duplicate whose other definition uses `define_method` cannot
+      # be detected across files.
+      #
+      # Cross-file duplicates whose other definition lives in a file matching one
+      # of the `AllowedCrossFilePaths` patterns are not reported. This suits files
+      # that redefine application methods but are never loaded together with them,
+      # such as standalone scripts. Patterns are matched with the same glob (or
+      # regexp) semantics as `Exclude`, against the other file's path relative to
+      # the directory of the `.rubocop.yml` that configures the cop; absolute
+      # patterns are matched against the absolute path. Offenses inside such files
+      # themselves are best silenced with an ordinary per-cop `Exclude`.
       #
       # @example
       #
@@ -129,6 +144,24 @@ module RuboCop
       #     delegate :foo, to: :bar
       #   end
       #
+      #   # good - Active Support's redefinition markers signal an intentional
+      #   # redefinition of a method defined in another file
+      #   silence_redefinition_of_method :foo
+      #   def foo
+      #     1
+      #   end
+      #
+      # @example AllowedCrossFilePaths: ['script/**/*'] (default: [])
+      #   # Cross-file duplicates whose other definition lives in a file
+      #   # matching one of the patterns are not reported.
+      #
+      #   # good - assuming `AppHelper#format` is also defined in
+      #   # `script/backfill.rb`, which is never loaded with this file
+      #   class AppHelper
+      #     def format
+      #     end
+      #   end
+      #
       # @example DelegatingMethods: ['delegate', 'expose'] (default: ['delegate'])
       #   # A project's own `delegate`-shaped macros can be registered so the
       #   # methods they define are recognized (with
@@ -160,13 +193,14 @@ module RuboCop
           super
           @definitions = {}
           @scopes = Hash.new { |hash, key| hash[key] = [] }
-          @self_aliased = Set.new
+          @intentionally_redefined = Set.new
         end
 
         def on_new_investigation
-          # The self-alias trick declares an intentional redefinition only within
-          # the file that uses it, so the tracked names do not carry over.
-          @self_aliased = Set.new
+          # The self-alias trick and Active Support's redefinition markers declare
+          # an intentional redefinition only within the file that uses them, so the
+          # tracked names do not carry over.
+          @intentionally_redefined = Set.new
           super
         end
 
@@ -199,7 +233,7 @@ module RuboCop
           return unless name && original_name
 
           if name == original_name
-            track_self_alias(node, name)
+            track_intentional_redefinition(node, name)
             return
           end
           return if node.ancestors.any?(&:if_type?)
@@ -241,6 +275,15 @@ module RuboCop
           )
         PATTERN
 
+        # Matches Active Support's markers of an intentional method redefinition:
+        # `silence_redefinition_of_method :name` suppresses Ruby's redefinition
+        # warning for a subsequent definition of `name`, and
+        # `redefine_method(:name) { ... }` both silences the warning and redefines.
+        # @!method active_support_redefinition_marker(node)
+        def_node_matcher :active_support_redefinition_marker, <<~PATTERN
+          (send nil? {:silence_redefinition_of_method :redefine_method} ({sym str} $_) ...)
+        PATTERN
+
         # @!method sym_name(node)
         def_node_matcher :sym_name, '(sym $_name)'
 
@@ -263,7 +306,7 @@ module RuboCop
 
           if name && original_name
             if name == original_name
-              track_self_alias(node, name)
+              track_intentional_redefinition(node, name)
               return
             end
             return if inside_condition?(node)
@@ -283,6 +326,12 @@ module RuboCop
             return if inside_condition?(node)
 
             names.each { |name| found_instance_method(node, name) }
+          elsif (name = active_support_redefinition_marker(node))
+            # `redefine_method` takes a block; scope resolution must start from the
+            # block node, since `parent_module_name` cannot see through a block
+            # ancestor that is not a module constructor.
+            track_intentional_redefinition(node.block_node || node, name) if
+              active_support_extensions_enabled?
           end
         end
 
@@ -386,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}"
@@ -441,27 +490,39 @@ module RuboCop
           if scope && !@scopes[scope].include?(key)
             @definitions[key] = node
             @scopes[scope] << key
-          elsif intentional_cross_file_redefinition?(node, method_name, key)
+          elsif intentional_cross_file_redefinition?(node, method_name, key) ||
+                allowed_cross_file_redefinition?(node, key)
             @definitions[key] = node
           else
             add_offense(location(node), message: message_for_dup(node, method_name, key))
           end
         end
 
+        # `AllowedCrossFilePaths` also covers duplicates detected without the index,
+        # when the cop instance carries definitions over from an earlier file of the
+        # same run.
+        def allowed_cross_file_redefinition?(node, key)
+          other_path = @definitions[key].source_range.source_buffer.name
+          return false if other_path == node.source_range.source_buffer.name
+
+          allowed_cross_file_path?(other_path)
+        end
+
         # The self-alias trick (`alias foo foo` or `alias_method :foo, :foo` right before
         # a `def`) suppresses Ruby's method redefinition warning, signaling an intentional
-        # redefinition of a method defined in another file.
+        # redefinition of a method defined in another file. Active Support's redefinition
+        # markers (tracked when `ActiveSupportExtensionsEnabled` is on) signal the same.
         def intentional_cross_file_redefinition?(node, method_name, key)
-          @self_aliased.include?(method_name) &&
+          @intentionally_redefined.include?(method_name) &&
             @definitions[key].source_range.source_buffer.name !=
               node.source_range.source_buffer.name
         end
 
-        def track_self_alias(node, name)
+        def track_intentional_redefinition(node, name)
           scope = node.parent_module_name
           return unless scope
 
-          @self_aliased << "#{humanize_scope(scope)}#{name}"
+          @intentionally_redefined << "#{humanize_scope(scope)}#{name}"
         end
 
         def method_key(node, method_name)
@@ -544,7 +605,7 @@ module RuboCop
 
         def check_cross_file_duplicate(node, method_name)
           return unless project_index
-          return if @self_aliased.include?(method_name)
+          return if @intentionally_redefined.include?(method_name)
           return if node.each_ancestor(:any_def).any?
           return unless (prior = cross_file_prior_definition(method_name))
 
@@ -559,12 +620,27 @@ module RuboCop
 
           definitions = definitions_in_other_files(
             indexed_definitions(match[:owner], match[:separator], match[:name])
-          )
+          ).reject { |definition| allowed_cross_file_path?(definition.location.to_file_path) }
           return if definitions.empty? || cross_file_self_alias_trick?(definitions)
+          return if cross_file_redefinition_marker?(definitions, match[:name])
 
           first_indexed_definition(definitions)
         end
 
+        # Cross-file duplicates whose other definition site matches one of the
+        # `AllowedCrossFilePaths` patterns are skipped (e.g. standalone scripts that
+        # are never loaded together with the code they redefine). Patterns are
+        # matched like `Exclude` patterns, against the path relative to the
+        # directory of the config file that configures the cop; absolute patterns
+        # are matched against the absolute path.
+        def allowed_cross_file_path?(path)
+          patterns = cop_config.fetch('AllowedCrossFilePaths', [])
+          return false if patterns.empty?
+
+          relative = config.path_relative_to_config(path)
+          patterns.any? { |pattern| match_path?(pattern, relative) || match_path?(pattern, path) }
+        end
+
         def indexed_definitions(owner, separator, name)
           namespace = separator == '.' ? "#{owner}::<#{owner.split('::').last}>" : owner
 
@@ -601,6 +677,28 @@ module RuboCop
           others.any? { |definition| alias_paths.include?(definition.location.to_file_path) }
         end
 
+        # An Active Support redefinition marker alongside one of the definitions in
+        # another file marks the redefinition there as intentional, like the
+        # self-alias trick. The index does not record the marker's method-name
+        # argument, so the other file's source is searched for a marker naming
+        # the method.
+        def cross_file_redefinition_marker?(definitions, name)
+          return false unless active_support_extensions_enabled?
+
+          definitions.map { |definition| definition.location.to_file_path }.uniq.any? do |path|
+            redefinition_marker_in_file?(path, name)
+          end
+        end
+
+        def redefinition_marker_in_file?(path, name)
+          return false unless File.readable?(path)
+
+          escaped = Regexp.escape(name)
+          marker = /\b(?:silence_redefinition_of_method|redefine_method)\s*\(?\s*
+                    (?::#{escaped}|(["'])#{escaped}\1)(?![\w=!?])/x
+          File.read(path).scrub.match?(marker)
+        end
+
         def first_indexed_definition(definitions)
           definitions.find { |definition| !definition.is_a?(Rubydex::MethodAliasDefinition) }
         end

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/implicit_string_concatenation.rb

@@ -28,7 +28,7 @@ module RuboCop
         FOR_METHOD = ' Or, if they were intended to be separate method ' \
                      'arguments, separate them with a comma.'
 
-        # rubocop:disable Metrics/AbcSize, Metrics/MethodLength, Metrics/PerceivedComplexity
+        # rubocop:disable-next Metrics/AbcSize, Metrics/MethodLength, Metrics/PerceivedComplexity
         def on_dstr(node)
           each_bad_cons(node) do |lhs_node, rhs_node|
             range = lhs_node.source_range.join(rhs_node.source_range)
@@ -52,7 +52,6 @@ module RuboCop
             end
           end
         end
-        # rubocop:enable Metrics/AbcSize, Metrics/MethodLength, Metrics/PerceivedComplexity
 
         private
 

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

@@ -80,7 +80,7 @@ module RuboCop
                       alternative: alternative)
         end
 
-        # rubocop:disable Metrics/CyclomaticComplexity
+        # rubocop:disable-next Metrics/CyclomaticComplexity
         def ineffective_modifier(node, ignored_methods = nil, modifier = nil, &block)
           node.each_child_node do |child|
             case child.type
@@ -97,7 +97,6 @@ module RuboCop
             end
           end
         end
-        # rubocop:enable Metrics/CyclomaticComplexity
 
         def access_modifier?(node)
           node.bare_access_modifier? && !node.method?(:module_function)

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

@@ -41,7 +41,7 @@ module RuboCop
 
         private
 
-        # rubocop:disable Metrics/CyclomaticComplexity
+        # rubocop:disable-next Metrics/CyclomaticComplexity
         def check(node)
           return if node.parent&.regexp_type?
           return unless /(?<!\\)#\{.*\}/.match?(node.source)
@@ -51,7 +51,6 @@ module RuboCop
 
           add_offense(node) { |corrector| autocorrect(corrector, node) }
         end
-        # rubocop:enable Metrics/CyclomaticComplexity
 
         def autocorrect(corrector, node)
           starting_token, ending_token = if node.source.include?('"')

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
@@ -88,7 +88,7 @@ module RuboCop
           end
         end
 
-        # rubocop:disable Metrics/AbcSize
+        # rubocop:disable-next Metrics/AbcSize
         def on_while_post(node)
           return if node.condition.source == 'true'
 
@@ -102,7 +102,6 @@ module RuboCop
             end
           end
         end
-        # rubocop:enable Metrics/AbcSize
 
         def on_until(node)
           return if node.condition.source == 'false'
@@ -118,7 +117,7 @@ module RuboCop
           end
         end
 
-        # rubocop:disable Metrics/AbcSize
+        # rubocop:disable-next Metrics/AbcSize
         def on_until_post(node)
           return if node.condition.source == 'false'
 
@@ -132,7 +131,6 @@ module RuboCop
             end
           end
         end
-        # rubocop:enable Metrics/AbcSize
 
         def on_case(case_node)
           if (cond = case_node.condition)
@@ -177,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?
@@ -250,7 +254,7 @@ module RuboCop
           end
         end
 
-        # rubocop:disable Metrics/AbcSize, Metrics/MethodLength, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+        # rubocop:disable-next Metrics/AbcSize, Metrics/MethodLength, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
         def correct_if_node(node, cond)
           result = condition_evaluation?(node, cond)
 
@@ -281,7 +285,6 @@ module RuboCop
             ignore_node(node)
           end
         end
-        # rubocop:enable Metrics/AbcSize, Metrics/MethodLength, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
       end
     end
   end