rubocop 1.88.0 → 1.88.2

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

@@ -50,9 +50,11 @@ module RuboCop
         private
 
         def register_offense(node)
-          add_offense(offense_range(node)) do |corrector|
-            corrector.remove(node.loc.begin)
-            corrector.remove(node.loc.end)
+          range = offense_range(node)
+          return if processed_source.contains_comment?(range)
+
+          add_offense(range) do |corrector|
+            corrector.remove(range)
           end
         end
 
@@ -88,8 +90,12 @@ module RuboCop
         #
         def parenthesized_it_method_in_block?(node)
           return false unless node.method?(:it)
-          return false unless (block_node = node.each_ancestor(:block).first)
-          return false unless block_node.arguments.empty_and_without_delimiters?
+          return false unless (block_node = node.each_ancestor(:any_block).first)
+          # Inside a numbered/`it` block, a bare `it` is a parse error (it conflicts
+          # with the implicit parameter), so `it()` must keep its parentheses.
+          if block_node.block_type? && !block_node.arguments.empty_and_without_delimiters?
+            return false
+          end
 
           !node.receiver && node.arguments.empty? && !node.block_literal?
         end

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

@@ -102,6 +102,10 @@ module RuboCop
         MSG_PRESENT = 'Use def without parentheses.'
         MSG_MISSING = 'Use def with parentheses when there are parameters.'
 
+        def self.autocorrect_incompatible_with
+          [Style::ArgumentsForwarding]
+        end
+
         def on_def(node)
           args = node.arguments
 
@@ -166,7 +170,7 @@ module RuboCop
 
         def anonymous_arguments?(node)
           return true if node.arguments.any? do |arg|
-            arg.type?(:forward_arg, :restarg, :kwrestarg)
+            arg.forward_arg_type? || (arg.type?(:restarg, :kwrestarg) && arg.name.nil?)
           end
           return false unless (last_argument = node.last_argument)
 

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

@@ -55,8 +55,11 @@ module RuboCop
           lhs, operator, rhs = comparison_condition(node.condition)
           return unless operator
 
+          # For `unless`, the branches run opposite to an `if`, so swap them to
+          # keep the `max`/`min` decision correct.
           if_branch = node.if_branch
           else_branch = node.else_branch
+          if_branch, else_branch = else_branch, if_branch if node.unless?
           preferred_method = preferred_method(operator, lhs, rhs, if_branch, else_branch)
           return unless preferred_method
 

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

@@ -65,16 +65,19 @@ module RuboCop
         private
 
         def implements_respond_to_missing?(node)
-          return false unless (grand_parent = node.parent.parent)
+          scope = enclosing_scope(node)
+          search_root = scope || node.parent
+          return false unless search_root
 
-          grand_parent.each_descendant(node.type) do |descendant|
-            return true if descendant.method?(:respond_to_missing?)
-
-            child = descendant.children.first
-            return true if child.respond_to?(:method?) && child.method?(:respond_to_missing?)
+          search_root.each_descendant(node.type).any? do |descendant|
+            descendant.method?(:respond_to_missing?) && enclosing_scope(descendant).equal?(scope)
           end
+        end
 
-          false
+        # The class/module/`class << self` body that lexically contains `node`,
+        # or `nil` when `node` is defined at the top level.
+        def enclosing_scope(node)
+          node.each_ancestor(:class, :module, :sclass).first
         end
       end
     end

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

@@ -47,7 +47,7 @@ module RuboCop
         # @!method include_statement(node)
         def_node_matcher :include_statement, <<~PATTERN
           (send nil? ${:include :extend :prepend}
-            const)
+            const+)
         PATTERN
 
         # @!method in_top_level_scope?(node)

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

@@ -110,9 +110,11 @@ module RuboCop
         def_node_matcher :private_directive?, '(send nil? :private ...)'
 
         def on_module(node)
-          return unless node.body&.begin_type?
+          return unless node.body
 
-          each_wrong_style(node.body.children) do |child_node|
+          body_nodes = node.body.begin_type? ? node.body.children : [node.body]
+
+          each_wrong_style(body_nodes) do |child_node|
             add_offense(child_node) do |corrector|
               next if style == :forbidden
 

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

@@ -36,7 +36,7 @@ module RuboCop
         private
 
         def non_modifier_then?(node)
-          node.then? && node.loc.begin.line != node.if_branch&.loc&.line
+          node.multiline? && node.then? && node.loc.begin.line != node.if_branch&.loc&.line
         end
       end
     end

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

@@ -65,10 +65,16 @@ module RuboCop
           if style == :keyword
             rhs.begin_type?
           else
-            rhs.kwbegin_type?
+            # A `begin` block with `rescue`/`ensure` cannot be expressed with
+            # parentheses, so wrapping it in `(` and `)` is not possible.
+            rhs.kwbegin_type? && !contains_rescue_or_ensure?(rhs)
           end
         end
 
+        def contains_rescue_or_ensure?(node)
+          node.each_child_node(:rescue, :ensure).any?
+        end
+
         def keyword_autocorrect(node, corrector)
           node_buf = node.source_range.source_buffer
           corrector.replace(node.loc.begin, keyword_begin_str(node, node_buf))

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

@@ -51,10 +51,12 @@ module RuboCop
           end
 
           arguments_range = range_with_surrounding_space(arguments_range(node), side: :left)
-          # If the method name isn't on the same line as def, move it directly after def
+          # If the method name isn't on the same line as `def`, pull the name and
+          # the opening parenthesis up next to `def` so the collapsed signature
+          # stays on a single line and remains valid Ruby.
           if arguments_range.first_line != opening_line(node)
-            corrector.remove(node.loc.name)
-            corrector.insert_after(node.loc.keyword, " #{node.loc.name.source}")
+            prefix_range = range_between(node.loc.keyword.end_pos, begin_of_arguments.begin_pos)
+            corrector.replace(prefix_range, " #{prefix_range.source.strip}")
           end
 
           corrector.remove(arguments_range)
@@ -85,7 +87,12 @@ module RuboCop
         end
 
         def definition_width(node)
-          node.source_range.begin.join(node.arguments.source_range.end).length
+          # Measure the collapsed single-line width the autocorrect would
+          # produce, not the multi-line source length, so a signature that
+          # would fit on one line is not skipped.
+          signature = node.source_range.begin.join(node.arguments.source_range.end).source
+
+          signature.gsub(/\s+/, ' ').length
         end
       end
     end

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

@@ -6,6 +6,11 @@ module RuboCop
       # Checks for lambdas and procs that always return nil,
       # which can be replaced with an empty lambda or proc instead.
       #
+      # NOTE: A `proc` that returns nil via an explicit `return` is allowed,
+      # because in a `proc` `return` exits the enclosing method, so removing it
+      # would change behavior. A lambda is still reported, since there `return`
+      # only exits the lambda itself.
+      #
       # @example
       #   # bad
       #   -> { nil }
@@ -46,6 +51,9 @@ module RuboCop
         def on_block(node) # rubocop:disable InternalAffairs/NumblockHandler, InternalAffairs/ItblockHandler
           return unless node.lambda_or_proc?
           return unless nil_return?(node.body)
+          # `return` inside a non-lambda proc returns from the enclosing method,
+          # so dropping it changes behavior; only a lambda can omit it safely.
+          return if node.body.return_type? && !node.lambda?
 
           message = format(MSG, type: node.lambda? ? 'lambda' : 'proc')
           add_offense(node, message: message) do |corrector|

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

@@ -92,7 +92,7 @@ module RuboCop
           return unless numeric
 
           return if allowed_method_name?(node.method_name) ||
-                    node.each_ancestor(:send, :block).any? do |ancestor|
+                    node.each_ancestor(:send, :any_block).any? do |ancestor|
                       allowed_method_name?(ancestor.method_name)
                     end
 

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

@@ -61,7 +61,7 @@ module RuboCop
         def custom_class_or_module_definition?(node)
           parent = node.parent
 
-          parent.type?(:class, :module) && node.left_siblings.empty?
+          parent&.type?(:class, :module) && node.left_siblings.empty?
         end
       end
     end

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

@@ -46,7 +46,7 @@ module RuboCop
         end
 
         def super_used?(node)
-          node.parent.each_node(:zsuper).any?
+          node.parent.each_node(:zsuper, :super).any?
         end
       end
     end

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

@@ -27,6 +27,7 @@ module RuboCop
         def on_def(node)
           each_misplaced_optional_arg(node.arguments) { |argument| add_offense(argument) }
         end
+        alias on_defs on_def
 
         private
 

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

@@ -233,14 +233,23 @@ module RuboCop
           def source(node, loc)
             # __FILE__ is treated as a StrNode but has no begin
             if node.str_type? && loc.respond_to?(:begin) && loc.begin.nil?
-              "'#{node.source}'"
+              # `%w` elements have no per-element delimiter, so the value must be
+              # quoted and escaped to stay valid (e.g. `%w(it's)` -> `'it\'s'`).
+              quote(node.value)
             elsif node.sym_type? && !node.loc?(:begin)
-              ":#{node.source}"
+              # `%i` elements have no per-element delimiter, so a symbol that needs
+              # quoting must be emitted as `:"..."` (e.g. `%i(foo-bar)` -> `:"foo-bar"`),
+              # otherwise `:foo-bar` would parse as `:foo.-(bar)`.
+              node.value.inspect
             else
               node.source
             end
           end
 
+          def quote(string)
+            "'#{string.gsub(/[\\']/) { |char| "\\#{char}" }}'"
+          end
+
           def extract_sources(node)
             node.children.map(&:source)
           end

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

@@ -101,6 +101,8 @@ module RuboCop
         def string_source(node)
           if node.is_a?(String)
             node.scrub
+          elsif node.is_a?(Symbol)
+            node.to_s
           elsif node.respond_to?(:type) && node.type?(:str, :sym)
             node.source
           end

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

@@ -5,7 +5,7 @@ module RuboCop
     module Style
       # Looks for uses of Perl-style regexp match
       # backreferences and their English versions like
-      # $1, $2, $&, &+, $MATCH, $PREMATCH, etc.
+      # $1, $2, $&, $MATCH, $PREMATCH, etc.
       #
       # @example
       #   # bad
@@ -69,6 +69,10 @@ module RuboCop
         # @return [String, nil]
         def preferred_expression_to(node)
           first = node.to_a.first
+          # NOTE: `$+` / `$LAST_PAREN_MATCH` is deliberately not converted. It
+          # refers to the last group that actually matched, which has no concise
+          # `Regexp.last_match` equivalent (`Regexp.last_match(-1)` is the last
+          # group in the pattern, which may be `nil`).
           case first
           when ::Integer
             "Regexp.last_match(#{first})"
@@ -78,8 +82,6 @@ module RuboCop
             'Regexp.last_match.pre_match'
           when :$', :$POSTMATCH
             'Regexp.last_match.post_match'
-          when :$+, :$LAST_PAREN_MATCH
-            'Regexp.last_match(-1)'
           end
         end
 

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

@@ -26,7 +26,9 @@ module RuboCop
         def on_send(node)
           return unless (first_argument = node.first_argument)
           return unless (index = first_argument.source.index(CURRENT_DIRECTORY_PREFIX))
-          return unless (redundant_length = redundant_path_length(first_argument.str_content))
+
+          content = leading_path_content(first_argument)
+          return unless (redundant_length = redundant_path_length(content))
 
           begin_pos = first_argument.source_range.begin.begin_pos + index
           end_pos = begin_pos + redundant_length
@@ -39,6 +41,16 @@ module RuboCop
 
         private
 
+        # The literal text at the start of the path, which is the whole string
+        # for a plain string and the leading literal segment for an interpolated
+        # one (`nil` when it starts with interpolation).
+        def leading_path_content(node)
+          return node.str_content if node.str_type?
+          return unless node.dstr_type? && (first = node.children.first)&.str_type?
+
+          first.str_content
+        end
+
         def redundant_path_length(path)
           return unless (match = path&.match(REDUNDANT_CURRENT_DIRECTORY_PREFIX))
 

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

@@ -38,6 +38,10 @@ module RuboCop
 
         def fix_exploded(node)
           exploded?(node) do |command, message|
+            # `raise RuntimeError, nil` uses the class name as the message, so
+            # rewriting it to `raise nil.to_s` (an empty message) would change it.
+            next if message.nil_type?
+
             add_offense(node, message: MSG_1) do |corrector|
               corrector.replace(node, replaced_exploded(node, command, message))
             end
@@ -56,6 +60,8 @@ module RuboCop
 
         def fix_compact(node)
           compact?(node) do |new_call, message|
+            next if message.nil_type?
+
             add_offense(node, message: MSG_2) do |corrector|
               corrector.replace(new_call, replaced_compact(message))
             end

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

@@ -62,7 +62,7 @@ module RuboCop
         def_node_matcher :select_predicate?, <<~PATTERN
           (call
             {
-              (block $(call _ {:select :filter :find_all}) ...)
+              (any_block $(call _ {:select :filter :find_all}) ...)
               $(call _ {:select :filter :find_all} block_pass_type?)
             }
             ${:#{RESTRICT_ON_SEND.join(' :')}})

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

@@ -89,6 +89,8 @@ module RuboCop
 
         def on_send(node)
           format_without_additional_args?(node) do |value|
+            next if string_with_format_sequence?(value)
+
             replacement = escape_control_chars(value.source)
 
             add_offense(node, message: message(node, replacement)) do |corrector|
@@ -102,6 +104,24 @@ module RuboCop
 
         private
 
+        # A single-argument `format` whose string still contains a format sequence is
+        # not redundant: `format('%s')` raises at runtime, and `format('%%')` returns
+        # `'%'`, so replacing it with the literal would change behavior.
+        def string_with_format_sequence?(node)
+          string = static_string_value(node)
+          return false unless string
+
+          RuboCop::Cop::Utils::FormatString.new(string).format_sequences.any?
+        end
+
+        def static_string_value(node)
+          if node.str_type?
+            node.value
+          elsif node.dstr_type?
+            node.children.select(&:str_type?).map(&:value).join
+          end
+        end
+
         def message(node, prefer)
           format(MSG, prefer: prefer, method_name: node.method_name)
         end
@@ -246,6 +266,14 @@ module RuboCop
         def argument_value(argument)
           argument = argument.children.first if argument.begin_type?
 
+          # `nil` formats to an empty string (`format('%s', nil) == ''`), not the
+          # literal `'nil'` that `argument.source` would return.
+          return if argument.nil_type?
+
+          typed_argument_value(argument)
+        end
+
+        def typed_argument_value(argument)
           if argument.dsym_type?
             dsym_value(argument)
           elsif argument.hash_type?

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

@@ -48,8 +48,13 @@ module RuboCop
         def need_heredoc_delimiter_quotes?(node)
           heredoc_delimiter = node.source.delete(heredoc_type(node))
           return true unless heredoc_delimiter.start_with?("'", '"')
+          return true if node.loc.heredoc_end.source.strip.match?(/\W/)
 
-          node.loc.heredoc_end.source.strip.match?(/\W/) ||
+          # A double-quoted delimiter interpolates exactly like an unquoted one,
+          # so its quotes are always redundant. A single-quoted delimiter is
+          # required when the body contains interpolation or escapes that would
+          # otherwise be evaluated.
+          heredoc_delimiter.start_with?("'") &&
             node.loc.heredoc_body.source.match?(STRING_INTERPOLATION_OR_ESCAPED_CHARACTER_PATTERN)
         end
       end

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

@@ -165,11 +165,11 @@ module RuboCop
         end
 
         def inspect_end_of_ruby_code_line_continuation
-          last_line = processed_source.lines[processed_source.ast.last_line - 1]
+          last_line_number = processed_source.ast.last_line
+          last_line = processed_source.lines[last_line_number - 1]
           return unless code_ends_with_continuation?(last_line)
 
-          last_column = last_line.length
-          line_continuation_range = range_between(last_column - 1, last_column)
+          line_continuation_range = trailing_line_continuation_range(last_line_number)
 
           add_offense(line_continuation_range) do |corrector|
             corrector.remove_trailing(line_continuation_range, 1)
@@ -182,6 +182,14 @@ module RuboCop
           last_line.end_with?(LINE_CONTINUATION)
         end
 
+        # The backslash is the last character of the line; locate it by the line's
+        # position in the buffer rather than treating the column as an absolute offset
+        # (which corrupts an earlier line in multi-line files).
+        def trailing_line_continuation_range(line_number)
+          line_range = processed_source.buffer.line_range(line_number)
+          range_between(line_range.end_pos - 1, line_range.end_pos)
+        end
+
         def inside_string_literal?(range, token)
           ALLOWED_STRING_TOKENS.include?(token.type) && token.pos.overlaps?(range)
         end

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

@@ -65,7 +65,7 @@ module RuboCop
           # different versions of Ruby so that e.g. /\i/ != /i/
           return true if /[[:alnum:]]/.match?(char)
           return true if ALLOWED_ALWAYS_ESCAPES.include?(char) || delimiter?(node, char)
-          return true if requires_escape_to_avoid_interpolation?(node.source[index], char)
+          return true if requires_escape_to_avoid_interpolation?(node, index, char)
 
           if within_character_class
             ALLOWED_WITHIN_CHAR_CLASS_METACHAR_ESCAPES.include?(char) &&
@@ -97,10 +97,14 @@ module RuboCop
           delimiters.include?(char)
         end
 
-        def requires_escape_to_avoid_interpolation?(char_before_escape, escaped_char)
+        def requires_escape_to_avoid_interpolation?(node, index, escaped_char)
           # Preserve escapes after '#' that would otherwise trigger interpolation:
-          # '#@ivar', '#@@cvar', and '#$gvar'.
-          char_before_escape == '#' && INTERPOLATION_SIGILS.include?(escaped_char)
+          # '#@ivar', '#@@cvar', and '#$gvar'. `index` is relative to the regexp
+          # contents, so index into those rather than `node.source` (which also
+          # includes the opening delimiter, e.g. `%r{`).
+          return false unless index.positive? && INTERPOLATION_SIGILS.include?(escaped_char)
+
+          contents_range(node).source[index - 1] == '#'
         end
 
         def each_escape(node)

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

@@ -100,6 +100,15 @@ module RuboCop
           add_lhs_to_local_variables_scopes(node.rhs, node.lhs)
         end
 
+        # Register the exception variable of `rescue => e` so that `self.e` in the
+        # body is not treated as redundant (it disambiguates the local variable).
+        def on_resbody(node)
+          exception_variable = node.exception_variable
+          return unless exception_variable&.lvasgn_type?
+
+          @local_variables_scopes[node] << exception_variable.name
+        end
+
         def on_in_pattern(node)
           add_match_var_scopes(node)
         end

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

@@ -100,12 +100,31 @@ module RuboCop
         end
 
         def range(redundant_keyword_init)
-          if redundant_keyword_init.parent.left_siblings.last.is_a?(AST::Node)
-            beginning_of_range = redundant_keyword_init.parent.left_siblings.last.source_range.end
+          if redundant_keyword_init.parent.pairs.all? { |pair| keyword_init?(pair) }
+            # The hash holds only `keyword_init` pairs, so it is emptied; anchor the
+            # removal before the hash to also drop the comma that precedes it.
+            range_emptying_hash(redundant_keyword_init)
+          else
+            # Other pairs remain, so just drop this pair and one adjacent comma.
+            range_within_hash(redundant_keyword_init)
+          end
+        end
+
+        def range_within_hash(pair)
+          if (left = pair.left_sibling)
+            left.source_range.end.join(pair.source_range.end)
+          elsif (right = pair.right_sibling)
+            pair.source_range.begin.join(right.source_range.begin)
+          else
+            pair.source_range
+          end
+        end
 
-            beginning_of_range.join(redundant_keyword_init.source_range.end)
+        def range_emptying_hash(pair)
+          if (preceding = pair.parent.left_sibling).is_a?(AST::Node)
+            preceding.source_range.end.join(pair.source_range.end)
           else
-            redundant_keyword_init
+            pair.source_range
           end
         end
       end

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

@@ -170,10 +170,10 @@ module RuboCop
         end
 
         def find_semicolon_positions(line)
-          # Scan for all the semicolons on the line
-          semicolons = processed_source[line - 1].enum_for(:scan, ';')
-          semicolons.each do
-            yield Regexp.last_match.begin(0)
+          # Scan for all the semicolon tokens on the line. Iterating tokens rather
+          # than the raw source skips `;` characters inside string/regexp literals.
+          processed_source.tokens.each do |token|
+            yield token.column if token.line == line && token.semicolon?
           end
         end
 

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

@@ -44,11 +44,12 @@ module RuboCop
           add_offense(node) do |corrector|
             corrector.insert_after(do_line(node), "\n")
 
-            node_body = node.body
-
-            if node_body.respond_to?(:heredoc?) && node_body.heredoc?
+            if (heredoc = trailing_heredoc(node.body))
+              # The heredoc body extends past the `end` on the source, so the
+              # `end` has to be moved after it rather than before, which would
+              # otherwise move it into the heredoc body and break the syntax.
               corrector.remove(node.loc.end)
-              corrector.insert_after(node_body.loc.heredoc_end, "\nend")
+              corrector.insert_after(heredoc.loc.heredoc_end, "\nend")
             else
               corrector.insert_before(node.loc.end, "\n")
             end
@@ -60,6 +61,18 @@ module RuboCop
 
         private
 
+        # Returns the heredoc opened on the block's line whose body extends the
+        # furthest down, whether it is the block body itself or nested within it.
+        def trailing_heredoc(node_body)
+          return unless node_body
+
+          heredocs = [node_body, *node_body.each_descendant].select do |node|
+            node.respond_to?(:heredoc?) && node.heredoc?
+          end
+
+          heredocs.max_by { |heredoc| heredoc.loc.heredoc_end.line }
+        end
+
         def do_line(node)
           if node.type?(:numblock, :itblock) ||
              node.arguments.children.empty? || node.send_node.lambda_literal?

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

@@ -41,6 +41,7 @@ module RuboCop
 
         def on_pair(node)
           return unless string_hash_key?(node)
+          return if node.key.heredoc?
 
           key_content = node.key.str_content
           return unless key_content.valid_encoding?

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

@@ -41,7 +41,9 @@ module RuboCop
           return unless struct_constructor?(node.parent_class)
 
           add_offense(node.parent_class) do |corrector|
-            corrector.remove(range_with_surrounding_space(node.loc.keyword, newlines: false))
+            corrector.remove(
+              range_with_surrounding_space(node.loc.keyword, side: :right, newlines: false)
+            )
             corrector.replace(node.loc.operator, '=')
 
             correct_parent(node.parent_class, corrector)

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

@@ -113,6 +113,10 @@ module RuboCop
         def offense?(node)
           condition = node.condition
 
+          # A modifier `if`/`unless` requires the parentheses, e.g. `(a if b) ? x : y`,
+          # so removing them would change the meaning. Don't flag it.
+          return false if parenthesized_modifier_condition?(condition)
+
           if safe_assignment?(condition)
             !safe_assignment_allowed?
           else
@@ -174,6 +178,13 @@ module RuboCop
           condition.children.any? { |child| below_ternary_precedence?(child) }
         end
 
+        def parenthesized_modifier_condition?(condition)
+          return false unless condition.begin_type?
+
+          inner = condition.children.first
+          inner&.if_type? && inner.modifier_form?
+        end
+
         def unparenthesized_method_call?(child)
           /^[a-z]/i.match?(method_name(child)) && !child.parenthesized?
         end