rubocop 1.91.0 → 1.92.1

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

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

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

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

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

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

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

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

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

@@ -114,9 +114,31 @@ module RuboCop
           method_call, _lhs, method, _rhs = inverse_candidate?(node)
           return unless method_call && method
 
-          corrector.remove(not_to_receiver(node, method_call))
+          remove_negation(corrector, node, method, method_call)
           corrector.replace(method_call.loc.selector, inverse_methods[method].to_s)
-          remove_end_parenthesis(corrector, node, method, method_call)
+        end
+
+        def remove_negation(corrector, node, method, method_call)
+          if !keep_parentheses?(node, method_call)
+            corrector.remove(not_to_receiver(node, method_call))
+            remove_end_parenthesis(corrector, node, method, method_call)
+          elsif node.parenthesized?
+            corrector.remove(node.loc.selector)
+          else
+            corrector.remove(node.loc.selector.join(node.receiver.source_range.begin))
+          end
+        end
+
+        def keep_parentheses?(node, method_call)
+          return false unless node.receiver.begin_type? || node.parenthesized?
+          return false unless method_call.operator_method?
+          return false unless (parent = node.parent)&.call_type?
+
+          binary_operator?(parent) || parent.receiver.equal?(node)
+        end
+
+        def binary_operator?(node)
+          node.operator_method? && !node.loc.dot && !node.method?(:[]) && !node.method?(:[]=)
         end
 
         def correct_inverse_block(corrector, node)

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

@@ -59,8 +59,20 @@ module RuboCop
         MSG_AVOID_IT_PARAMETER = 'Avoid using `it` block parameter.'
         MSG_AVOID_IT_PARAMETER_MULTILINE = 'Avoid using `it` block parameter for multi-line blocks.'
 
+        SCOPE_TYPES = %i[any_def class module sclass].freeze
+
         minimum_target_ruby_version 3.4
 
+        # `Style/StabbyLambdaParentheses` wraps the parameter this cop removes in the same pass,
+        # which would leave an empty parameter list that forbids `it`.
+        def self.autocorrect_incompatible_with
+          [Style::Lambda, Style::StabbyLambdaParentheses]
+        end
+
+        def on_new_investigation
+          @it_variable_definitions = nil
+        end
+
         def on_block(node)
           return unless style == :always
           return unless node.arguments.one?
@@ -68,9 +80,10 @@ module RuboCop
           # `restarg`, `kwrestarg`, `blockarg` nodes can return early.
           return unless node.first_argument.arg_type?
 
-          variables = find_block_variables(node, node.first_argument.source)
+          block_argument_name = node.first_argument.source
+          return if keep_parameter_name?(node.body, block_argument_name)
 
-          variables.each do |variable|
+          find_block_variables(node, block_argument_name).each do |variable|
             add_offense(variable, message: MSG_USE_IT_PARAMETER) do |corrector|
               corrector.remove(node.arguments)
               corrector.replace(variable, 'it')
@@ -109,12 +122,89 @@ module RuboCop
         private
 
         def find_block_variables(node, block_argument_name)
-          return [] unless node.body
+          return [] if !node.body || it_variable_in_scope?(node)
+
+          ranges = inner_block_ranges(node.body)
+
+          block_variables(node.body, block_argument_name).reject do |variable|
+            ranges.any? { |range| range.contains?(variable.source_range) }
+          end
+        end
+
+        def it_variable_in_scope?(node)
+          scope = nearest_scope(node)
+          return true if it_argument_in_scope?(node, scope)
 
-          node.body.each_descendant(:lvar).select do |descendant|
+          it_variable_definitions.any? do |definition|
+            nearest_scope(definition).equal?(scope) && visible_in_block?(definition, node)
+          end
+        end
+
+        def it_variable_definitions
+          @it_variable_definitions ||=
+            variable_definitions(processed_source.ast).filter_map do |name, definition|
+              definition if name == 'it'
+            end
+        end
+
+        def nearest_scope(node)
+          node.each_ancestor(*SCOPE_TYPES).first
+        end
+
+        def it_argument_in_scope?(node, scope)
+          owners = node.each_ancestor(:block).select { |block| nearest_scope(block).equal?(scope) }
+          owners << scope if scope&.any_def_type?
+
+          owners.any? { |owner| owner.arguments.argument_list.any? { |arg| arg.name == :it } }
+        end
+
+        def visible_in_block?(definition, node)
+          return true if definition.source_range.begin_pos < node.source_range.begin_pos
+
+          node.source_range.contains?(definition.source_range)
+        end
+
+        def inner_block_ranges(body)
+          body.each_node(:any_block).map { |block| block.loc.begin.join(block.loc.end) }
+        end
+
+        def keep_parameter_name?(body, block_arg_name)
+          used_within_inner_block?(body, block_arg_name) || reassigned?(body, block_arg_name)
+        end
+
+        def used_within_inner_block?(body, block_argument_name)
+          return false unless body
+
+          ranges = inner_block_ranges(body)
+
+          block_variables(body, block_argument_name).any? do |variable|
+            ranges.any? { |range| range.contains?(variable.source_range) }
+          end
+        end
+
+        def reassigned?(body, block_argument_name)
+          return false unless body
+
+          variable_definitions(body).any? { |name, _definition| name == block_argument_name }
+        end
+
+        def block_variables(body, block_argument_name)
+          body.each_descendant(:lvar).select do |descendant|
             descendant.source == block_argument_name
           end
         end
+
+        def variable_definitions(node)
+          node.each_node(:lvasgn, :match_var, :match_with_lvasgn).flat_map do |definition|
+            names = if definition.match_with_lvasgn_type?
+                      definition.children.first.each_capture(named: true).map(&:name)
+                    else
+                      [definition.children.first.to_s]
+                    end
+
+            names.map { |name| [name, definition] }
+          end
+        end
       end
     end
   end

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

@@ -75,7 +75,9 @@ module RuboCop
 
         def remove_kwargs(kwarg_nodes, corrector)
           kwarg_nodes.each do |kwarg|
-            with_space = range_with_surrounding_space(kwarg.source_range)
+            range = range_with_surrounding_space(kwarg.source_range, side: :left, whitespace: true)
+            with_space = range_with_surrounding_space(range, side: :right)
+
             corrector.remove(range_with_surrounding_comma(with_space, :left))
           end
         end

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

@@ -48,6 +48,8 @@ module RuboCop
       #       end
       class Lambda < Base
         include ConfigurableEnforcedStyle
+        include PatternMatchingHelp
+        include RescueNode
         extend AutoCorrector
 
         LITERAL_MESSAGE = 'Use the `-> { ... }` lambda literal syntax for %<modifier>s lambdas.'
@@ -71,6 +73,7 @@ module RuboCop
           selector = node.send_node.source
 
           return unless offending_selector?(node, selector)
+          return if uncorrectable_lambda_literal?(node)
 
           add_offense(node.send_node, message: message(node, selector)) do |corrector|
             if node.send_node.lambda_literal?
@@ -91,6 +94,21 @@ module RuboCop
           selector == OFFENDING_SELECTORS[:style][style][lines]
         end
 
+        def uncorrectable_lambda_literal?(node)
+          return false unless node.send_node.lambda_literal?
+          return true if in_pattern?(node)
+          return false unless rescue_or_ensure_clause?(node.body)
+
+          LambdaLiteralToMethodCorrector.new(node).replace_delimiters?
+        end
+
+        def rescue_or_ensure_clause?(body)
+          return false unless body
+          return true if body.ensure_type?
+
+          body.rescue_type? && !rescue_modifier?(body.resbody_branches.first)
+        end
+
         def message(node, selector)
           message = selector == '->' ? METHOD_MESSAGE : LITERAL_MESSAGE
 
@@ -111,12 +129,27 @@ module RuboCop
 
           return unless node.arguments?
 
-          arg_str = "(#{lambda_arg_string(node.arguments)})"
+          arg_str = lambda_arg_string(node.arguments)
+          arg_str = " #{arg_str} " if space_inside_parens?
+          arg_str = "(#{arg_str})"
+          arg_str = " #{arg_str}" if space_in_lambda_literal_required?
 
           corrector.insert_after(node.send_node, arg_str)
           corrector.remove(arguments_with_whitespace(node))
         end
 
+        def space_inside_parens?
+          return false unless config.cop_enabled?('Layout/SpaceInsideParens')
+
+          %w[space compact].include?(config.for_cop('Layout/SpaceInsideParens')['EnforcedStyle'])
+        end
+
+        def space_in_lambda_literal_required?
+          return false unless config.cop_enabled?('Layout/SpaceInLambdaLiteral')
+
+          config.for_cop('Layout/SpaceInLambdaLiteral')['EnforcedStyle'] == 'require_space'
+        end
+
         def arguments_with_whitespace(node)
           node.loc.begin.end.join(node.arguments.loc.end)
         end

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

@@ -28,8 +28,9 @@ module RuboCop
         def on_send(node)
           return unless node.receiver
           # Rewriting the call rebuilds it as a single expression, which would drop
-          # any comments inside the argument list, so leave it to be fixed manually.
-          return if comments_in_node?(node)
+          # any comments or heredoc bodies inside the argument list, so leave it to be
+          # fixed manually.
+          return if comments_in_node?(node) || heredoc_argument?(node)
 
           if offense?(node)
             prefer = prefer(node)
@@ -59,6 +60,10 @@ module RuboCop
           end
         end
 
+        def heredoc_argument?(node)
+          node.arguments.any? { |argument| argument.each_node(:any_str).any?(&:heredoc?) }
+        end
+
         def offense?(node)
           (explicit_style? && node.implicit_call?) || (implicit_style? && !node.implicit_call?)
         end

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

@@ -112,8 +112,7 @@ module RuboCop
 
         def on_block(node)
           return unless each_block_with_push?(node)
-
-          dest_var = find_dest_var(node)
+          return unless (dest_var = find_dest_var(node))
 
           if offending_empty_array_tap?(node, dest_var)
             asgn = dest_var.declaration_node

data/lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb

@@ -30,7 +30,7 @@ module RuboCop
 
           private
 
-          def omit_parentheses(node) # rubocop:disable Metrics/PerceivedComplexity
+          def omit_parentheses(node) # rubocop:disable Metrics/AbcSize, Metrics/PerceivedComplexity
             return unless node.parenthesized?
             return if inside_endless_method_def?(node)
             return if require_parentheses_for_hash_value_omission?(node)
@@ -40,6 +40,9 @@ module RuboCop
             return if legitimate_call_with_parentheses?(node)
             return if allowed_camel_case_method_call?(node)
             return if allowed_string_interpolation_method_call?(node)
+            return if code_after_closing_parenthesis_on_its_own_line?(node)
+            return if comment_before_first_argument?(node)
+            return if args_parenthesized?(node)
 
             (@pending_omit_offenses ||= []) << node
           end
@@ -104,14 +107,33 @@ module RuboCop
               inside_string_interpolation?(node)
           end
 
+          def code_after_closing_parenthesis_on_its_own_line?(node)
+            closing = node.loc.end
+            return false if node.arguments.none? || node.last_argument.last_line == closing.line
+
+            rest = closing.source_line[(closing.column + 1)..].strip
+
+            !rest.empty? && !rest.start_with?('#')
+          end
+
+          # Without the parentheses, a comment before the first argument would end the call there,
+          # and a line continuation can't carry the call past a comment.
+          def comment_before_first_argument?(node)
+            return false unless (first_argument = node.first_argument)
+
+            lines = node.loc.begin.line...first_argument.first_line
+            processed_source.each_comment_in_lines(lines).any?
+          end
+
           def parentheses_at_the_end_of_multiline_call?(node)
-            node.multiline? &&
-              node.loc.begin.source_line
-                  .gsub(TRAILING_WHITESPACE_REGEX, '')
-                  .end_with?('(')
+            return false unless node.multiline?
+
+            opening = node.loc.begin
+
+            opening.source_line[(opening.column + 1)..].gsub(TRAILING_WHITESPACE_REGEX, '').empty?
           end
 
-          def legitimate_call_with_parentheses?(node) # rubocop:disable Metrics/PerceivedComplexity
+          def legitimate_call_with_parentheses?(node) # rubocop:disable Metrics/AbcSize, Metrics/PerceivedComplexity
             call_in_literals?(node) ||
               node.parent&.when_type? ||
               call_with_ambiguous_arguments?(node) ||
@@ -121,7 +143,9 @@ module RuboCop
               allowed_multiline_call_with_parentheses?(node) ||
               allowed_chained_call_with_parentheses?(node) ||
               assignment_in_condition?(node) ||
-              forwards_anonymous_rest_arguments?(node)
+              command_assignment_in_expression?(node) ||
+              forwards_anonymous_rest_arguments?(node) ||
+              trailing_comma?(node)
           end
 
           def call_in_literals?(node)
@@ -137,9 +161,13 @@ module RuboCop
             parent = node.parent&.any_block_type? ? node.parent.parent : node.parent
             return false unless parent
 
-            logical_operator?(parent) ||
-              (parent.send_type? &&
-              parent.arguments.any? { |argument| logical_operator?(argument) })
+            if logical_operator?(parent) || command_assignment_before_keyword_operator?(parent)
+              return true
+            end
+
+            parent.send_type? && parent.arguments.any? do |argument|
+              logical_operator?(argument)
+            end
           end
 
           def call_in_optional_arguments?(node)
@@ -229,6 +257,15 @@ module RuboCop
             node.operator_keyword? && node.logical_operator?
           end
 
+          def command_assignment_before_keyword_operator?(node)
+            return false unless node.assignment?
+
+            node = node.parent while node.parent&.assignment?
+            return false unless (operator = node.parent)
+
+            operator.operator_keyword? && operator.semantic_operator?
+          end
+
           def hash_literal?(node)
             node.hash_type? && node.braces?
           end
@@ -244,7 +281,7 @@ module RuboCop
           end
 
           def assigned_before?(node, target)
-            node.assignment? && node.loc.operator.begin < target.loc.begin
+            node.assignment? && node.loc.operator.begin < target.source_range.begin
           end
 
           def inside_string_interpolation?(node)
@@ -261,11 +298,41 @@ module RuboCop
             parent.assignment? && (grandparent.conditional? || grandparent.when_type?)
           end
 
+          # rubocop:disable-next Metrics/PerceivedComplexity
+          def command_assignment_in_expression?(node)
+            value = node.parent&.type?(:any_block, :rescue) ? node.parent : node
+            assignment = outermost_assignment(value)
+            return false if assignment.equal?(value)
+
+            call_in_literals?(assignment) ||
+              call_in_logical_operators?(assignment) ||
+              call_in_optional_arguments?(assignment) ||
+              call_as_argument_or_chain?(assignment) ||
+              assignment.parent&.type?(:masgn, :return, :next, :break, :defined?)
+          end
+
+          def outermost_assignment(value)
+            parent = value.parent
+            return value if !parent&.assignment? || parent.masgn_type?
+            return value unless assigned_before?(parent, value)
+
+            outermost_assignment(parent)
+          end
+
           def forwards_anonymous_rest_arguments?(node)
+            node.arguments.any? do |argument|
+              next true if argument.forwarded_restarg_type?
+
+              argument.hash_type? && argument.children.any?(&:forwarded_kwrestarg_type?)
+            end
+          end
+
+          def trailing_comma?(node)
             return false unless (last_argument = node.last_argument)
-            return true if last_argument.forwarded_restarg_type?
 
-            last_argument.hash_type? && last_argument.children.any?(&:forwarded_kwrestarg_type?)
+            range = last_argument.source_range.end.join(node.loc.end.begin)
+
+            processed_source.tokens_within(range).any?(&:comma?)
           end
         end
       end