rubocop 1.91.0 → 1.92.2

data/lib/rubocop/cop/lint/useless_assignment.rb

@@ -212,16 +212,23 @@ module RuboCop
         end
 
         def remove_local_variable_assignment_part(corrector, node)
-          corrector.remove(node.loc.name.begin.join(node.expression.source_range.begin))
-        end
-
-        def variable_in_loop_condition?(assignment_node, variable)
-          return false if assignment_node.each_ancestor(:any_def).any?
+          expression = node.expression
+          assignment_part = node.loc.name.begin.join(expression.source_range.begin)
 
-          loop_node = assignment_node.each_ancestor.find do |ancestor|
-            ancestor.type?(*VariableForce::LOOP_TYPES)
+          # `x = 1, 2` cannot become `1, 2`, so the values become an array literal.
+          if expression.array_type? && !expression.bracketed?
+            corrector.replace(assignment_part, '[')
+            corrector.insert_after(expression, ']')
+          else
+            corrector.remove(assignment_part)
           end
+        end
 
+        def variable_in_loop_condition?(assignment_node, variable)
+          # A method defined inside the loop has its own scope, so the loop condition
+          # can only read the variable if the loop is nearer than any method definition.
+          loop_node = assignment_node.each_ancestor(*VariableForce::LOOP_TYPES, :any_def).first
+          return false if !loop_node || loop_node.any_def_type?
           return false unless loop_node.respond_to?(:condition)
 
           condition_node = loop_node.condition

data/lib/rubocop/cop/lint/useless_setter_call.rb

@@ -35,15 +35,13 @@ module RuboCop
         ASSIGNMENT_TYPES = %i[lvasgn ivasgn cvasgn gvasgn].freeze
 
         def on_def(node)
-          return unless node.body
+          return if !node.body || node.void_context?
 
           last_expr = last_expression(node.body)
           return unless setter_call_to_local_variable?(last_expr)
 
-          tracker = MethodVariableTracker.new(node.body)
           receiver, = *last_expr
-          variable_name, = *receiver
-          return unless tracker.contain_local_object?(variable_name)
+          return unless contain_local_object?(node.body, receiver)
 
           loc_name = receiver.loc.name
 
@@ -66,6 +64,11 @@ module RuboCop
           expression.is_a?(Array) ? expression.last : expression
         end
 
+        def contain_local_object?(body, receiver)
+          variable_name, = *receiver
+          MethodVariableTracker.new(body).contain_local_object?(variable_name)
+        end
+
         # This class tracks variable assignments in a method body
         # and if a variable contains object passed as argument at the end of
         # the method.

data/lib/rubocop/cop/lint/void.rb

@@ -271,7 +271,14 @@ module RuboCop
           return if node.parent.type?(:if, :case, :when, :case_match, :in_pattern)
           return if (def_node = node.each_ancestor(:any_def).first) && def_node.assignment_method?
 
-          corrector.remove(range_with_surrounding_space(range: node.source_range, side: :left))
+          range = range_with_surrounding_space(range: void_expression_range(node), side: :left)
+          corrector.remove(range)
+        end
+
+        def void_expression_range(node)
+          return node.source_range unless node.respond_to?(:heredoc?) && node.heredoc?
+
+          node.source_range.join(node.loc.heredoc_end)
         end
 
         def autocorrect_nonmutating_send(corrector, node, suggestion)

data/lib/rubocop/cop/metrics/class_length.rb

@@ -40,6 +40,8 @@ module RuboCop
       class ClassLength < Base
         include CodeLength
 
+        LABEL = 'Class'
+
         def on_class(node)
           check_code_length(node)
         end
@@ -60,8 +62,8 @@ module RuboCop
 
         private
 
-        def message(length, max_length)
-          format('Class has too many lines. [%<length>d/%<max>d]', length: length, max: max_length)
+        def cop_label
+          LABEL
         end
 
         def find_expression_within_parent(parent)

data/lib/rubocop/cop/metrics/cyclomatic_complexity.rb

@@ -48,10 +48,6 @@ module RuboCop
 
           1
         end
-
-        def count_block?(block)
-          KNOWN_ITERATING_METHODS.include? block.method_name
-        end
       end
     end
   end

data/lib/rubocop/cop/metrics/module_length.rb

@@ -38,6 +38,8 @@ module RuboCop
       class ModuleLength < Base
         include CodeLength
 
+        LABEL = 'Module'
+
         def on_module(node)
           check_code_length(node)
         end
@@ -53,8 +55,8 @@ module RuboCop
           (casgn nil? _ (any_block (send (const {nil? cbase} :Module) :new) ...))
         PATTERN
 
-        def message(length, max_length)
-          format('Module has too many lines. [%<length>d/%<max>d]', length: length, max: max_length)
+        def cop_label
+          LABEL
         end
       end
     end

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

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

@@ -76,11 +76,7 @@ module RuboCop
       def extract_first_element_over_column_limit(node, elements, max)
         line = node.first_line
 
-        # If a `send` or `csend` node is not parenthesized, don't move the first element, because it
-        # can result in changed behavior or a syntax error.
-        if node.call_type? && !node.parenthesized? && !first_argument_is_heredoc?(node)
-          elements = elements.drop(1)
-        end
+        elements = elements.drop(1) unless first_element_movable?(node)
 
         i = 0
         i += 1 while within_column_limit?(elements[i], max, line)
@@ -93,23 +89,35 @@ module RuboCop
       end
 
       # @api private
-      def first_argument_is_heredoc?(node)
-        first_argument = node.first_argument
+      # If a method call or definition is not parenthesized, the first element cannot be moved,
+      # because it can result in changed behavior or a syntax error.
+      def first_element_movable?(node)
+        return !node.arguments.loc.begin.nil? if node.any_def_type?
+        return true if !node.call_type? || node.parenthesized?
 
-        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 +136,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 +151,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

@@ -5,6 +5,8 @@ module RuboCop
     # Checks for code on multiple lines that could be rewritten on a single line
     # without changing semantics or exceeding the `Max` parameter of `Layout/LineLength`.
     module CheckSingleLineSuitability
+      include LineLengthHelp
+
       def suitable_as_single_line?(node)
         !too_long?(node) &&
           !comment_within?(node) &&
@@ -14,10 +16,14 @@ 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]
-        to_single_line(lines.join("\n")).length > max_line_length
+        lines = processed_source.lines[(line_range.begin - 1)...line_range.end]
+        line_length(to_single_line(lines.join("\n"))) > max_line_length
       end
 
       def to_single_line(source)

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/comments_help.rb

@@ -66,7 +66,7 @@ module RuboCop
       # the line at which the parent node ends.
       # rubocop:disable-next Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity
       def find_end_line(node)
-        if node.if_type?
+        if node.if_type? && !node.modifier_form?
           if node.else?
             node.loc.else.line
           elsif node.ternary?

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,105 @@
+# 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))
+        return true if body_disallowed_in_argument?(body)
+        return true if negated_command_call?(body)
+
+        body.each_node(:any_block).any? do |block|
+          block.keywords? && command_call?(block.send_node)
+        end
+      end
+
+      def body_disallowed_in_argument?(body)
+        command_body_in_argument?(body) || do_end_block_body_in_command_argument?(body)
+      end
+
+      # `private def foo = bar baz` parses only on Ruby 4.0+, and only as the sole argument.
+      def command_body_in_argument?(body)
+        return false unless command_call?(body)
+
+        call = argument_receiving_call(body.parent)
+        return false if call.nil?
+
+        target_ruby_version < 4.0 || !call.arguments.one?
+      end
+
+      def argument_receiving_call(def_node)
+        call = def_node.parent
+        return unless call&.call_type?
+
+        call if call.arguments.any? { |argument| argument.equal?(def_node) }
+      end
+
+      def do_end_block_body_in_command_argument?(body)
+        call = argument_receiving_call(body.parent)
+        return false if call.nil? || call.parenthesized?
+
+        body.each_node(:any_block).any? do |block|
+          block.keywords? && !block.send_node.lambda_literal?
+        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
+
+      def negated_command_call?(node)
+        node.send_type? && node.prefix_bang? && command_call?(node.receiver)
+      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,13 +55,21 @@ module RuboCop
       # Common functionality for checking alignment of hash values.
       module ValueAlignment
         def checkable_layout?(node)
-          !node.pairs_on_same_line? && !node.mixed_delimiters? && alignable_values?(node)
+          !node.pairs_on_same_line? && !node.mixed_delimiters? && alignable_values?(node) &&
+            !pair_after_kwsplat_on_same_line?(node)
         end
 
+        # With several enforced styles, deltas are computed even for a hash this style
+        # can't check. A pair that doesn't begin its line can't be moved without
+        # deleting whatever precedes it, so it's left alone.
         def deltas(first_pair, current_pair)
+          return {} unless current_pair.equal?(first_pair) ||
+                           Util.begins_its_line?(current_pair.source_range)
+
           key_delta = key_delta(first_pair, current_pair)
-          separator_delta = separator_delta(first_pair, current_pair, key_delta)
-          value_delta = value_delta(first_pair, current_pair) - key_delta - separator_delta
+          shift = separator_shift(current_pair, key_delta)
+          separator_delta = separator_delta(first_pair, current_pair, shift)
+          value_delta = value_delta(first_pair, current_pair) - shift - separator_delta
 
           { key: key_delta, separator: separator_delta, value: value_delta }
         end
@@ -78,9 +86,22 @@ module RuboCop
           pair.value && pair.key.last_line != pair.value.first_line
         end
 
-        def separator_delta(first_pair, current_pair, key_delta)
+        def pair_after_kwsplat_on_same_line?(node)
+          first_pair = node.pairs.first
+
+          node.children.each_cons(2).any? do |previous, current|
+            current.pair_type? && !current.equal?(first_pair) &&
+              previous.last_line == current.first_line
+          end
+        end
+
+        def separator_shift(current_pair, key_delta)
+          current_pair.key.multiline? ? 0 : key_delta
+        end
+
+        def separator_delta(first_pair, current_pair, shift)
           if current_pair.hash_rocket?
-            hash_rocket_delta(first_pair, current_pair) - key_delta
+            hash_rocket_delta(first_pair, current_pair) - shift
           else
             0
           end
@@ -152,6 +173,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)
@@ -163,7 +195,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}"
@@ -97,7 +106,16 @@ module RuboCop
       end
 
       def hash_rockets_enforced?(hash_node)
-        style == :hash_rockets || force_hash_rockets?(hash_node.pairs)
+        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
@@ -210,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)
@@ -233,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/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