rubocop 1.90.0 → 1.92.0

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

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

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

@@ -15,6 +15,10 @@ module RuboCop
         cop_config['IndentationWidth'] || config.for_cop('Layout/IndentationWidth')['Width'] || 2
       end
 
+      def using_tabs?
+        config.for_cop('Layout/IndentationStyle')['EnforcedStyle'] == 'tabs'
+      end
+
       def indentation(node)
         offset(node) + (SPACE * configured_indentation_width)
       end
@@ -66,7 +70,7 @@ module RuboCop
       end
 
       # @deprecated Use processed_source.line_with_comment?(line)
-      def end_of_line_comment(line) # rubocop:disable Naming/PredicateMethod
+      def end_of_line_comment(line) # rubocop:disable Naming/PredicateMethod -- a deprecated shim kept under its original name
         warn Rainbow(<<~WARNING).yellow, uplevel: 1
           `end_of_line_comment` is deprecated. Use `processed_source.line_with_comment?` instead.
         WARNING

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

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

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

@@ -94,22 +94,29 @@ module RuboCop
 
       # @api private
       def first_argument_is_heredoc?(node)
-        first_argument = node.first_argument
-
-        first_argument.respond_to?(:heredoc?) && first_argument.heredoc?
+        node.first_argument.respond_to?(:heredoc?) && node.first_argument.heredoc?
       end
 
       # @api private
       # If a `send` or `csend` node contains a heredoc argument, splitting cannot happen
       # after the heredoc or else it will cause a syntax error.
       def shift_elements_for_heredoc_arg(node, elements, index)
-        return index unless node.type?(:call, :array)
+        return index unless node.type?(:call, :array, :hash)
+        return index unless (heredoc_pos = heredoc_begin_position(node))
+
+        last_safe = elements.rindex { |element| element.source_range.begin_pos <= heredoc_pos }
+        return nil if last_safe.nil? ||
+                      (last_safe.zero? && elements.first.source_range.end_pos > heredoc_pos)
 
-        heredoc_index = elements.index { |arg| arg.respond_to?(:heredoc?) && arg.heredoc? }
-        return index unless heredoc_index
-        return nil if heredoc_index.zero?
+        [index, last_safe + 1].min
+      end
 
-        heredoc_index >= index ? index : heredoc_index + 1
+      # @api private
+      def heredoc_begin_position(node)
+        children = node.call_type? ? node.arguments : node.children
+        children.flat_map { |child| [child, *child.each_descendant(:any_str)] }
+                .find { |descendant| descendant.type?(:any_str) && descendant.heredoc? }
+                &.source_range&.begin_pos
       end
 
       # @api private
@@ -128,9 +135,7 @@ module RuboCop
         # or redundant edits, we only mark one offense at a time.
         return true if contained_by_breakable_collection_on_same_line?(node)
 
-        return true if contained_by_multiline_collection_that_could_be_broken_up?(node)
-
-        false
+        contained_by_multiline_collection_that_could_be_broken_up?(node)
       end
 
       # @api private
@@ -145,9 +150,7 @@ module RuboCop
         # break before the second argument and the rest of the
         # argument will get auto-formatted onto separate lines
         # by other cops.
-        has_second_element = elements.length >= 2
-
-        starts_with_bracket && has_second_element
+        starts_with_bracket && elements.length >= 2
       end
 
       # @api private

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

@@ -14,9 +14,13 @@ module RuboCop
       private
 
       def too_long?(node)
+        too_long_as_single_line?(node.first_line..node.last_line)
+      end
+
+      def too_long_as_single_line?(line_range)
         return false unless max_line_length
 
-        lines = processed_source.lines[(node.first_line - 1)...node.last_line]
+        lines = processed_source.lines[(line_range.begin - 1)...line_range.end]
         to_single_line(lines.join("\n")).length > max_line_length
       end
 

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

@@ -59,12 +59,20 @@ module RuboCop
         return node.loc.name if node.casgn_type?
 
         if LSP.enabled?
-          end_range = node.loc?(:name) ? node.loc.name : node.loc.begin
-          node.source_range.begin.join(end_range)
+          node.source_range.begin.join(header_end(node))
         else
           node.source_range
         end
       end
+
+      # Where the header of a definition ends: the name of a class, module or
+      # method, the `self` of `class << self`, or the opening of a block.
+      def header_end(node)
+        return node.loc.name if node.loc?(:name)
+        return node.identifier.source_range if node.sclass_type?
+
+        node.loc.begin
+      end
     end
   end
 end

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

@@ -5,7 +5,7 @@ module RuboCop
     module Layout
       # Common functionality for checking if presence/absence of empty lines
       # around some kind of body matches the configuration.
-      module EmptyLinesAroundBody
+      module EmptyLinesAroundBody # rubocop:disable Metrics/ModuleLength
         extend NodePattern::Macros
         include ConfigurableEnforcedStyle
         include RangeHelp
@@ -14,6 +14,8 @@ module RuboCop
         MSG_MISSING = 'Empty line missing at %<kind>s body %<location>s.'
         MSG_DEFERRED = 'Empty line missing before first %<type>s definition'
 
+        LEADING_DOT_TYPES = %i[tDOT tANDDOT].to_set.freeze
+
         private
 
         # @!method constant_definition?(node)
@@ -29,6 +31,7 @@ module RuboCop
 
           first_line = adjusted_first_line || node.source_range.first_line
           last_line = node.source_range.last_line
+          return if first_line >= last_line
 
           case style
           when :empty_lines_except_namespace
@@ -99,12 +102,20 @@ module RuboCop
           return unless yield(processed_source.lines[line])
 
           offset = style == :empty_lines && msg.include?('end.') ? 2 : 1
+          return if style == :empty_lines && leading_dot_line?(line + offset)
+
           range = source_range(processed_source.buffer, line + offset, 0)
           add_offense(range, message: msg) do |corrector|
             EmptyLineCorrector.correct(corrector, [style, range])
           end
         end
 
+        def leading_dot_line?(line)
+          first_token = processed_source.sorted_tokens.find { |token| token.line == line }
+
+          LEADING_DOT_TYPES.include?(first_token&.type)
+        end
+
         def check_deferred_empty_line(body)
           node = first_empty_line_required_child(body)
           return unless node

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

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # Common functionality for checking whether a method body can become the
+    # body of an endless method definition without changing its meaning.
+    module EndlessMethodBodyHelp
+      private
+
+      def endless_method_body?(body)
+        return false if body.type?(:begin, :kwbegin, :rescue, :ensure, :masgn)
+        return false if low_precedence_body?(body)
+        return false if ends_with_omitted_hash_value?(body) || ends_with_anonymous_argument?(body)
+        return false if body.assignment? && multiple_values?(assigned_value(body))
+
+        !command_disallowed_in_endless_body?(body)
+      end
+
+      # `def foo = bar and baz` parses as `(def foo = bar) and baz`.
+      def low_precedence_body?(body)
+        body.type?(:any_match_pattern, :while_post, :until_post) ||
+          (body.type?(:and, :or) && body.semantic_operator?) ||
+          (body.type?(:if, :while, :until) && body.modifier_form?)
+      end
+
+      # `foo = 1, 2` and `foo = *bar` assign an array without brackets.
+      def multiple_values?(node)
+        node.array_type? && !node.bracketed?
+      end
+
+      def ends_with_omitted_hash_value?(body)
+        body.each_descendant(:pair).any? do |pair|
+          pair.value_omission? && pair.source_range.end_pos == body.source_range.end_pos
+        end
+      end
+
+      def ends_with_anonymous_argument?(body)
+        forwarding = %i[forwarded_restarg forwarded_kwrestarg block_pass]
+
+        body.each_descendant(*forwarding).any? do |argument|
+          argument.source_range.end_pos == body.source_range.end_pos &&
+            (!argument.block_pass_type? || argument.children.first.nil?)
+        end
+      end
+
+      def command_disallowed_in_endless_body?(body)
+        return true if body.assignment? && command_call?(assigned_value(body))
+
+        body.each_node(:any_block).any? do |block|
+          block.keywords? && command_call?(block.send_node)
+        end
+      end
+
+      def assigned_value(node)
+        while node.assignment? || node.rescue_type?
+          node = node.rescue_type? ? node.body : node.children.last
+        end
+        node
+      end
+
+      def command_call?(node)
+        node = node.send_node if node.any_block_type?
+        return false unless node.type?(:call, :super, :yield)
+
+        node.arguments? && !node.parenthesized? && !node.operator_method? && !node.setter_method?
+      end
+    end
+  end
+end

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

@@ -7,9 +7,9 @@ module RuboCop
       SIGILS = '@$' # if a variable starts with a sigil it will be removed
 
       def forbidden_identifier?(name)
-        name = name.to_s.delete(SIGILS)
+        return false if forbidden_identifiers.empty?
 
-        forbidden_identifiers.any? && forbidden_identifiers.include?(name)
+        forbidden_identifiers.include?(name.to_s.delete(SIGILS))
       end
 
       def forbidden_identifiers

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

@@ -55,7 +55,7 @@ module RuboCop
       # Common functionality for checking alignment of hash values.
       module ValueAlignment
         def checkable_layout?(node)
-          !node.pairs_on_same_line? && !node.mixed_delimiters?
+          !node.pairs_on_same_line? && !node.mixed_delimiters? && alignable_values?(node)
         end
 
         def deltas(first_pair, current_pair)
@@ -68,6 +68,16 @@ module RuboCop
 
         private
 
+        def alignable_values?(node)
+          return false if node.pairs.first.value_omission?
+
+          node.pairs.none? { |pair| value_on_later_line?(pair) }
+        end
+
+        def value_on_later_line?(pair)
+          pair.value && pair.key.last_line != pair.value.first_line
+        end
+
         def separator_delta(first_pair, current_pair, key_delta)
           if current_pair.hash_rocket?
             hash_rocket_delta(first_pair, current_pair) - key_delta
@@ -142,6 +152,17 @@ module RuboCop
           {}
         end
 
+        # Keys are right-aligned by the column their last line ends on.
+        # A key spanning several lines ends on a line other than the one it starts on,
+        # so moving its first line would never change that column and the correction
+        # would be repeated on every pass. Such pairs are left alone, and so is every pair
+        # when the first key spans several lines, since there is then no column to right-align to.
+        def deltas(first_pair, current_pair)
+          return {} if first_pair.key.multiline? || current_pair.key.multiline?
+
+          super
+        end
+
         private
 
         def key_delta(first_pair, current_pair)
@@ -153,7 +174,10 @@ module RuboCop
         end
 
         def value_delta(first_pair, current_pair)
-          current_pair.value_omission? ? 0 : first_pair.value_delta(current_pair)
+          return 0 if first_pair.equal?(current_pair) || current_pair.value_omission?
+
+          expected_value_column = first_pair.loc.operator.end.column + 1
+          expected_value_column - current_pair.value.loc.column
         end
       end
 

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

@@ -11,6 +11,15 @@ module RuboCop
       DO_NOT_MIX_OMIT_VALUE_MSG = "#{DO_NOT_MIX_MSG_PREFIX} #{OMIT_HASH_VALUE_MSG}"
       DO_NOT_MIX_EXPLICIT_VALUE_MSG = "#{DO_NOT_MIX_MSG_PREFIX} #{EXPLICIT_HASH_VALUE_MSG}"
 
+      # A keyword parameter can be named after a keyword, as in `def foo(if:)`,
+      # but the parameter can only be referenced by an omitted hash value,
+      # so `{ if: }` has no explicit form: `{ if: if }` is invalid Ruby.
+      KEYWORDS = %i[
+        __ENCODING__ __FILE__ __LINE__ BEGIN END alias and begin break case class def do
+        else elsif end ensure false for if in module next nil not or redo rescue retry
+        return self super then true undef unless until when while yield
+      ].to_set.freeze
+
       DefNode = Struct.new(:node) do
         def selector
           if node.loc?(:selector)
@@ -53,7 +62,7 @@ module RuboCop
           replacement = "#{hash_key_source}:"
           self.config_to_allow_offenses = { 'Enabled' => false }
         else
-          return unless node.value_omission?
+          return if !node.value_omission? || keyword_value?(node)
 
           message = EXPLICIT_HASH_VALUE_MSG
           replacement = "#{hash_key_source}: #{hash_key_source}"
@@ -87,13 +96,26 @@ module RuboCop
       def ignore_mixed_hash_shorthand_syntax?(hash_node)
         target_ruby_version <= 3.0 ||
           !%w[consistent either_consistent].include?(enforced_shorthand_syntax) ||
-          !hash_node.hash_type?
+          !hash_node.hash_type? || hash_rockets_enforced?(hash_node)
       end
 
       def ignore_hash_shorthand_syntax?(pair_node)
         target_ruby_version <= 3.0 || enforced_shorthand_syntax == 'either' ||
           %w[consistent either_consistent].include?(enforced_shorthand_syntax) ||
-          !pair_node.parent.hash_type?
+          !pair_node.parent.hash_type? || hash_rockets_enforced?(pair_node.parent)
+      end
+
+      def hash_rockets_enforced?(hash_node)
+        style == :hash_rockets || force_hash_rockets?(hash_node.pairs) ||
+          no_mixed_keys_enforces_hash_rockets?(hash_node.pairs)
+      end
+
+      def no_mixed_keys_enforces_hash_rockets?(pairs)
+        case style
+        when :no_mixed_keys then !sym_indices?(pairs) || pairs.first.delimiter == '=>'
+        when :ruby19_no_mixed_keys then !sym_indices?(pairs)
+        else false
+        end
       end
 
       def enforced_shorthand_syntax
@@ -206,6 +228,8 @@ module RuboCop
       def mixed_shorthand_syntax_check(hash_value_type_breakdown)
         if hash_with_values_that_cant_be_omitted?(hash_value_type_breakdown)
           each_omitted_value_pair(hash_value_type_breakdown) do |pair_node|
+            next if keyword_value?(pair_node)
+
             hash_key_source = pair_node.key.source
             replacement = "#{hash_key_source}: #{hash_key_source}"
             register_offense(pair_node, DO_NOT_MIX_EXPLICIT_VALUE_MSG, replacement)
@@ -229,6 +253,10 @@ module RuboCop
           register_offense(pair_node, OMIT_HASH_VALUE_MSG, replacement)
         end
       end
+
+      def keyword_value?(pair_node)
+        KEYWORDS.include?(pair_node.key.value)
+      end
     end
   end
   # rubocop:enable Metrics/ModuleLength

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

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

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

@@ -32,7 +32,9 @@ module RuboCop
         branches << node.if_branch
 
         else_branch = node.else_branch
-        if_conditional_branches(else_branch, branches) if else_branch&.if_type?
+        if else_branch&.if_type? && else_branch.elsif?
+          if_conditional_branches(else_branch, branches)
+        end
         branches
       end
     end

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

@@ -11,8 +11,10 @@ module RuboCop
         return if all_on_same_line?(children, ignore_last: ignore_last)
 
         last_seen_line = -1
-        children.each do |child|
+        children.each_with_index do |child, index|
           if last_seen_line >= child.first_line
+            next if heredoc_opened_before?(children.first(index), child)
+
             add_offense(child) { |corrector| EmptyLineCorrector.insert_before(corrector, child) }
           else
             last_seen_line = child.last_line
@@ -27,6 +29,14 @@ module RuboCop
 
         nodes.first.first_line == nodes.last.last_line
       end
+
+      def heredoc_opened_before?(previous_children, child)
+        previous_children.any? do |previous|
+          previous.each_node(:any_str).any? do |str|
+            str.heredoc? && same_line?(str, child)
+          end
+        end
+      end
     end
   end
 end

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

@@ -15,6 +15,7 @@ module RuboCop
         # If the last node is or contains a conflicting HEREDOC, we don't want
         # to adjust the brace layout because this will result in invalid code.
         return if last_line_heredoc?(node.children.last)
+        return if heredoc_opened_on_closing_brace_line?(node)
 
         check(node)
       end
@@ -136,6 +137,14 @@ module RuboCop
 
         node.children.any? { |child| last_line_heredoc?(child, parent) }
       end
+
+      def heredoc_opened_on_closing_brace_line?(node)
+        closing_brace_line = node.loc.end.line
+
+        node.each_descendant(:any_str).any? do |str|
+          str.heredoc? && str.first_line == closing_brace_line
+        end
+      end
     end
   end
 end

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

@@ -40,7 +40,7 @@ module RuboCop
           OrderedGemCorrector.correct(
             processed_source,
             current,
-            previous_declaration(current),
+            previous,
             treat_comments_as_separators
           ).call(corrector)
         end

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

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # Common functionality for checking whether a node is used in a pattern of
+    # pattern matching, where only some expressions are allowed.
+    module PatternMatchingHelp
+      PATTERN_TYPES = %i[
+        array_pattern array_pattern_with_tail begin const_pattern find_pattern hash_pattern
+        match_alt match_as pair
+      ].freeze
+
+      private
+
+      def in_pattern?(node)
+        child = node
+
+        node.each_ancestor do |ancestor|
+          case ancestor.type
+          when :in_pattern
+            return ancestor.pattern.equal?(child)
+          when :match_pattern, :match_pattern_p
+            return ancestor.children[1].equal?(child)
+          when *PATTERN_TYPES
+            child = ancestor
+          else
+            return false
+          end
+        end
+
+        false
+      end
+    end
+  end
+end

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

@@ -174,15 +174,31 @@ module RuboCop
           #                ^
           tokens = remove_equals_in_def(tokens, processed_source)
 
-          # Only attempt to align the first = on each line
-          Set.new(tokens.uniq(&:line))
+          # Only attempt to align the first = on each line. An `=` that comes after a comparison
+          # on its line is left out as well: whether a line is aligned is judged by its first
+          # assignment or comparison operator, so such an `=` could never be found aligned
+          # and `Layout/SpaceAroundOperators` would keep undoing the padding added for it.
+          Set.new(tokens.uniq(&:line).select do |token|
+            first_operator_on_line(token.line).equal?(token)
+          end)
         end
       end
 
       # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity
       # rubocop:disable Metrics/PerceivedComplexity, Metrics/MethodLength
       def relevant_assignment_lines(line_range)
-        relevant_lines(line_range) { |line_number| assignment_lines.include?(line_number) }
+        relevant_lines(line_range, interrupting_operator_lines) do |line_number|
+          assignment_lines.include?(line_number)
+        end
+      end
+
+      def interrupting_operator_lines
+        @interrupting_operator_lines ||=
+          processed_source.tokens.each_with_object(Set.new) do |token, lines|
+            next unless ASSIGNMENT_OR_COMPARISON_TOKENS.include?(token.type)
+
+            lines << token.line unless assignment_lines.include?(token.line)
+          end
       end
 
       def alignment_lines(line_number)
@@ -259,6 +275,16 @@ module RuboCop
 
         asgn_tokens.reject { |t| eqls_to_ignore.include?(t.begin_pos) }
       end
+
+      def first_operator_on_line(line)
+        @first_operator_by_line ||= processed_source.tokens.each_with_object({}) do |token, by_line|
+          next unless ASSIGNMENT_OR_COMPARISON_TOKENS.include?(token.type)
+
+          by_line[token.line] ||= token
+        end
+
+        @first_operator_by_line[line]
+      end
     end
   end
 end

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

@@ -119,6 +119,21 @@ module RuboCop
         end
       end
 
+      # Whether the `def`/`defs` node overrides a method defined by an ancestor
+      # of its enclosing class or module elsewhere in the project.
+      def overrides_inherited_method?(def_node)
+        return false unless project_index
+        return false unless (namespace_node = def_node.each_ancestor(:class, :module).first)
+
+        declaration = resolve_constant_in_index(namespace_node.identifier)
+        return false unless declaration.is_a?(Rubydex::Namespace)
+
+        scope = def_node.defs_type? ? indexed_singleton_of(declaration) : declaration
+        !scope.nil? && inherited_index_member?(scope, "#{def_node.method_name}()")
+      rescue StandardError
+        false
+      end
+
       # Whether every link of the declaration's ancestry is resolved in the
       # index: no definition of any ancestor has an unresolved superclass or
       # mixin reference. Unresolved links silently vanish from `ancestors`,

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

@@ -51,15 +51,25 @@ module RuboCop
       # regardless of size (for cops where verification is the offense logic).
       def verified_by_reparse(items, oversized: :report)
         scope_groups(items).flat_map do |scope, group|
-          if (oversized == :report && verification_too_large?(scope)) ||
-             (group.size > 1 && corrections_verify?(scope, group))
+          if oversized == :report && verification_too_large?(scope)
             group
           else
-            group.select { |item| corrections_verify?(scope, [item]) }
+            verified_subset(scope, group)
           end
         end
       end
 
+      # Verifies a group with a single reparse and bisects it when that fails,
+      # so a few significant items among many cost a logarithmic number of
+      # reparses rather than one each.
+      def verified_subset(scope, group)
+        return group if corrections_verify?(scope, group)
+        return [] if group.one?
+
+        half = group.size / 2
+        verified_subset(scope, group.take(half)) + verified_subset(scope, group.drop(half))
+      end
+
       # Whether the exact correction for `item` produces source that still
       # parses, without requiring an equivalent AST. For corrections that
       # intentionally change the tree.

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

@@ -96,9 +96,15 @@ module RuboCop
         [parenthesized, first_line_comment(node)].compact.join(' ')
       end
 
+      # rubocop:disable-next Metrics/AbcSize
       def if_body_source(if_body)
         if if_body.call_type? && !if_body.method?(:[]=) && omitted_value_in_last_hash_arg?(if_body)
           "#{method_source(if_body)}(#{if_body.arguments.map(&:source).join(', ')})"
+        elsif (value = wrapped_value(if_body))
+          prefix = if_body.source_range.begin.join(value.source_range.begin).source
+          suffix = value.source_range.end.join(if_body.source_range.end).source
+
+          "#{prefix}#{if_body_source(value)}#{suffix}"
         else
           if_body.source
         end
@@ -116,6 +122,14 @@ module RuboCop
         if_body.source_range.begin.join(end_range).source
       end
 
+      def wrapped_value(if_body)
+        if if_body.type?(:return, :next, :break)
+          if_body.first_argument if if_body.arguments.one?
+        elsif if_body.type?(:lvasgn, :ivasgn, :cvasgn, :gvasgn, :casgn)
+          if_body.expression
+        end
+      end
+
       def first_line_comment(node)
         comment = processed_source.comment_at_line(node.first_line)
         return unless comment
@@ -137,9 +151,15 @@ module RuboCop
         parent = node.parent
         return false if parent.nil?
         return true if parent.assignment? || parent.operator_keyword?
-        return true if %i[array pair].include?(parent.type)
+        return true if parent.type?(:array, :pair, :call, :yield, :super)
+
+        ternary_branch_or_endless_method_body?(parent)
+      end
+
+      def ternary_branch_or_endless_method_body?(parent)
+        return parent.ternary? if parent.if_type?
 
-        node.parent.send_type?
+        parent.any_def_type? && parent.endless?
       end
 
       def comment_disables_cop?(comment)