rubocop 1.53.1 → 1.90.0

data/lib/rubocop/cop/bundler/gem_version.rb

@@ -7,48 +7,48 @@ module RuboCop
       # ref, or tag) are either required or forbidden.
       #
       # @example EnforcedStyle: required (default)
-      #  # bad
-      #  gem 'rubocop'
+      #   # bad
+      #   gem 'rubocop'
       #
-      #  # good
-      #  gem 'rubocop', '~> 1.12'
+      #   # good
+      #   gem 'rubocop', '~> 1.12'
       #
-      #  # good
-      #  gem 'rubocop', '>= 1.10.0'
+      #   # good
+      #   gem 'rubocop', '>= 1.10.0'
       #
-      #  # good
-      #  gem 'rubocop', '>= 1.5.0', '< 1.10.0'
+      #   # good
+      #   gem 'rubocop', '>= 1.5.0', '< 1.10.0'
       #
-      #  # good
-      #  gem 'rubocop', branch: 'feature-branch'
+      #   # good
+      #   gem 'rubocop', branch: 'feature-branch'
       #
-      #  # good
-      #  gem 'rubocop', ref: '74b5bfbb2c4b6fd6cdbbc7254bd7084b36e0c85b'
+      #   # good
+      #   gem 'rubocop', ref: '74b5bfbb2c4b6fd6cdbbc7254bd7084b36e0c85b'
       #
-      #  # good
-      #  gem 'rubocop', tag: 'v1.17.0'
+      #   # good
+      #   gem 'rubocop', tag: 'v1.17.0'
       #
       # @example EnforcedStyle: forbidden
-      #  # good
-      #  gem 'rubocop'
+      #   # good
+      #   gem 'rubocop'
       #
-      #  # bad
-      #  gem 'rubocop', '~> 1.12'
+      #   # bad
+      #   gem 'rubocop', '~> 1.12'
       #
-      #  # bad
-      #  gem 'rubocop', '>= 1.10.0'
+      #   # bad
+      #   gem 'rubocop', '>= 1.10.0'
       #
-      #  # bad
-      #  gem 'rubocop', '>= 1.5.0', '< 1.10.0'
+      #   # bad
+      #   gem 'rubocop', '>= 1.5.0', '< 1.10.0'
       #
-      #  # bad
-      #  gem 'rubocop', branch: 'feature-branch'
+      #   # bad
+      #   gem 'rubocop', branch: 'feature-branch'
       #
-      #  # bad
-      #  gem 'rubocop', ref: '74b5bfbb2c4b6fd6cdbbc7254bd7084b36e0c85b'
+      #   # bad
+      #   gem 'rubocop', ref: '74b5bfbb2c4b6fd6cdbbc7254bd7084b36e0c85b'
       #
-      #  # bad
-      #  gem 'rubocop', tag: 'v1.17.0'
+      #   # bad
+      #   gem 'rubocop', tag: 'v1.17.0'
       #
       class GemVersion < Base
         include ConfigurableEnforcedStyle
@@ -56,6 +56,7 @@ module RuboCop
 
         REQUIRED_MSG = 'Gem version specification is required.'
         FORBIDDEN_MSG = 'Gem version specification is forbidden.'
+        RESTRICT_ON_SEND = %i[gem].freeze
         VERSION_SPECIFICATION_REGEX = /^\s*[~<>=]*\s*[0-9.]+/.freeze
 
         # @!method includes_version_specification?(node)
@@ -90,13 +91,11 @@ module RuboCop
           Array(cop_config['AllowedGems'])
         end
 
-        def message(range)
-          gem_specification = range.source
-
+        def message(_range)
           if required_style?
-            format(REQUIRED_MSG, gem_specification: gem_specification)
+            REQUIRED_MSG
           elsif forbidden_style?
-            format(FORBIDDEN_MSG, gem_specification: gem_specification)
+            FORBIDDEN_MSG
           end
         end
 

data/lib/rubocop/cop/bundler/insecure_protocol_source.rb

@@ -39,7 +39,6 @@ module RuboCop
       #   source 'http://rubygems.org'
       #
       class InsecureProtocolSource < Base
-        include RangeHelp
         extend AutoCorrector
 
         MSG = 'The source `:%<source>s` is deprecated because HTTP requests ' \

data/lib/rubocop/cop/bundler/ordered_gems.rb

@@ -19,7 +19,15 @@ module RuboCop
       #
       #   gem 'rspec'
       #
-      #   # good only if TreatCommentsAsGroupSeparators is true
+      # @example TreatCommentsAsGroupSeparators: true (default)
+      #   # good
+      #   # For code quality
+      #   gem 'rubocop'
+      #   # For tests
+      #   gem 'rspec'
+      #
+      # @example TreatCommentsAsGroupSeparators: false
+      #   # bad
       #   # For code quality
       #   gem 'rubocop'
       #   # For tests
@@ -35,9 +43,8 @@ module RuboCop
         def on_new_investigation
           return if processed_source.blank?
 
-          gem_declarations(processed_source.ast)
-            .each_cons(2) do |previous, current|
-            next unless consecutive_lines(previous, current)
+          gem_declarations(processed_source.ast).each_cons(2) do |previous, current|
+            next unless consecutive_lines?(previous, current)
             next unless case_insensitive_out_of_order?(gem_name(current), gem_name(previous))
 
             register_offense(previous, current)

data/lib/rubocop/cop/bundler.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # Cops for the `Bundler` department. The department's cops are registered for lazy loading
+    # and their files are loaded on demand.
+    module Bundler
+      extend LazyLoader
+
+      register_cop :DuplicatedGem, "#{__dir__}/bundler/duplicated_gem"
+      register_cop :DuplicatedGroup, "#{__dir__}/bundler/duplicated_group"
+      register_cop :GemComment, "#{__dir__}/bundler/gem_comment"
+      register_cop :GemFilename, "#{__dir__}/bundler/gem_filename"
+      register_cop :GemVersion, "#{__dir__}/bundler/gem_version"
+      register_cop :InsecureProtocolSource, "#{__dir__}/bundler/insecure_protocol_source"
+      register_cop :OrderedGems, "#{__dir__}/bundler/ordered_gems"
+    end
+  end
+end

data/lib/rubocop/cop/commissioner.rb

@@ -64,14 +64,16 @@ module RuboCop
         r = '#' unless RESTRICTED_CALLBACKS.include?(method_name) # has Restricted?
         c = '#' if NO_CHILD_NODES.include?(node_type) # has Children?
 
+        # The `after_` calls are guarded because barely any cop defines an `after_`
+        # callback, and the guard is cheaper than the method call it avoids.
         class_eval(<<~RUBY, __FILE__, __LINE__ + 1)
-                  def on_#{node_type}(node)                               # def on_send(node)
-                    trigger_responding_cops(:on_#{node_type}, node)       #   trigger_responding_cops(:on_send, node)
-              #{r}  trigger_restricted_cops(:on_#{node_type}, node)       #   trigger_restricted_cops(:on_send, node)
-          #{c}      super(node)                                           #   super(node)
-          #{c}      trigger_responding_cops(:after_#{node_type}, node)    #   trigger_responding_cops(:after_send, node)
-          #{c}#{r}  trigger_restricted_cops(:after_#{node_type}, node)    #   trigger_restricted_cops(:after_send, node)
-                  end                                                     # end
+                  def on_#{node_type}(node)                                                                                # def on_send(node)
+                    trigger_responding_cops(:on_#{node_type}, node)                                                        #   trigger_responding_cops(:on_send, node)
+              #{r}  trigger_restricted_cops(:on_#{node_type}, node)                                                        #   trigger_restricted_cops(:on_send, node)
+          #{c}      super(node)                                                                                            #   super(node)
+          #{c}      trigger_responding_cops(:after_#{node_type}, node) if @callbacks[:after_#{node_type}]                  #   trigger_responding_cops(:after_send, node) if @callbacks[:after_send]
+          #{c}#{r}  trigger_restricted_cops(:after_#{node_type}, node) unless @restricted_map[:after_#{node_type}].empty?  #   trigger_restricted_cops(:after_send, node) unless @restricted_map[:after_send].empty?
+                  end                                                                                                      # end
         RUBY
       end
 
@@ -81,13 +83,13 @@ module RuboCop
 
         begin_investigation(processed_source, offset: offset, original: original)
         if processed_source.valid_syntax?
-          invoke(:on_new_investigation, @cops)
+          invoke(:on_new_investigation, @callbacks[:on_new_investigation])
           invoke_with_argument(:investigate, @forces, processed_source)
 
           walk(processed_source.ast) unless @cops.empty?
-          invoke(:on_investigation_end, @cops)
+          invoke(:on_investigation_end, @callbacks[:on_investigation_end])
         else
-          invoke(:on_other_file, @cops)
+          invoke(:on_other_file, @callbacks[:on_other_file])
         end
         reports = @cops.map { |cop| cop.send(:complete_investigation) }
         InvestigationReport.new(processed_source, reports, @errors)
@@ -157,7 +159,7 @@ module RuboCop
       end
 
       def invoke(callback, cops)
-        cops.each { |cop| with_cop_error_handling(cop) { cop.send(callback) } }
+        cops&.each { |cop| with_cop_error_handling(cop) { cop.send(callback) } }
       end
 
       def invoke_with_argument(callback, cops, arg)

data/lib/rubocop/cop/cop.rb

@@ -22,6 +22,14 @@ module RuboCop
         end
       end
 
+      def self.inherited(_subclass)
+        super
+        warn Rainbow(<<~WARNING).yellow, uplevel: 1
+          Inheriting from `RuboCop::Cop::Cop` is deprecated. Use `RuboCop::Cop::Base` instead.
+          For more information, see https://docs.rubocop.org/rubocop/v1_upgrade_notes.html.
+        WARNING
+      end
+
       def self.support_autocorrect?
         method_defined?(:autocorrect)
       end
@@ -37,16 +45,28 @@ module RuboCop
 
       # @deprecated Use Registry.global
       def self.registry
+        warn Rainbow(<<~WARNING).yellow, uplevel: 1
+          `Cop.registry` is deprecated. Use `Registry.global` instead.
+        WARNING
+
         Registry.global
       end
 
       # @deprecated Use Registry.all
       def self.all
+        warn Rainbow(<<~WARNING).yellow, uplevel: 1
+          `Cop.all` is deprecated. Use `Registry.all` instead.
+        WARNING
+
         Registry.all
       end
 
       # @deprecated Use Registry.qualified_cop_name
       def self.qualified_cop_name(name, origin)
+        warn Rainbow(<<~WARNING).yellow, uplevel: 1
+          `Cop.qualified_cop_name` is deprecated. Use `Registry.qualified_cop_name` instead.
+        WARNING
+
         Registry.qualified_cop_name(name, origin)
       end
 
@@ -58,7 +78,7 @@ module RuboCop
         # template file, we convert it to location info in the original file.
         range = range_for_original(range)
 
-        if block.nil? && !support_autocorrect?
+        if block.nil? && !self.class.support_autocorrect?
           super(range, message: message, severity: severity)
         else
           super(range, message: message, severity: severity) do |corrector|
@@ -74,13 +94,19 @@ module RuboCop
 
       # @deprecated Use class method
       def support_autocorrect?
-        # warn 'deprecated, use cop.class.support_autocorrect?' TODO
+        warn Rainbow(<<~WARNING).yellow, uplevel: 1
+          `support_autocorrect?` is deprecated. Use `cop.class.support_autocorrect?`.
+        WARNING
+
         self.class.support_autocorrect?
       end
 
       # @deprecated
       def corrections
-        # warn 'Cop#corrections is deprecated' TODO
+        warn Rainbow(<<~WARNING).yellow, uplevel: 1
+          `Cop#corrections` is deprecated.
+        WARNING
+
         return [] unless @last_corrector
 
         Legacy::CorrectionsProxy.new(@last_corrector)
@@ -136,7 +162,7 @@ module RuboCop
       end
 
       def correction_lambda
-        return unless support_autocorrect?
+        return unless self.class.support_autocorrect?
 
         dedupe_on_node(@v0_argument) { autocorrect(@v0_argument) }
       end

data/lib/rubocop/cop/corrector.rb

@@ -46,7 +46,7 @@ module RuboCop
 
       # Removes `size` characters prior to the source range.
       #
-      # @param [Parser::Source::Range, RuboCop::AST::Node] range or node
+      # @param [Parser::Source::Range, RuboCop::AST::Node] node_or_range
       # @param [Integer] size
       def remove_preceding(node_or_range, size)
         range = to_range(node_or_range)
@@ -58,7 +58,7 @@ module RuboCop
       # If `size` is greater than the size of `range`, the removed region can
       # overrun the end of `range`.
       #
-      # @param [Parser::Source::Range, RuboCop::AST::Node] range or node
+      # @param [Parser::Source::Range, RuboCop::AST::Node] node_or_range
       # @param [Integer] size
       def remove_leading(node_or_range, size)
         range = to_range(node_or_range)
@@ -70,7 +70,7 @@ module RuboCop
       # If `size` is greater than the size of `range`, the removed region can
       # overrun the beginning of `range`.
       #
-      # @param [Parser::Source::Range, RuboCop::AST::Node] range or node
+      # @param [Parser::Source::Range, RuboCop::AST::Node] node_or_range
       # @param [Integer] size
       def remove_trailing(node_or_range, size)
         range = to_range(node_or_range)
@@ -103,7 +103,7 @@ module RuboCop
       # :nodoc:
       def to_range(node_or_range)
         range = case node_or_range
-                when ::RuboCop::AST::Node, ::Parser::Source::Comment
+                when RuboCop::AST::Node, ::Parser::Source::Comment
                   node_or_range.source_range
                 when ::Parser::Source::Range
                   node_or_range

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

@@ -12,27 +12,42 @@ module RuboCop
       class << self
         attr_reader :processed_source
 
-        def correct(corrector, processed_source, node, column_delta)
+        # `tab_indentation` may only be set by callers whose `column_delta` represents
+        # whole indentation levels (e.g. `Layout/IndentationWidth`).
+        # Alignment to an arbitrary column cannot be expressed with tabs, so those callers
+        # leave tab correction disabled to avoid producing a never-converging correction.
+        def correct(corrector, processed_source, node, column_delta, tab_indentation: false)
           return unless node
 
           @processed_source = processed_source
+
           expr = node.respond_to?(:loc) ? node.source_range : node
           return if block_comment_within?(expr)
 
           taboo_ranges = inside_string_ranges(node)
 
-          each_line(expr) do |line_begin_pos|
-            autocorrect_line(corrector, line_begin_pos, expr, column_delta, taboo_ranges)
+          if using_tabs?
+            return unless tab_indentation
+
+            correct_tab_indentation(corrector, expr, column_delta, taboo_ranges)
+          else
+            each_line(expr) do |line_begin_pos|
+              autocorrect_line(corrector, line_begin_pos, expr, column_delta, taboo_ranges)
+            end
           end
         end
 
         def align_end(corrector, processed_source, node, align_to)
           @processed_source = processed_source
           whitespace = whitespace_range(node)
-          return false unless whitespace.source.strip.empty?
-
           column = alignment_column(align_to)
-          corrector.replace(whitespace, ' ' * column)
+          indentation = indentation_string(column)
+
+          if whitespace.source.strip.empty?
+            corrector.replace(whitespace, indentation)
+          else
+            corrector.insert_after(whitespace, "\n#{indentation}")
+          end
         end
 
         private
@@ -47,14 +62,56 @@ module RuboCop
           if column_delta.positive? && range.resize(1).source != "\n"
             corrector.insert_before(range, ' ' * column_delta)
           elsif /\A[ \t]+\z/.match?(range.source)
-            remove(range, corrector)
+            corrector.remove(range)
           end
         end
 
+        # Tab indentation is corrected by rewriting each line's leading whitespace to
+        # the target number of tabs. Working in whole tabs rather than applying a column delta
+        # keeps the result idempotent, which avoids the infinite loops that delta-based correction
+        # caused for tabs.
+        def correct_tab_indentation(corrector, expr, column_delta, taboo_ranges)
+          buffer = expr.source_buffer
+
+          each_line(expr) do |line_begin_pos|
+            line_range = buffer.line_range(buffer.line_for_position(line_begin_pos))
+            correct_tab_line(corrector, line_range, column_delta, taboo_ranges)
+          end
+        end
+
+        def correct_tab_line(corrector, line_range, column_delta, taboo_ranges)
+          leading = line_range.source[/\A[ \t]*/]
+          return if leading.length == line_range.source.length # blank line
+
+          leading_range = range_between(line_range.begin_pos, line_range.begin_pos + leading.length)
+          return if taboo_ranges.any? { |t| within?(leading_range, t) }
+
+          target = target_tab_indentation(leading, column_delta)
+          corrector.replace(leading_range, target) unless leading == target
+        end
+
+        def target_tab_indentation(leading, column_delta)
+          width = configured_indentation_width
+          return leading unless width.positive?
+
+          visual_width = leading.chars.sum { |char| char == "\t" ? width : 1 }
+
+          "\t" * ([visual_width + column_delta, 0].max / width)
+        end
+
+        # The number of columns a single tab spans. This must match the width
+        # `Layout/IndentationWidth` uses to compute `column_delta`, otherwise
+        # the division below would not land on a tab boundary. `Layout/IndentationStyle`
+        # has its own `IndentationWidth`, but that only governs how that cop replaces tabs
+        # with spaces, so it must not be consulted here.
+        def configured_indentation_width
+          processed_source.config.for_cop('Layout/IndentationWidth')['Width'] || 2
+        end
+
         def inside_string_ranges(node)
           return [] unless node.is_a?(Parser::AST::Node)
 
-          node.each_node(:str, :dstr, :xstr).filter_map { |n| inside_string_range(n) }
+          node.each_node(:any_str).filter_map { |n| inside_string_range(n) }
         end
 
         def inside_string_range(node)
@@ -73,9 +130,7 @@ module RuboCop
         #   nil.
         # - The source map of `__FILE__` responds to neither :begin nor :end.
         def delimited_string_literal?(node)
-          loc = node.location
-
-          loc.respond_to?(:begin) && loc.begin && loc.respond_to?(:end) && loc.end
+          node.loc?(:begin) && node.loc?(:end)
         end
 
         def block_comment_within?(expr)
@@ -96,17 +151,6 @@ module RuboCop
           end
         end
 
-        def remove(range, corrector)
-          original_stderr = $stderr
-          $stderr = StringIO.new # Avoid error messages on console
-          corrector.remove(range)
-        rescue RuntimeError
-          range = range_between(range.begin_pos + 1, range.end_pos + 1)
-          retry if /^ +$/.match?(range.source)
-        ensure
-          $stderr = original_stderr
-        end
-
         def each_line(expr)
           line_begin_pos = expr.begin_pos
           expr.source.each_line do |line|
@@ -130,6 +174,20 @@ module RuboCop
             align_to.column
           end
         end
+
+        def indentation_string(column)
+          if using_tabs?
+            "\t" * column
+          else
+            ' ' * column
+          end
+        end
+
+        def using_tabs?
+          config = processed_source.config
+          indentation_style = config.for_cop('Layout/IndentationStyle')['EnforcedStyle']
+          indentation_style == 'tabs'
+        end
       end
     end
   end

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

@@ -16,7 +16,7 @@ module RuboCop
 
         def negated_condition(node)
           condition = node.condition
-          condition = condition.children.first while condition.begin_type?
+          condition = condition.children.last while condition.begin_type?
           condition
         end
       end

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

@@ -27,25 +27,21 @@ module RuboCop
         if block_node.arguments?
           format(CORRECTION_WITH_ARGUMENTS,
                  collection: collection_node.source,
-                 variables: argument_node.children.first.source)
+                 variables: argument_node.children.map(&:source).join(', '))
         else
           format(CORRECTION_WITHOUT_ARGUMENTS, enumerable: collection_node.source)
         end
       end
 
       def offending_range
+        begin_range = block_node.source_range.begin
+
         if block_node.arguments?
-          replacement_range(argument_node.source_range.end_pos)
+          begin_range.join(argument_node.source_range.end)
         else
-          replacement_range(block_node.loc.begin.end_pos)
+          begin_range.join(block_node.loc.begin.end)
         end
       end
-
-      def replacement_range(end_pos)
-        Parser::Source::Range.new(block_node.source_range.source_buffer,
-                                  block_node.source_range.begin_pos,
-                                  end_pos)
-      end
     end
   end
 end

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

@@ -6,7 +6,7 @@ module RuboCop
     class ForToEachCorrector
       extend NodePattern::Macros
 
-      CORRECTION = '%<collection>s.each do |%<argument>s|'
+      CORRECTION = '%<collection>s%<dot>seach do |%<argument>s|'
 
       def initialize(for_node)
         @for_node        = for_node
@@ -15,6 +15,8 @@ module RuboCop
       end
 
       def call(corrector)
+        offending_range = for_node.source_range.begin.join(end_range)
+
         corrector.replace(offending_range, correction)
       end
 
@@ -23,7 +25,12 @@ module RuboCop
       attr_reader :for_node, :variable_node, :collection_node
 
       def correction
-        format(CORRECTION, collection: collection_source, argument: variable_node.source)
+        format(
+          CORRECTION,
+          collection: collection_source,
+          dot: collection_node.csend_type? ? '&.' : '.',
+          argument: variable_node.source
+        )
       end
 
       def collection_source
@@ -37,14 +44,14 @@ module RuboCop
       def requires_parentheses?
         return true if collection_node.send_type? && collection_node.operator_method?
 
-        collection_node.range_type? || collection_node.or_type? || collection_node.and_type?
+        collection_node.range_type? || collection_node.operator_keyword?
       end
 
-      def end_position
+      def end_range
         if for_node.do?
-          keyword_begin.end_pos
+          keyword_begin.end
         else
-          collection_end.end_pos
+          collection_end.end
         end
       end
 
@@ -59,16 +66,6 @@ module RuboCop
           collection_node.source_range
         end
       end
-
-      def offending_range
-        replacement_range(end_position)
-      end
-
-      def replacement_range(end_pos)
-        Parser::Source::Range.new(for_node.source_range.source_buffer,
-                                  for_node.source_range.begin_pos,
-                                  end_pos)
-      end
     end
   end
 end

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

@@ -14,12 +14,15 @@ module RuboCop
         # Check for unparenthesized args' preceding and trailing whitespaces.
         remove_unparenthesized_whitespace(corrector)
 
-        # Avoid correcting to `lambdado` by inserting whitespace
-        # if none exists before or after the lambda arguments.
-        insert_separating_space(corrector)
+        if block_node.block_type?
+          # Avoid correcting to `lambdado` by inserting whitespace
+          # if none exists before or after the lambda arguments.
+          insert_separating_space(corrector)
+
+          remove_arguments(corrector)
+        end
 
         replace_selector(corrector)
-        remove_arguments(corrector)
 
         replace_delimiters(corrector)
 
@@ -83,7 +86,13 @@ module RuboCop
       end
 
       def lambda_arg_string
-        arguments.children.map(&:source).join(', ')
+        # Block-local (shadow) arguments are separated from regular arguments by a
+        # `;`; joining everything with `,` would turn them into extra parameters
+        # and change the lambda's arity.
+        regular, shadow = arguments.children.partition { |arg| !arg.shadowarg_type? }
+        arg_string = regular.map(&:source).join(', ')
+        arg_string += "; #{shadow.map(&:source).join(', ')}" unless shadow.empty?
+        arg_string
       end
 
       def needs_separating_space?

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

@@ -51,6 +51,8 @@ module RuboCop
         def semicolon(node)
           @semicolon ||= {}.compare_by_identity
           @semicolon[node] ||= processed_source.sorted_tokens.select(&:semicolon?).find do |token|
+            next if token.pos.end_pos <= node.source_range.begin_pos
+
             same_line?(token, node.body) && trailing_class_definition?(token, node.body)
           end
         end

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