rubocop 1.91.0 → 1.92.2

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

@@ -69,9 +69,13 @@ module RuboCop
 
         # @!method variable_argument?(node)
         def_node_matcher :variable_argument?, <<~PATTERN
-          (send {str dstr} :% #autocorrectable?)
+          (send {str dstr} :% !#autocorrectable?)
         PATTERN
 
+        def on_new_investigation
+          @corrected_ranges = nil
+        end
+
         def on_send(node)
           formatter(node) do |selector|
             detected_style = selector == :% ? :percent : selector
@@ -86,10 +90,12 @@ module RuboCop
 
         private
 
+        # Only an argument that is provably not an array can be corrected,
+        # because `String#%` spreads an array argument and `format` does not.
         def autocorrectable?(node)
-          return true if node.lvar_type?
+          return true if node.literal?
 
-          node.send_type? && !AUTOCORRECTABLE_METHODS.include?(node.method_name)
+          node.call_type? && AUTOCORRECTABLE_METHODS.include?(node.method_name)
         end
 
         def message(detected_style)
@@ -101,7 +107,9 @@ module RuboCop
         end
 
         def autocorrect(corrector, node)
-          return if variable_argument?(node)
+          return if variable_argument?(node) || within_corrected_range?(node)
+
+          corrected_ranges << node.source_range
 
           case node.method_name
           when :%
@@ -116,6 +124,14 @@ module RuboCop
           end
         end
 
+        def within_corrected_range?(node)
+          corrected_ranges.any? { |range| range.contains?(node.source_range) }
+        end
+
+        def corrected_ranges
+          @corrected_ranges ||= []
+        end
+
         def autocorrect_from_percent(corrector, node)
           percent_rhs = node.first_argument
           args = case percent_rhs.type
@@ -146,14 +162,20 @@ module RuboCop
         def format_single_parameter(arg)
           # `format(fmt, *args)` is equivalent to `fmt % args`, so unwrap the splat
           # and render the argument it splats.
-          return format_single_parameter(arg.children.first) if arg.splat_type?
+          return format_splatted_parameter(arg.children.first) if arg.splat_type?
 
           source = arg.source
-          return "{ #{source} }" if arg.hash_type?
+          return "{ #{source} }" if arg.hash_type? && !arg.braces?
 
           requires_parentheses?(arg) ? "(#{source})" : source
         end
 
+        def format_splatted_parameter(arg)
+          return "#{arg.source}.to_a" if arg.hash_type?
+
+          format_single_parameter(arg)
+        end
+
         # An argument that binds looser than `%` (a ternary, range, assignment, or
         # operator call) must be parenthesized to keep its meaning.
         def requires_parentheses?(arg)

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

@@ -142,7 +142,8 @@ module RuboCop
           end
 
           next_token = processed_source.tokens[token_number]
-          if next_token&.text&.valid_encoding? && Encoding::ENCODING_PATTERN.match?(next_token.text)
+          if next_token&.text&.valid_encoding? &&
+             MagicComment.parse(next_token.text).encoding_specified?
             token = next_token
           end
 

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

@@ -186,40 +186,37 @@ module RuboCop
             return if trivial?(node)
 
             example = "#{conditional_keyword} #{condition.source}; #{scope_exiting_keyword}; end"
-            replacement = <<~RUBY.chomp
-              #{conditional_keyword} #{condition.source}
-                #{scope_exiting_keyword}
-              end
-            RUBY
+            replacement = "#{conditional_keyword} #{condition.source}\n  #{scope_exiting_keyword}"
           end
 
           add_offense(node.loc.keyword, message: format(MSG, example: example)) do |corrector|
             next if node.else? && guard.nil?
 
-            autocorrect(corrector, node, condition, replacement || example, guard)
+            autocorrect(corrector, node, example, replacement, guard)
           end
         end
 
         # rubocop:disable-next Metrics/AbcSize
-        def autocorrect(corrector, node, condition, replacement, guard)
-          corrector.replace(node.loc.keyword.join(condition.source_range), replacement)
-
-          if_branch = node.if_branch
-          else_branch = node.else_branch
-
+        def autocorrect(corrector, node, example, multiline_replacement, guard)
+          range = node.loc.keyword.join(node.condition.source_range)
+          corrector.replace(range, multiline_replacement || example)
           corrector.replace(node.loc.begin, "\n") if node.then?
 
-          if (if_heredoc = find_heredoc_argument(if_branch))
-            autocorrect_heredoc_argument(corrector, node, if_heredoc, else_branch, guard)
-          elsif (else_heredoc = find_heredoc_argument(else_branch))
-            autocorrect_heredoc_argument(corrector, node, else_heredoc, if_branch, guard)
-          else
-            corrector.remove(node.loc.end)
-            return unless node.else?
+          branches = [node.if_branch, node.else_branch]
+          guard_branch, leave_branch = guard == :else ? branches.reverse : branches
 
-            corrector.remove(node.loc.else)
-            corrector.remove(range_of_branch_to_remove(node, guard))
+          heredoc = find_heredoc_argument(guard_branch)
+          close_multiline_guard_clause(corrector, range, heredoc, guard) if multiline_replacement
+
+          if heredoc
+            return autocorrect_heredoc_argument(corrector, node, heredoc, leave_branch, guard)
           end
+
+          corrector.remove(node.loc.end)
+          return unless node.else?
+
+          corrector.remove(node.loc.else)
+          corrector.remove(range_of_branch_to_remove(node, guard))
         end
 
         def heredoc?(argument)
@@ -241,6 +238,10 @@ module RuboCop
           find_heredoc_argument(node.receiver)
         end
 
+        def close_multiline_guard_clause(corrector, range, heredoc, guard)
+          corrector.insert_after(guard && heredoc ? heredoc.loc.heredoc_end : range, "\nend")
+        end
+
         def autocorrect_heredoc_argument(corrector, node, heredoc_node, leave_branch, guard)
           remove_whole_lines(corrector, node.loc.end)
           return unless node.else?
@@ -282,7 +283,15 @@ module RuboCop
         end
 
         def accepted_form?(node, ending: false)
-          accepted_if?(node, ending) || node.condition.multiline? || node.parent&.assignment?
+          accepted_if?(node, ending) || node.condition.multiline? ||
+            node.parent&.assignment? || endless_method_body?(node)
+        end
+
+        # The body of an endless method is a single expression, so there is no
+        # room for a guard clause followed by the rest of the code.
+        def endless_method_body?(node)
+          parent = node.parent
+          parent&.any_def_type? && parent.endless?
         end
 
         def trivial?(node)

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

@@ -44,6 +44,10 @@ module RuboCop
         include ConfigurableEnforcedStyle
         extend AutoCorrector
 
+        def self.autocorrect_incompatible_with
+          [Layout::MultilineArrayBraceLayout, Style::TrailingCommaInArrayLiteral]
+        end
+
         def on_hash(node)
           return if node.children.first&.kwsplat_type?
           return unless (array = containing_array(node))

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

@@ -53,6 +53,12 @@ module RuboCop
         # @!method hash_from_array?(node)
         def_node_matcher :hash_from_array?, '(send (const {nil? cbase} :Hash) :[] ...)'
 
+        # A hash literal as the first argument needs the parentheses of the call,
+        # which `Style/MethodCallWithArgsParentheses` removes in the same pass.
+        def self.autocorrect_incompatible_with
+          [Style::MethodCallWithArgsParentheses]
+        end
+
         def on_send(node)
           return if part_of_ignored_node?(node) || !hash_from_array?(node)
 
@@ -95,12 +101,30 @@ module RuboCop
         def register_offense_for_hash(node, hash_argument)
           add_offense(node, message: MSG_LITERAL_HASH_ARG) do |corrector|
             corrector.replace(node, "{#{hash_argument.source}}")
-
-            parent = node.parent
-            add_parentheses(parent, corrector) if parent&.send_type? && !parent.parenthesized?
+            add_parentheses_to_parent_call(node, corrector)
           end
         end
 
+        # Without parentheses, a hash literal at the start of the first argument would be
+        # parsed as a block. That includes an argument like `Hash[a, b].merge(c)`.
+        def add_parentheses_to_parent_call(node, corrector)
+          node = node.parent while starts_parent?(node)
+          parent = node.parent
+          return unless parent&.type?(:call, :super, :yield)
+          return if parent.parenthesized? || operator_syntax?(parent)
+
+          add_parentheses(parent, corrector)
+        end
+
+        def starts_parent?(node)
+          node.parent && node.parent.source_range.begin_pos == node.source_range.begin_pos
+        end
+
+        # `foo[x]`, `foo.bar = x` and `foo == x` take a hash literal as it is.
+        def operator_syntax?(call)
+          call.setter_method? || (call.operator_method? && !call.loc?(:dot))
+        end
+
         def register_offense_for_zip_method(node, zip_method)
           add_offense(node, message: MSG_TO_H) do |corrector|
             if zip_method.parenthesized?
@@ -135,11 +159,7 @@ module RuboCop
         def correct_multi_argument(node)
           add_offense(node, message: MSG_LITERAL_MULTI_ARG) do |corrector|
             corrector.replace(node, args_to_hash(node.arguments))
-
-            parent = node.parent
-            if parent&.send_type? && !parent.method?(:to_h) && !parent.parenthesized?
-              add_parentheses(parent, corrector)
-            end
+            add_parentheses_to_parent_call(node, corrector)
           end
         end
 

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

@@ -34,6 +34,9 @@ module RuboCop
       #   # good - fetch with block is allowed
       #   hash.fetch(key) { default }
       #
+      #   # good - `ENV.fetch` is left to `Style/FetchEnvVar` when it is enabled
+      #   ENV.fetch(key)
+      #
       # @example EnforcedStyle: fetch
       #   # bad
       #   hash[key]
@@ -55,6 +58,9 @@ module RuboCop
 
         RESTRICT_ON_SEND = %i[[] fetch].freeze
 
+        # @!method env_const?(node)
+        def_node_matcher :env_const?, '(const {nil? cbase} :ENV)'
+
         def on_send(node)
           return if (receiver = node.receiver) && allowed_receiver?(receiver)
           return if part_of_ignored_node?(node)
@@ -76,28 +82,55 @@ module RuboCop
         private
 
         def offense_for_brackets?(node)
-          style == :brackets && node.receiver && node.method?(:fetch) && node.arguments.one? &&
-            !node.block_literal? && !node.csend_type?
+          return false if style != :brackets || !node.receiver
+          return false if !node.method?(:fetch) || !node.arguments.one?
+          return false if node.block_literal? || node.csend_type?
+
+          !exempt_from_brackets?(node)
+        end
+
+        def exempt_from_brackets?(node)
+          return true if forwarded_or_splatted?(node.first_argument)
+
+          comment_before_dot?(node) || env_fetch_preferred?(node.receiver)
+        end
+
+        def forwarded_or_splatted?(argument)
+          if argument.hash_type? && !argument.braces?
+            argument.children.any? { |child| child.type?(:kwsplat, :forwarded_kwrestarg) }
+          else
+            argument.type?(:forwarded_args, :forwarded_restarg, :splat, :block_pass)
+          end
+        end
+
+        def comment_before_dot?(node)
+          processed_source.contains_comment?(node.receiver.source_range.end.join(node.loc.dot))
+        end
+
+        def env_fetch_preferred?(receiver)
+          env_const?(receiver) && processed_source.registry.enabled?(Style::FetchEnvVar, config)
         end
 
         def offense_for_fetch?(node)
-          style == :fetch && node.method?(:[]) && node.arguments.one?
+          style == :fetch && node.method?(:[]) && node.arguments.one? &&
+            !compound_assignment_target?(node)
+        end
+
+        def compound_assignment_target?(node)
+          node.parent&.type?(:op_asgn, :or_asgn, :and_asgn) && node.parent.children.first == node
         end
 
         def correct_fetch_to_brackets(corrector, node)
           key = node.first_argument.source
 
-          corrector.replace(node.loc.dot.join(node.source_range.end), "[#{key}]")
+          corrector.replace(node.receiver.source_range.end.join(node.source_range.end), "[#{key}]")
         end
 
         def correct_brackets_to_fetch(corrector, node)
           key = node.first_argument.source
+          replacement = node.loc.dot ? "fetch(#{key})" : ".fetch(#{key})"
 
-          if node.csend_type?
-            corrector.replace(node.loc.dot.join(node.source_range.end), "&.fetch(#{key})")
-          else
-            corrector.replace(node.loc.selector.join(node.source_range.end), ".fetch(#{key})")
-          end
+          corrector.replace(node.loc.selector.join(node.source_range.end), replacement)
         end
       end
     end

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

@@ -142,6 +142,13 @@ module RuboCop
         MSG_HASH_ROCKETS = 'Use hash rockets syntax.'
         NO_MIXED_KEYS_STYLES = %i[ruby19_no_mixed_keys no_mixed_keys].freeze
 
+        # Omitting the last hash value of a call without parentheses adds the parentheses,
+        # which `Style/MethodCallWithArgsParentheses` and `Style/SuperWithArgsParentheses`
+        # would add again in the same pass.
+        def self.autocorrect_incompatible_with
+          [Style::MethodCallWithArgsParentheses, Style::SuperWithArgsParentheses]
+        end
+
         def on_hash(node)
           pairs = node.pairs
 
@@ -241,6 +248,8 @@ module RuboCop
         def check(pairs, delim, msg)
           pairs.each do |pair|
             if pair.delimiter == delim
+              next if pair.value_omission? && keyword_value?(pair)
+
               location = pair.source_range.begin.join(pair.loc.operator)
               add_offense(location, message: msg) do |corrector|
                 autocorrect(corrector, pair)
@@ -283,12 +292,16 @@ module RuboCop
         end
 
         def autocorrect_hash_rockets(corrector, pair_node)
-          op = pair_node.loc.operator
-
           key_with_hash_rocket = ":#{pair_node.key.source}#{pair_node.inverse_delimiter(true)}"
           key_with_hash_rocket += pair_node.key.source if pair_node.value_omission?
           corrector.replace(pair_node.key, key_with_hash_rocket)
-          corrector.remove(range_with_surrounding_space(op))
+          corrector.remove(operator_range(pair_node))
+        end
+
+        def operator_range(pair_node)
+          op = pair_node.loc.operator
+
+          range_with_surrounding_space(op, newlines: !pair_node.value_omission?)
         end
 
         def autocorrect_no_mixed_keys(corrector, pair_node)

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

@@ -188,7 +188,7 @@ module RuboCop
           end
         end
 
-        # rubocop:disable-next Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity
+        # rubocop:disable-next Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity
         def check_expressions(node, expressions, insert_position)
           return if expressions.any?(&:nil?)
 
@@ -198,8 +198,7 @@ module RuboCop
             add_offense(expression) do |corrector|
               next if node.if_type? && (node.ternary? || node.then?)
 
-              range = range_by_whole_lines(expression.source_range, include_final_newline: true)
-              corrector.remove(range)
+              corrector.remove(removal_range(expression))
               next if inserted_expression
 
               if node.parent&.assignment?
@@ -213,6 +212,26 @@ module RuboCop
           end
         end
 
+        def removal_range(expression)
+          range = expression.source_range
+          whole_lines = range_by_whole_lines(range, include_final_newline: true)
+          return whole_lines if whole_lines.source.strip == expression.source
+
+          range_with_separator(range)
+        end
+
+        def range_with_separator(range)
+          source = range.source_buffer.source
+
+          if (following = source[range.end_pos..][/\A[ \t]*;[ \t]*/])
+            range.adjust(end_pos: following.length)
+          elsif (preceding = source[0...range.begin_pos][/[ \t]*;[ \t]*\z/])
+            range.adjust(begin_pos: -preceding.length)
+          else
+            range_with_surrounding_space(range, side: :right, newlines: false)
+          end
+        end
+
         def correct_assignment(corrector, node, expression, insert_position)
           indentation = indentation_of(node.parent)
 

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

@@ -75,7 +75,7 @@ module RuboCop
           return if comments_between_else_and_if?(node, else_branch)
 
           add_offense(else_branch.loc.keyword) do |corrector|
-            next if part_of_ignored_node?(node)
+            next if part_of_ignored_node?(node) || shares_lines_with_other_code?(else_branch)
 
             autocorrect(corrector, else_branch)
             ignore_node(node)
@@ -84,6 +84,26 @@ module RuboCop
 
         private
 
+        # The `elsif` correction moves and removes whole lines, so it can't be applied when
+        # the nested `if` condition, its `if` branch or its `end` shares a line with other code.
+        # A modifier `if` on the `else` line would leave its body on the `elsif` line.
+        def shares_lines_with_other_code?(node)
+          return false if node.then?
+          return !begins_its_line?(node.source_range) if node.modifier_form?
+
+          moved_ranges(node).any? { |range| !begins_its_line?(range) || !ends_its_line?(range) }
+        end
+
+        def moved_ranges(node)
+          ranges = [if_condition_range(node, node.condition), find_end_range(node)]
+          ranges << range_with_comments(node.if_branch) if node.if_branch
+          ranges
+        end
+
+        def ends_its_line?(range)
+          processed_source.lines[range.last_line - 1][range.last_column..].match?(/\A\s*(#|\z)/)
+        end
+
         def autocorrect(corrector, node)
           if node.then?
             # If the nested `if` is a then node, correct it first,

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

@@ -100,6 +100,7 @@ module RuboCop
                     pattern_matching_nodes(condition).any?
 
           return unless (msg = message(node))
+          return if modifier_sharing_line_in_logical_operator?(node)
 
           add_offense(node.loc.keyword, message: format(msg, keyword: node.keyword)) do |corrector|
             next if part_of_ignored_node?(node)
@@ -159,7 +160,7 @@ module RuboCop
           corrector.replace(node, replacement)
         end
 
-        def replacement_for_modifier_form(corrector, node) # rubocop:disable Metrics/AbcSize
+        def replacement_for_modifier_form(corrector, node)
           comment = comment_on_node_line(node)
           if comment && too_long_due_to_comment_after_modifier?(node, comment)
             remove_comment(corrector, node, comment)
@@ -167,12 +168,11 @@ module RuboCop
             return to_modifier_form_with_move_comment(node, indent(node), comment)
           end
 
-          last_argument = node.if_branch.last_argument if node.if_branch.send_type?
-          if last_argument.respond_to?(:heredoc?) && last_argument.heredoc?
-            heredoc = extract_heredoc_from(last_argument)
-            remove_heredoc(corrector, heredoc)
+          heredoc_ranges = heredoc_ranges_in(node)
+          unless heredoc_ranges.empty?
+            remove_heredoc(corrector, heredoc_ranges)
 
-            return to_normal_form_with_heredoc(node, indent(node), heredoc)
+            return to_normal_form_with_heredoc(node, indent(node))
           end
 
           to_normal_form(node, indent(node))
@@ -234,11 +234,18 @@ module RuboCop
         end
 
         def collection_from_ancestor(node)
-          return node if node&.type?(:array, :call)
+          return node if node&.type?(:array, :call, :and, :or)
 
           node.parent if node&.type?(:pair)
         end
 
+        def modifier_sharing_line_in_logical_operator?(node)
+          collection = find_containing_collection(node)
+          return false if !node.modifier_form? || !collection&.operator_keyword?
+
+          another_modifier_if_on_same_line?(node)
+        end
+
         def another_modifier_if_on_same_line?(node)
           collection = find_containing_collection(node)
           return false unless collection
@@ -275,16 +282,20 @@ module RuboCop
           RUBY
         end
 
-        def to_normal_form_with_heredoc(node, indentation, heredoc)
-          heredoc_body, heredoc_end = heredoc
+        def remove_heredoc(corrector, heredoc_ranges)
+          heredoc_ranges.each do |range|
+            corrector.remove(range_by_whole_lines(range, include_final_newline: true))
+          end
+        end
 
-          <<~RUBY.chomp
-            #{node.keyword} #{node.condition.source}
-            #{indentation}  #{node.body.source}
-            #{indentation}  #{heredoc_body.source.chomp}
-            #{indentation}  #{heredoc_end.source.chomp}
-            #{indentation}end
-          RUBY
+        def to_normal_form_with_heredoc(node, indentation)
+          [
+            "#{node.keyword} #{node.condition.source}",
+            *heredoc_ranges_in(node.condition).map(&:source),
+            "#{indentation}  #{node.body.source}",
+            *heredoc_ranges_in(node.if_branch).map(&:source),
+            "#{indentation}end"
+          ].join("\n")
         end
 
         def to_modifier_form_with_move_comment(node, indentation, comment)
@@ -294,17 +305,12 @@ module RuboCop
           RUBY
         end
 
-        def extract_heredoc_from(last_argument)
-          heredoc_body = last_argument.loc.heredoc_body
-          heredoc_end = last_argument.loc.heredoc_end
-
-          [heredoc_body, heredoc_end]
-        end
-
-        def remove_heredoc(corrector, heredoc)
-          heredoc.each do |range|
-            corrector.remove(range_by_whole_lines(range, include_final_newline: true))
+        def heredoc_ranges_in(body)
+          ranges = body.each_node(:any_str).select(&:heredoc?).map do |heredoc|
+            range_by_whole_lines(heredoc.loc.heredoc_body.join(heredoc.loc.heredoc_end))
           end
+          # A heredoc opened in another heredoc's interpolation is moved along with it.
+          ranges.reject { |range| ranges.any? { |other| other.contains?(range) } }
         end
 
         def comment_on_node_line(node)

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

@@ -28,6 +28,10 @@ module RuboCop
 
         MSG = 'Avoid modifier `%<keyword>s` after another conditional.'
 
+        def self.autocorrect_incompatible_with
+          [Style::SoleNestedConditional]
+        end
+
         # rubocop:disable-next Metrics/AbcSize
         def on_if(node)
           return unless node.modifier_form? && node.body.if_type?

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

@@ -21,6 +21,10 @@ module RuboCop
         MSG_NEWLINE = 'Do not use `%<keyword>s %<expr>s;` - use a newline instead.'
         MSG_TERNARY = 'Do not use `%<keyword>s %<expr>s;` - use a ternary operator instead.'
 
+        LOWER_PRECEDENCE_THAN_TERNARY_TYPES = %i[
+          and or if rescue any_match_pattern while until while_post until_post
+        ].freeze
+
         def on_normal_if_unless(node)
           return if node.parent&.if_type?
           return if part_of_ignored_node?(node)
@@ -77,12 +81,14 @@ module RuboCop
         def replacement(node)
           return correct_elsif(node) if node.else_branch&.if_type?
 
-          then_code = node.if_branch ? build_expression(node.if_branch) : 'nil'
-          else_code = node.else_branch ? build_expression(node.else_branch) : 'nil'
+          then_code = node.if_branch ? ternary_operand(node.if_branch) : 'nil'
+          else_code = node.else_branch ? ternary_operand(node.else_branch) : 'nil'
 
           then_code, else_code = else_code, then_code if node.unless?
 
-          "#{ternary_condition(node)} ? #{then_code} : #{else_code}"
+          ternary = "#{ternary_condition(node)} ? #{then_code} : #{else_code}"
+
+          operand_of_parent?(node) ? "(#{ternary})" : ternary
         end
 
         def correct_elsif(node)
@@ -108,7 +114,34 @@ module RuboCop
         # `(a = b) ? c : d`), changing what gets assigned.
         def ternary_condition(node)
           condition = node.condition
-          condition.assignment? ? "(#{condition.source})" : condition.source
+          condition.assignment? ? "(#{condition.source})" : ternary_operand(condition)
+        end
+
+        def ternary_operand(expr)
+          lower_precedence_than_ternary?(expr) ? "(#{expr.source})" : build_expression(expr)
+        end
+
+        # Expressions that bind looser than `?:` (or cannot appear unparenthesized
+        # inside it) would otherwise absorb or break the ternary.
+        def lower_precedence_than_ternary?(node)
+          return true if node.type?(*LOWER_PRECEDENCE_THAN_TERNARY_TYPES)
+          return true if node.send_type? && (node.prefix_not? || prefix_bang_on_command?(node))
+
+          node.type?(:yield, :super, :defined?) && node.arguments.any? && !node.parenthesized?
+        end
+
+        def operand_of_parent?(node)
+          return false unless (parent = node.parent)
+          return true if parent.operator_keyword?
+
+          parent.call_type? && call_operand?(parent, node)
+        end
+
+        def call_operand?(call, node)
+          return false if call.prefix_not?
+          return true if call.receiver.equal?(node)
+
+          call.operator_method? && !call.method?(:[]) && !call.method?(:[]=)
         end
 
         def build_else_branch(second_condition)
@@ -131,6 +164,16 @@ module RuboCop
           result
         end
 
+        # `!foo a` leaves the arguments of `foo` unparenthesized at the end of the operand,
+        # where they would absorb the rest of the ternary.
+        def prefix_bang_on_command?(node)
+          return false unless node.prefix_bang?
+
+          receiver = node.receiver
+
+          require_argument_parentheses?(receiver) || lower_precedence_than_ternary?(receiver)
+        end
+
         def require_argument_parentheses?(node)
           return false if !node.call_type? || node.arithmetic_operation?