rubocop 1.84.2 → 1.88.1

data/lib/rubocop/cop/correctors/multiline_literal_brace_corrector.rb

@@ -59,11 +59,7 @@ module RuboCop
       end
 
       def content_if_comment_present(corrector, node)
-        range = range_with_surrounding_space(
-          children(node).last.source_range,
-          side: :right
-        ).end.resize(1)
-        if range.source == '#'
+        if processed_source.comment_at_line(children(node).last.last_line)
           select_content_to_be_inserted_after_last_element(corrector, node)
         else
           node.loc.end.source

data/lib/rubocop/cop/correctors/ordered_gem_corrector.rb

@@ -18,7 +18,14 @@ module RuboCop
           current_range = declaration_with_comment(node)
           previous_range = declaration_with_comment(previous_declaration)
 
-          ->(corrector) { corrector.swap(current_range, previous_range) }
+          lambda do |corrector|
+            if current_range.source.end_with?("\n")
+              corrector.swap(current_range, previous_range)
+            else
+              corrector.insert_before(previous_range, "#{current_range.source}\n")
+              corrector.remove(current_range)
+            end
+          end
         end
 
         private

data/lib/rubocop/cop/correctors/parentheses_corrector.rb

@@ -13,8 +13,7 @@ module RuboCop
           buffer = node.source_range.source_buffer
           corrector.remove(range_with_surrounding_space(range: node.loc.begin, buffer: buffer,
                                                         side: :right, whitespace: true))
-          corrector.remove(range_with_surrounding_space(range: node.loc.end, buffer: buffer,
-                                                        side: :left))
+          remove_close_paren(corrector, node, buffer)
           handle_orphaned_comma(corrector, node)
 
           return unless ternary_condition?(node) && next_char_is_question_mark?(node)
@@ -24,6 +23,38 @@ module RuboCop
 
         private
 
+        # When the line above `)` ends with a comment and a chained call follows `)`,
+        # crossing the newline would pull the chain into the comment. Preserve the newline.
+        def remove_close_paren(corrector, node, buffer)
+          newlines = !comment_above_close_paren_swallows_chain?(node, buffer)
+          corrector.remove(range_with_surrounding_space(range: node.loc.end, buffer: buffer,
+                                                        side: :left, newlines: newlines))
+        end
+
+        def comment_above_close_paren_swallows_chain?(node, buffer)
+          last_child = node.children.last
+          return false unless last_child
+
+          body_end = last_child.source_range.end_pos
+          close_paren_begin = node.loc.end.begin_pos
+          return false if body_end >= close_paren_begin
+
+          source_between = buffer.source[body_end...close_paren_begin]
+          return false unless source_between.match?(/#[^\n]*\n/)
+
+          chained_after_close_paren?(node)
+        end
+
+        def chained_after_close_paren?(node)
+          close_paren = node.loc.end
+          line_text = close_paren.source_line
+          after_paren = line_text[(close_paren.column + 1)..]
+          return false if after_paren.nil?
+
+          trimmed = after_paren.lstrip
+          !trimmed.empty? && !trimmed.start_with?('#')
+        end
+
         def ternary_condition?(node)
           node.parent&.if_type? && node.parent.ternary?
         end

data/lib/rubocop/cop/correctors/percent_literal_corrector.rb

@@ -97,8 +97,8 @@ module RuboCop
         if delimiters.first != delimiters.last
           # With different delimiters (eg. `[]`, `()`), if there are the same
           # number of each, escaping is not necessary
-          delimiter_counts = delimiters.each_with_object({}) do |delimiter, counts|
-            counts[delimiter] = content.count(delimiter)
+          delimiter_counts = delimiters.to_h do |delimiter|
+            [delimiter, content.count(delimiter)]
           end
 
           return content if delimiter_counts[delimiters.first] == delimiter_counts[delimiters.last]

data/lib/rubocop/cop/correctors.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop # rubocop:disable Style/Documentation
+    # Autoloads corrector classes used by cops. Classes are autoloaded to reduce the number of
+    # required classes because they're referenced only when autocorrection is performed.
+
+    # rubocop:disable Layout/LineLength
+    autoload :AlignmentCorrector, 'rubocop/cop/correctors/alignment_corrector'
+    autoload :ConditionCorrector, 'rubocop/cop/correctors/condition_corrector'
+    autoload :EachToForCorrector, 'rubocop/cop/correctors/each_to_for_corrector'
+    autoload :EmptyLineCorrector, 'rubocop/cop/correctors/empty_line_corrector'
+    autoload :ForToEachCorrector, 'rubocop/cop/correctors/for_to_each_corrector'
+    autoload :IfThenCorrector, 'rubocop/cop/correctors/if_then_corrector'
+    autoload :LambdaLiteralToMethodCorrector, 'rubocop/cop/correctors/lambda_literal_to_method_corrector'
+    autoload :LineBreakCorrector, 'rubocop/cop/correctors/line_break_corrector'
+    autoload :MultilineLiteralBraceCorrector, 'rubocop/cop/correctors/multiline_literal_brace_corrector'
+    autoload :OrderedGemCorrector, 'rubocop/cop/correctors/ordered_gem_corrector'
+    autoload :ParenthesesCorrector, 'rubocop/cop/correctors/parentheses_corrector'
+    autoload :PercentLiteralCorrector, 'rubocop/cop/correctors/percent_literal_corrector'
+    autoload :PunctuationCorrector, 'rubocop/cop/correctors/punctuation_corrector'
+    autoload :RequireLibraryCorrector, 'rubocop/cop/correctors/require_library_corrector'
+    autoload :SpaceCorrector, 'rubocop/cop/correctors/space_corrector'
+    autoload :StringLiteralCorrector, 'rubocop/cop/correctors/string_literal_corrector'
+    autoload :UnusedArgCorrector, 'rubocop/cop/correctors/unused_arg_corrector'
+    # rubocop:enable Layout/LineLength
+  end
+end

data/lib/rubocop/cop/documentation.rb

@@ -55,10 +55,9 @@ module RuboCop
 
       # @api private
       def builtin?(cop_class)
-        # any custom method will do
-        return false unless (m = cop_class.instance_methods(false).first)
+        return false unless (name = cop_class.name)
 
-        path, _line = cop_class.instance_method(m).source_location
+        path, _line = Module.const_source_location(name)
         path.start_with?(__dir__)
       end
     end

data/lib/rubocop/cop/exclude_limit.rb

@@ -4,16 +4,42 @@ module RuboCop
   # Allows specified configuration options to have an exclude limit
   # ie. a maximum value tracked that it can be used by `--auto-gen-config`.
   module ExcludeLimit
+    class << self
+      attr_accessor :tmp_dir
+
+      # Reads the aggregated exclude limit values for a cop from tmp files.
+      # Returns a hash like { 'Max' => 81 } or an empty hash if no values were written.
+      def read_limits(cop_name)
+        cop_dir = cop_dir_for(cop_name)
+        return {} unless cop_dir&.directory?
+
+        limits = {}
+        cop_dir.children.each do |filepath|
+          next unless filepath.file?
+
+          values = filepath.readlines.map(&:to_i)
+          limits[filepath.basename.to_s] = values.max unless values.empty?
+        end
+        limits
+      end
+
+      # Returns the tmp directory path for a given cop, or nil if tmp_dir is not set.
+      def cop_dir_for(cop_name)
+        tmp_dir&.join(cop_name.tr('/', '-'))
+      end
+    end
+
     # Sets up a configuration option to have an exclude limit tracked.
     # The parameter name given is transformed into a method name (eg. `Max`
     # becomes `self.max=` and `MinDigits` becomes `self.min_digits=`).
     def exclude_limit(parameter_name, method_name: transform(parameter_name))
       define_method(:"#{method_name}=") do |value|
-        cfg = config_to_allow_offenses
-        cfg[:exclude_limit] ||= {}
-        current_max = cfg[:exclude_limit][parameter_name]
-        value = [current_max, value].max if current_max
-        cfg[:exclude_limit][parameter_name] = value
+        cop_dir = RuboCop::ExcludeLimit.cop_dir_for(self.class.badge.to_s)
+        return unless cop_dir
+
+        cop_dir.mkpath
+        filepath = cop_dir.join(parameter_name)
+        filepath.write("#{value}\n", mode: 'a')
       end
     end
 

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

@@ -95,7 +95,7 @@ module RuboCop
         private
 
         def forbidden_gem?(gem_name)
-          !cop_config['AllowedGems'].include?(gem_name)
+          !Array(cop_config['AllowedGems']).include?(gem_name)
         end
 
         def message(_range)

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

@@ -3,12 +3,12 @@
 module RuboCop
   module Cop
     module Gemspec
-      # An attribute assignment method calls should be listed only once
+      # An attribute assignment method call should be listed only once
       # in a gemspec.
       #
       # Assigning to an attribute with the same name using `spec.foo =` or
       # `spec.attribute#[]=` will be an unintended usage. On the other hand,
-      # duplication of methods such # as `spec.requirements`,
+      # duplication of methods such as `spec.requirements`,
       # `spec.add_runtime_dependency`, and others are permitted because it is
       # the intended use of appending values.
       #

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

@@ -6,7 +6,7 @@ module RuboCop
       # Requires a gemspec to have `rubygems_mfa_required` metadata set.
       #
       # This setting tells RubyGems that MFA (Multi-Factor Authentication) is
-      # required for accounts to be able perform privileged operations, such as
+      # required for accounts to be able to perform privileged operations, such as
       # (see RubyGems' documentation for the full list of privileged
       # operations):
       #
@@ -70,7 +70,7 @@ module RuboCop
         def_node_matcher :metadata, <<~PATTERN
           `{
             (send _ :metadata= $_)
-            (send (send _ :metadata) :[]= (str "rubygems_mfa_required") $_)
+            (send (send _ :metadata) :[]= {(str "rubygems_mfa_required") (sym :rubygems_mfa_required)} $_)
           }
         PATTERN
 
@@ -78,13 +78,13 @@ module RuboCop
         def_node_search :metadata_assignment, <<~PATTERN
           `{
             (send _ :metadata= _)
-            (send (send _ :metadata) :[]= (str _) _)
+            (send (send _ :metadata) :[]= {str sym} _)
           }
         PATTERN
 
         # @!method rubygems_mfa_required(node)
         def_node_search :rubygems_mfa_required, <<~PATTERN
-          (pair (str "rubygems_mfa_required") $_)
+          (pair {(str "rubygems_mfa_required") (sym :rubygems_mfa_required)} $_)
         PATTERN
 
         # @!method true_string?(node)
@@ -92,7 +92,7 @@ module RuboCop
           (str "true")
         PATTERN
 
-        def on_block(node) # rubocop:disable Metrics/MethodLength, InternalAffairs/NumblockHandler
+        def on_block(node) # rubocop:disable Metrics/MethodLength, InternalAffairs/NumblockHandler, InternalAffairs/ItblockHandler
           gem_specification(node) do |block_var|
             metadata_value = metadata(node)
             mfa_value = mfa_value(metadata_value)
@@ -143,7 +143,10 @@ module RuboCop
             #{block_var}.metadata['rubygems_mfa_required'] = 'true'
           RUBY
 
-          if (last_assignment = metadata_assignment(processed_source.ast).to_a.last)
+          # Scope the search to the current spec block. Searching the whole file
+          # would, for a second `Gem::Specification.new` block, insert the directive
+          # into the first block, leaving this block uncorrected and looping forever.
+          if (last_assignment = metadata_assignment(node).to_a.last)
             corrector.insert_after(last_assignment, "\n#{require_mfa_directive}")
           else
             corrector.insert_before(node.loc.end, "#{require_mfa_directive}\n")

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

@@ -4,10 +4,10 @@ module RuboCop
   module Cop
     module Gemspec
       # Checks that `RUBY_VERSION` and `Ruby::VERSION` constants are not used in gemspec.
-      # Using `RUBY_VERSION` and `Ruby::VERSION` are dangerous because value of the
+      # Using `RUBY_VERSION` and `Ruby::VERSION` is dangerous because the value of the
       # constant is determined by `rake release`.
-      # It's possible to have dependency based on ruby version used
-      # to execute `rake release` and not user's ruby version.
+      # It's possible to have a dependency based on the Ruby version used
+      # to execute `rake release` and not the user's Ruby version.
       #
       # @example
       #

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

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module InternalAffairs
+      # Checks for missing `itblock` handlers. The blocks with the `it`
+      # parameter introduced in Ruby 3.4 are parsed with a node type of
+      # `itblock` instead of block. Cops that define `block` handlers
+      # need to define `itblock` handlers or disable this cop for them.
+      #
+      # @example
+      #
+      #   # bad
+      #   class BlockRelatedCop < Base
+      #     def on_block(node)
+      #     end
+      #   end
+      #
+      #   # good
+      #   class BlockRelatedCop < Base
+      #     def on_block(node)
+      #     end
+      #
+      #     alias on_itblock on_block
+      #   end
+      #
+      #   class BlockRelatedCop < Base
+      #     def on_block(node)
+      #     end
+      #
+      #     alias_method :on_itblock, :on_block
+      #   end
+      #
+      #   class BlockRelatedCop < Base
+      #     def on_block(node)
+      #     end
+      #
+      #     def on_itblock(node)
+      #     end
+      #   end
+      class ItblockHandler < Base
+        MSG = 'Define on_itblock to handle blocks with the `it` parameter.'
+
+        def on_def(node)
+          return unless block_handler?(node)
+          return unless node.parent
+
+          add_offense(node) unless itblock_handler?(node.parent)
+        end
+
+        private
+
+        # @!method block_handler?(node)
+        def_node_matcher :block_handler?, <<~PATTERN
+          (def :on_block (args (arg :node)) ...)
+        PATTERN
+
+        # @!method itblock_handler?(node)
+        def_node_matcher :itblock_handler?, <<~PATTERN
+          {
+            `(def :on_itblock (args (arg :node)) ...)
+            `(alias (sym :on_itblock) (sym :on_block))
+            `(send nil? :alias_method (sym :on_itblock) (sym :on_block))
+          }
+        PATTERN
+      end
+    end
+  end
+end

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

@@ -25,6 +25,7 @@ module RuboCop
         def_node_matcher :line_send, <<~PATTERN
           {
             (send (send _ {:loc :source_range}) {:line :first_line})
+            (send (send (send _ :loc) {:begin :end}) :line)
             (send _ :first_line)
           }
         PATTERN

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

@@ -46,8 +46,7 @@ module RuboCop
 
         def on_block(node)
           return unless let_rubocop_config_new?(node)
-
-          describe = find_describe_method_node(node)
+          return unless (describe = find_describe_method_node(node))
 
           unless (exist_config = describe.last_argument.source == ':config')
             additional_message = ' and specify `:config` in `describe`'
@@ -65,7 +64,10 @@ module RuboCop
         private
 
         def find_describe_method_node(block_node)
-          block_node.ancestors.find { |node| node.block_type? && node.method?(:describe) }.send_node
+          describe = block_node.ancestors.find do |ancestor|
+            ancestor.block_type? && ancestor.method?(:describe)
+          end
+          describe&.send_node
         end
       end
     end

data/lib/rubocop/cop/internal_affairs.rb

@@ -7,6 +7,7 @@ require_relative 'internal_affairs/empty_line_between_expect_offense_and_correct
 require_relative 'internal_affairs/example_description'
 require_relative 'internal_affairs/example_heredoc_delimiter'
 require_relative 'internal_affairs/inherit_deprecated_cop_class'
+require_relative 'internal_affairs/itblock_handler'
 require_relative 'internal_affairs/lambda_or_proc'
 require_relative 'internal_affairs/location_exists'
 require_relative 'internal_affairs/location_expression'

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Layout
-      # Check that the arguments on a multi-line method call are aligned.
+      # Checks that the arguments on a multi-line method call are aligned.
       #
       # @example EnforcedStyle: with_first_argument (default)
       #   # good
@@ -52,7 +52,7 @@ module RuboCop
                            'following the first line of a multi-line method call.'
 
         def on_send(node)
-          return if !multiple_arguments?(node) || (node.send_type? && node.method?(:[]=)) ||
+          return if !multiple_arguments?(node) || (node.call_type? && node.method?(:[]=)) ||
                     autocorrect_incompatible_with_other_cops?
 
           items = flattened_arguments(node)

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Layout
-      # Check that the elements of a multi-line array literal are
+      # Checks that the elements of a multi-line array literal are
       # aligned.
       #
       # @example EnforcedStyle: with_first_element (default)

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

@@ -14,7 +14,7 @@ module RuboCop
       # `Layout/EndAlignment` cop aligns with keywords (e.g. `if`, `while`, `case`)
       # by default. On the other hand, `||= begin` that this cop targets tends to
       # align with the start of the line, it defaults to `EnforcedStyleAlignWith: start_of_line`.
-      # These style can be configured by each cop.
+      # These styles can be configured by each cop.
       #
       # @example EnforcedStyleAlignWith: start_of_line (default)
       #   # bad

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

@@ -18,6 +18,10 @@ module RuboCop
       # `either` (which is the default) : the `end` is allowed to be in either
       # location. The autocorrect will default to `start_of_line`.
       #
+      # When the `do` or `{` appears on a continuation line of multiline
+      # method arguments, the start of the line where the method is called
+      # is used as the alignment target instead of that continuation line.
+      #
       # @example EnforcedStyleAlignWith: either (default)
       #   # bad
       #
@@ -116,6 +120,7 @@ module RuboCop
           end_loc = block_node.loc.end
           return unless begins_its_line?(end_loc)
 
+          start_node = start_for_line_node(block_node) if style == :start_of_line
           start_loc = start_node.source_range
           return unless start_loc.column != end_loc.column || style == :start_of_block
 
@@ -196,23 +201,34 @@ module RuboCop
 
         def compute_do_source_line_column(node, end_loc)
           do_loc = node.loc.begin # Actually it's either do or {.
+          anchor_loc = do_line_anchor_loc(node, do_loc)
 
           # We've found that "end" is not aligned with the start node (which
           # can be a block, a variable assignment, etc). But we also allow
           # the "end" to be aligned with the start of the line where the "do"
           # is, which is a style some people use in multi-line chains of
           # blocks.
-          match = /\S.*/.match(do_loc.source_line)
+          match = /\S.*/.match(anchor_loc.source_line)
           indentation_of_do_line = match.begin(0)
-          return unless end_loc.column != indentation_of_do_line || style == :start_of_line
+          permitted_columns = permitted_do_line_columns(do_loc, indentation_of_do_line)
+          return if permitted_columns.include?(end_loc.column) && style != :start_of_line
 
           {
             source: match[0],
-            line: do_loc.line,
+            line: anchor_loc.line,
             column: indentation_of_do_line
           }
         end
 
+        # `end` aligned with an argument continuation line that holds the `do`
+        # was accepted before the anchor moved to the method dispatch line;
+        # keep accepting it so that such code does not become an offense.
+        def permitted_do_line_columns(do_loc, indentation_of_do_line)
+          columns = [indentation_of_do_line]
+          columns << (do_loc.source_line =~ /\S/) if style == :either
+          columns
+        end
+
         def loc_to_source_line_column(loc)
           {
             source: loc.source.lines.to_a.first.chomp,
@@ -239,7 +255,7 @@ module RuboCop
         def compute_start_col(ancestor_node, node)
           if style == :start_of_block
             do_loc = node.loc.begin
-            return do_loc.source_line =~ /\S/
+            return do_line_anchor_loc(node, do_loc).source_line =~ /\S/
           end
           (ancestor_node || node).source_range.column
         end
@@ -253,6 +269,44 @@ module RuboCop
 
           corrector.remove(range)
         end
+
+        # When the `do` or `{` is on a continuation line of multiline method
+        # arguments, the indentation of that line is not a meaningful
+        # alignment target; anchor on the method dispatch position instead.
+        def do_line_anchor_loc(node, do_loc)
+          if do_line_begins_inside_argument?(node, do_loc)
+            node.send_node.selector || node.send_node.source_range
+          else
+            do_loc
+          end
+        end
+
+        # rubocop:disable Metrics/AbcSize
+        def do_line_begins_inside_argument?(node, do_loc)
+          line_begin_pos = do_loc.begin_pos - do_loc.column
+          first_char_pos = line_begin_pos + (do_loc.source_line =~ /\S/)
+          return false unless inside_parentheses?(node, first_char_pos)
+
+          (node.send_node.arguments + node.arguments).any? do |argument|
+            argument.source_range.begin_pos <= first_char_pos &&
+              first_char_pos < argument.source_range.end_pos
+          end
+        end
+        # rubocop:enable Metrics/AbcSize
+
+        # The continuation line indentation is only an unmeaningful alignment target when
+        # it is dictated by an opening delimiter, i.e. the line begins inside `(` or `[`.
+        # For a bare argument list without parentheses the indentation is the author's
+        # deliberate alignment, so the anchor must not move to the method dispatch line.
+        def inside_parentheses?(node, pos)
+          preceding_tokens = processed_source.tokens.select do |token|
+            token.begin_pos >= node.source_range.begin_pos && token.begin_pos < pos
+          end
+          opens = preceding_tokens.count { |token| token.left_parens? || token.left_bracket? }
+          closes = preceding_tokens.count { |token| token.right_parens? || token.right_bracket? }
+
+          opens > closes
+        end
       end
     end
   end

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

@@ -49,7 +49,7 @@ module RuboCop
       #      - private_methods
       # ----
       #
-      # Instead of putting all literals in the expected order, is also
+      # Instead of putting all literals in the expected order, it is also
       # possible to group categories of macros. Visibility levels are handled
       # automatically.
       #
@@ -278,10 +278,14 @@ module RuboCop
 
           return [] unless class_def
 
-          if class_def.type?(:def, :send)
-            [class_def]
-          else
+          # Only a multi-statement body (`begin`/`kwbegin`) wraps several elements; any
+          # single statement (`def`, `send`, `csend`, `if`, ...) is itself the sole element.
+          # Exploding such a node into its children would yield non-node values (e.g. a
+          # method-name `Symbol` from a `csend`) and crash later checks.
+          if class_def.type?(:begin, :kwbegin)
             class_def.children.compact
+          else
+            [class_def]
           end
         end
 

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

@@ -44,16 +44,26 @@ module RuboCop
           message = message(condition)
 
           add_offense(condition, message: message) do |corrector|
-            range = range_by_whole_lines(condition.source_range, include_final_newline: true)
-
             corrector.insert_after(condition.parent.loc.keyword, " #{condition.source}")
-            corrector.remove(range)
+            corrector.remove(removal_range(node, condition))
           end
         end
 
         def message(condition)
           format(MSG, keyword: condition.parent.keyword)
         end
+
+        # When a body statement shares the condition's line (e.g. `while\n cond; body\nend`),
+        # removing the whole line would delete the body too. In that case only remove the
+        # condition and its trailing separator, preserving the body statement.
+        def removal_range(node, condition)
+          body = node.body
+          if body && body.source_range.line == condition.source_range.last_line
+            range_between(condition.source_range.begin_pos, body.source_range.begin_pos)
+          else
+            range_by_whole_lines(condition.source_range, include_final_newline: true)
+          end
+        end
       end
     end
   end

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

@@ -112,7 +112,7 @@ module RuboCop
         end
 
         def last_heredoc_line(node)
-          if node.send_type?
+          if node.call_type?
             node.arguments.select { |arg| heredoc?(arg) }.map { |arg| arg.loc.heredoc_end.line }.max
           elsif heredoc?(node)
             node.loc.heredoc_end.line

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

@@ -95,8 +95,7 @@ module RuboCop
         end
 
         def autocorrect(corrector, node)
-          previous_token = previous_token(node)
-          range = if previous_token && same_line?(node, previous_token)
+          range = if inline_comment?(node)
                     range_with_surrounding_space(node.source_range, newlines: false)
                   else
                     range_by_whole_lines(node.source_range, include_final_newline: true)
@@ -138,14 +137,13 @@ module RuboCop
           cop_config['AllowMarginComment']
         end
 
-        def current_token(comment)
-          processed_source.tokens.find { |token| token.pos == comment.source_range }
-        end
-
-        def previous_token(node)
-          current_token = current_token(node)
-          index = processed_source.tokens.index(current_token)
-          index.zero? ? nil : processed_source.tokens[index - 1]
+        # A comment is inline when code precedes it on the same line. Detecting this
+        # from the source (rather than the token stream) is required because, for a
+        # comment trailing a heredoc opener, the preceding token is the heredoc end on
+        # a later line, which would wrongly trigger whole-line removal of the opener.
+        def inline_comment?(comment)
+          preceding_source = processed_source.lines[comment.loc.line - 1][0...comment.loc.column]
+          !preceding_source.strip.empty?
         end
       end
     end