rubocop 1.90.0 → 1.92.0

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

@@ -181,11 +181,11 @@ module RuboCop
         def autocorrect_modifier(corrector, node)
           body = node.if_branch || node.else_branch
 
-          replacement =
-            "next #{node.inverse_keyword} #{node.condition.source}\n" \
-            "#{' ' * node.source_range.column}#{body.source}"
+          next_code = "next #{node.inverse_keyword} #{node.condition.source}\n" \
+                      "#{' ' * node.source_range.column}"
 
-          corrector.replace(node, replacement)
+          corrector.insert_before(node, next_code)
+          corrector.remove(range_between(body.source_range.end_pos, node.source_range.end_pos))
         end
 
         def autocorrect_block(corrector, node)
@@ -231,7 +231,7 @@ module RuboCop
 
           # end_range starts with the final newline of the if body
           lines = (node.source_range.line + 1)...node.loc.end.line
-          lines = lines.to_a - heredoc_lines(node)
+          lines = lines.to_a - string_content_lines(node)
           # Skip blank lines
           lines.reject { |lineno| /\A\s*\z/.match?(buffer.source_line(lineno)) }
         end
@@ -250,11 +250,25 @@ module RuboCop
           lines.map { |lineno| buffer.source_line(lineno) =~ /\S/ }.min
         end
 
-        def heredoc_lines(node)
-          node.each_node(:dstr)
-              .select(&:heredoc?)
-              .map { |n| n.loc.heredoc_body }
-              .flat_map { |b| (b.line...b.last_line).to_a }
+        # Lines that start inside a string literal or a heredoc body, whose
+        # leading whitespace is part of the string value.
+        def string_content_lines(node)
+          buffer = node.source_range.source_buffer
+          ranges = node.each_node(:any_str).filter_map { |str| string_content_range(str) }
+
+          ranges.flat_map do |range|
+            (range.line..range.last_line).select do |lineno|
+              (range.begin_pos...range.end_pos).cover?(buffer.line_range(lineno).begin_pos)
+            end
+          end
+        end
+
+        def string_content_range(node)
+          if node.heredoc?
+            node.loc.heredoc_body
+          elsif node.loc?(:begin) && node.loc?(:end)
+            node.loc.begin.end.join(node.loc.end.begin)
+          end
         end
 
         def reindent_line(corrector, lineno, delta, buffer)

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

@@ -42,28 +42,68 @@ module RuboCop
         # @!method nil_check?(node)
         def_node_matcher :nil_check?, '(send _ :nil?)'
 
-        # rubocop:disable-next Metrics/AbcSize
         def on_send(node)
           return unless node.receiver
+          return if prefer_comparison? && comment_before_dot?(node)
 
           style_check?(node) do
             add_offense(node.loc.selector) do |corrector|
               if prefer_comparison?
-                range = node.loc.dot.join(node.loc.selector.end)
-                corrector.replace(range, ' == nil')
+                autocorrect_to_comparison(corrector, node)
               else
-                range = node.receiver.source_range.end.join(node.source_range.end)
-                corrector.replace(range, '.nil?')
+                autocorrect_to_predicate(corrector, node)
               end
-
-              parent = node.parent
-              corrector.wrap(node, '(', ')') if parent.respond_to?(:method?) && parent.method?(:!)
             end
           end
         end
 
         private
 
+        def comment_before_dot?(node)
+          return false unless node.loc.dot
+
+          processed_source.contains_comment?(node.receiver.source_range.end.join(node.loc.dot))
+        end
+
+        def autocorrect_to_comparison(corrector, node)
+          range = node.receiver.source_range.end.join(node.loc.selector.end)
+          corrector.replace(range, ' == nil')
+
+          return if !operator_expression?(node.parent) && !receiver_of_parent?(node)
+
+          corrector.wrap(node, '(', ')')
+        end
+
+        def autocorrect_to_predicate(corrector, node)
+          receiver = node.receiver
+          if operator_expression?(receiver)
+            # A looser-binding receiver (e.g. `!x`, `a + b`) must be parenthesized
+            # so the appended `.nil?` applies to the whole expression.
+            corrector.replace(node, "(#{receiver.source}).nil?")
+          else
+            range = receiver.source_range.end.join(node.source_range.end)
+            corrector.replace(range, '.nil?')
+          end
+        end
+
+        def operator_expression?(node)
+          return false unless node
+
+          operator_send?(node) ||
+            node.operator_keyword? ||
+            (node.if_type? && node.ternary?) ||
+            node.type?(:range, :iflipflop, :eflipflop) ||
+            node.assignment?
+        end
+
+        def receiver_of_parent?(node)
+          node.parent&.call_type? && node.parent.receiver.equal?(node)
+        end
+
+        def operator_send?(node)
+          node.send_type? && node.operator_method? && !node.method?(:[]) && !node.method?(:[]=)
+        end
+
         def message(_node)
           prefer_comparison? ? EXPLICIT_MSG : PREDICATE_MSG
         end

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

@@ -48,7 +48,7 @@ module RuboCop
           { ({return next break} nil) (nil) }
         PATTERN
 
-        def on_block(node) # rubocop:disable InternalAffairs/NumblockHandler, InternalAffairs/ItblockHandler
+        def on_block(node) # rubocop:disable InternalAffairs/NumblockHandler, InternalAffairs/ItblockHandler -- a lambda whose body is `nil` uses no parameters
           return unless node.lambda_or_proc?
           return unless nil_return?(node.body)
           # `return` inside a non-lambda proc returns from the enclosing method,

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

@@ -109,7 +109,7 @@ module RuboCop
 
         def message(node)
           if node.method?(:!=) && !include_semantic_changes?
-            prefer = "!#{node.receiver.source}.nil?"
+            prefer = non_nil_check_replacement(node)
             format(MSG_FOR_REPLACEMENT, prefer: prefer, current: node.source)
           else
             MSG_FOR_REDUNDANCY
@@ -120,11 +120,27 @@ module RuboCop
           cop_config['IncludeSemanticChanges']
         end
 
+        # An operator-expression receiver (e.g. `a + b`) binds looser than the
+        # appended `.nil?`, so it must be parenthesized: `!(a + b).nil?`.
+        def non_nil_check_replacement(node)
+          receiver = node.receiver
+          source = operator_expression?(receiver) ? "(#{receiver.source})" : receiver.source
+          "!#{source}.nil?"
+        end
+
+        def operator_expression?(node)
+          node.operator_keyword? ||
+            (node.send_type? && node.operator_method?) ||
+            (node.if_type? && node.ternary?) ||
+            node.type?(:range, :iflipflop, :eflipflop) ||
+            node.assignment?
+        end
+
         def autocorrect_comparison(corrector, node)
           if include_semantic_changes?
             corrector.replace(node, node.receiver.source)
           else
-            corrector.replace(node, "!#{node.receiver.source}.nil?")
+            corrector.replace(node, non_nil_check_replacement(node))
           end
         end
 

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

@@ -54,9 +54,10 @@ module RuboCop
         end
 
         def requires_parens?(child)
-          child.operator_keyword? ||
-            (child.send_type? && child.binary_operation?) ||
-            (child.if_type? && child.ternary?)
+          return true if child.operator_keyword? || operator_method_requiring_parens?(child)
+          return true if child.if_type? && child.ternary?
+
+          child.type?(:range, :iflipflop, :eflipflop) || child.assignment?
         end
 
         def correct_opposite_method(corrector, range, child)
@@ -72,6 +73,12 @@ module RuboCop
         def correct_without_parens(corrector, range)
           corrector.replace(range, '!')
         end
+
+        def operator_method_requiring_parens?(child)
+          return false unless child.send_type?
+
+          child.binary_operation? || (child.unary_operation? && child.method?(:~))
+        end
       end
     end
   end

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

@@ -55,7 +55,11 @@ module RuboCop
           return unless type
 
           add_offense(node) do |corrector|
-            corrector.replace(node, send(:"format_#{type}", node.source))
+            # The prefix patterns below are anchored, so correct only the digits
+            # and leave any sign the literal's source carries in place.
+            range = unsigned_range(node)
+
+            corrector.replace(range, send(:"format_#{type}", range.source))
           end
         end
 
@@ -71,6 +75,12 @@ module RuboCop
           octal_literal_type(literal) || hex_bin_dec_literal_type(literal)
         end
 
+        def unsigned_range(node)
+          range = node.source_range
+
+          node.source.start_with?('+', '-') ? range.adjust(begin_pos: 1) : range
+        end
+
         def octal_literal_type(literal)
           if OCTAL_ZERO_ONLY_REGEX.match?(literal) && octal_zero_only?
             :octal_zero_only

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

@@ -90,6 +90,7 @@ module RuboCop
         def on_send(node)
           numeric, replacement = check(node)
           return unless numeric
+          return if handled_by_bitwise_predicate?(node)
 
           return if allowed_method_name?(node.method_name) ||
                     node.each_ancestor(:send, :any_block).any? do |ancestor|
@@ -108,6 +109,12 @@ module RuboCop
           allowed_method?(name) || matches_allowed_pattern?(name)
         end
 
+        def handled_by_bitwise_predicate?(node)
+          bitwise_predicate_candidate?(node) &&
+            config.for_cop('Style/BitwisePredicate').fetch('Enabled') &&
+            BitwisePredicate.support_target_ruby_version?(target_ruby_version)
+        end
+
         def check(node)
           numeric, operator =
             if style == :predicate
@@ -124,7 +131,7 @@ module RuboCop
         def replacement(node, numeric, operation)
           if style == :predicate
             [parenthesized_source(numeric), REPLACEMENTS.invert[operation.to_s]].join('.')
-          elsif negated?(node)
+          elsif comparison_requires_parentheses?(node)
             "(#{numeric.source} #{REPLACEMENTS[operation.to_s]} 0)"
           else
             [numeric.source, REPLACEMENTS[operation.to_s], 0].join(' ')
@@ -140,7 +147,7 @@ module RuboCop
         end
 
         def require_parentheses?(node)
-          node.send_type? && node.binary_operation? && !node.parenthesized?
+          node.send_type? && node.operator_method? && !node.parenthesized?
         end
 
         def replacement_supported?(operator)
@@ -159,10 +166,11 @@ module RuboCop
           end
         end
 
-        def negated?(node)
-          return false unless (parent = node.parent)
+        def comparison_requires_parentheses?(node)
+          return false unless (parent = node.parent)&.call_type?
+          return true if parent.receiver.equal?(node)
 
-          parent.send_type? && parent.method?(:!)
+          parent.operator_method? && !parent.method?(:[]) && !parent.method?(:[]=)
         end
 
         # @!method predicate(node)
@@ -179,6 +187,14 @@ module RuboCop
         def_node_matcher :inverted_comparison, <<~PATTERN
           (send (int 0) ${:== :> :<} [$(...) !gvar_type?])
         PATTERN
+
+        # @!method bitwise_predicate_candidate?(node)
+        def_node_matcher :bitwise_predicate_candidate?, <<~PATTERN
+          {
+            (send {(begin (send _ :& _)) (send _ :& _)} {:positive? :zero?})
+            (send {(begin (send _ :& _)) (send _ :& _)} {:> :==} (int 0))
+          }
+        PATTERN
       end
     end
   end

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

@@ -102,6 +102,7 @@ module RuboCop
           return replaced_node unless node.parent
           return "(#{replaced_node})" if node.parent.operator_keyword?
           return "(#{replaced_node})" if node.parent.send_type? && node.parent.operator_method?
+          return "(#{replaced_node})" if parent_binds_tighter_than_ternary?(node)
 
           replaced_node
         end
@@ -117,13 +118,21 @@ module RuboCop
         end
 
         def ternary_replacement(node)
-          condition, if_branch, else_branch = *node # rubocop:disable InternalAffairs/NodeDestructuring
+          condition, if_branch, else_branch = *node # rubocop:disable InternalAffairs/NodeDestructuring -- takes all three branches in one step
 
           "#{expr_replacement(condition)} ? " \
             "#{expr_replacement(if_branch)} : " \
             "#{expr_replacement(else_branch)}"
         end
 
+        def parent_binds_tighter_than_ternary?(node)
+          parent = node.parent
+          return parent.receiver.equal?(node) if parent.call_type?
+          return parent.namespace.equal?(node) if parent.type?(:const, :casgn)
+
+          parent.if_type? && parent.ternary? && parent.condition.equal?(node)
+        end
+
         def expr_replacement(node)
           return 'nil' if node.nil?
 
@@ -131,7 +140,9 @@ module RuboCop
         end
 
         def requires_parentheses?(node)
-          return true if %i[and or if].include?(node.type)
+          return true if node.type?(
+            :and, :or, :if, :rescue, :while, :until, :while_post, :until_post, :any_match_pattern
+          )
           return true if node.assignment?
           return true if method_call_with_changed_precedence?(node)
 
@@ -139,7 +150,7 @@ module RuboCop
         end
 
         def method_call_with_changed_precedence?(node)
-          return false unless node.send_type? && node.arguments?
+          return false unless node.call_type? && node.arguments?
           return false if node.parenthesized_call?
 
           !node.operator_method?

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

@@ -184,7 +184,7 @@ module RuboCop
           def accesses?(rhs, lhs)
             if lhs.method?(:[]=)
               # FIXME: Workaround `rubocop:disable` comment for JRuby.
-              # rubocop:disable-next Performance/RedundantEqualityComparisonBlock
+              # rubocop:disable-next Performance/RedundantEqualityComparisonBlock -- a JRuby workaround, as the comment above says
               matching_calls(rhs, lhs.receiver, :[]).any? { |args| args == lhs.arguments }
             else
               access_method = lhs.method_name.to_s.chop.to_sym

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

@@ -123,10 +123,15 @@ module RuboCop
 
         def parens_allowed?(node)
           parens_required?(node) ||
-            (safe_assignment?(node) && safe_assignment_allowed?) ||
+            (safe_assignment?(node) && safe_assignment_kept?) ||
             (node.multiline? && allow_multiline_conditions?)
         end
 
+        def safe_assignment_kept?
+          safe_assignment_allowed? ||
+            config.for_enabled_cop('Lint/AssignmentInCondition')['AllowSafeAssignment']
+        end
+
         def allow_multiline_conditions?
           cop_config['AllowInMultilineConditions']
         end

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

@@ -86,10 +86,21 @@ module RuboCop
         end
 
         def include_same_character_as_used_for_delimiter?(node, type)
-          return false unless %w[%w %i].include?(type)
-
           used_delimiters = matchpairs(begin_source(node)[-1])
-          contains_delimiter?(node, used_delimiters)
+          return contains_delimiter?(node, used_delimiters) if %w[%w %i].include?(type)
+          return false unless %w[%q %s %r].include?(type)
+
+          contains_escaped_delimiter?(node, used_delimiters)
+        end
+
+        # Without interpolation an escaped delimiter means something different
+        # once the delimiters change (`%q!it\!s!` is `"it!s"`, but `%q(it\!s)`
+        # is `"it\\!s"`). For a regexp the match stays the same, but its source
+        # changes. Interpolating literals read `\!` as `!` with any delimiter.
+        def contains_escaped_delimiter?(node, delimiters)
+          body = node.loc.begin.end.join(node.loc.end.begin).source
+
+          body.scan(/\\./m).any? { |escape| delimiters.include?(escape[1]) }
         end
 
         def contains_delimiter?(node, delimiters)

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

@@ -183,7 +183,7 @@ module RuboCop
         end
 
         def adjusted_source(expr_node, block_node)
-          source = expr_node.source
+          source = element_source(expr_node)
           return source unless block_node.numblock_type?
           return source if block_node.method?(:each_with_object)
 
@@ -194,6 +194,22 @@ module RuboCop
         def indent(node)
           ' ' * node.source_range.column
         end
+
+        def element_source(expr_node)
+          if command_call?(expr_node) || expr_node.assignment? || expr_node.rescue_type?
+            return "(#{expr_node.source})"
+          end
+          return "[#{expr_node.source}]" if expr_node.array_type? && !expr_node.bracketed?
+
+          expr_node.source
+        end
+
+        def command_call?(node)
+          node = node.send_node if node.any_block_type?
+          return false unless node.type?(:call, :super, :yield)
+
+          node.arguments? && !node.parenthesized? && !node.operator_method? && !node.setter_method?
+        end
       end
     end
   end

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

@@ -139,7 +139,7 @@ module RuboCop
           offense_range = node.loc.begin
 
           add_offense(offense_range) do |corrector|
-            if node.parent&.assignment?
+            if node.parent&.assignment? || node.parent&.type?(:return, :next, :break)
               replace_begin_with_statement(corrector, offense_range, node)
             else
               remove_begin(corrector, offense_range, node)
@@ -156,7 +156,7 @@ module RuboCop
           first_child = node.children.first
 
           source = first_child.source
-          source = "(#{source})" if first_child.if_type? && first_child.modifier_form?
+          source = "(#{source})" if low_precedence_statement?(first_child)
 
           corrector.replace(offense_range, source)
           corrector.remove(range_between(offense_range.end_pos, first_child.source_range.end_pos))
@@ -164,6 +164,13 @@ module RuboCop
           restore_removed_comments(corrector, offense_range, node, first_child)
         end
 
+        def low_precedence_statement?(node)
+          return node.modifier_form? if node.basic_conditional?
+          return node.prefix_not? if node.send_type?
+
+          node.operator_keyword? && node.semantic_operator?
+        end
+
         def remove_begin(corrector, offense_range, node)
           if node.parent.respond_to?(:endless?) && node.parent.endless?
             offense_range = range_with_surrounding_space(offense_range, newlines: true)
@@ -222,7 +229,17 @@ module RuboCop
         end
 
         def valid_begin_assignment?(node)
-          node.parent&.assignment? && !node.children.one?
+          node.parent&.assignment? && (!node.children.one? || too_long_when_joined?(node))
+        end
+
+        def too_long_when_joined?(node)
+          statement = node.children.first
+          max = config.for_enabled_cop('Layout/LineLength')['Max']
+          return false unless max && statement.single_line?
+
+          length = statement.source.length
+          length += 2 if low_precedence_statement?(statement)
+          node.loc.column + length > max
         end
 
         def inspect_branches(node)

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

@@ -78,7 +78,10 @@ module RuboCop
         ].freeze
 
         def on_if(node)
-          return if node.modifier_form? || node.elsif_conditional? || !offense?(node)
+          return unless redundant_condition_offense?(node)
+          return if node.each_ancestor(:if).any? do |ancestor|
+            redundant_condition_offense?(ancestor)
+          end
 
           message = message(node)
 
@@ -89,6 +92,10 @@ module RuboCop
 
         private
 
+        def redundant_condition_offense?(node)
+          !node.modifier_form? && !node.elsif_conditional? && offense?(node)
+        end
+
         def message(node)
           if redundant_condition?(node)
             REDUNDANT_CONDITION
@@ -119,7 +126,7 @@ module RuboCop
         end
 
         def offense?(node)
-          _condition, _if_branch, else_branch = *node # rubocop:disable InternalAffairs/NodeDestructuring
+          _condition, _if_branch, else_branch = *node # rubocop:disable InternalAffairs/NodeDestructuring -- takes all three branches in one step
           return false if use_if_branch?(else_branch) || use_hash_key_assignment?(else_branch)
 
           synonymous_condition_and_branch?(node) && !node.elsif? &&
@@ -143,7 +150,7 @@ module RuboCop
         end
 
         def synonymous_condition_and_branch?(node)
-          condition, if_branch, _else_branch = *node # rubocop:disable InternalAffairs/NodeDestructuring
+          condition, if_branch, _else_branch = *node # rubocop:disable InternalAffairs/NodeDestructuring -- takes all three branches in one step
           # e.g.
           #   if var
           #     var
@@ -192,7 +199,7 @@ module RuboCop
         end
 
         def branches_have_assignment?(node)
-          _condition, if_branch, else_branch = *node # rubocop:disable InternalAffairs/NodeDestructuring
+          _condition, if_branch, else_branch = *node # rubocop:disable InternalAffairs/NodeDestructuring -- takes all three branches in one step
 
           return false unless if_branch && else_branch
 
@@ -240,10 +247,10 @@ module RuboCop
         end
 
         # rubocop:disable-next Metrics/AbcSize
-        def if_source(if_branch, arithmetic_operation)
+        def if_source(if_branch, binary_operator)
           if branches_have_method?(if_branch.parent) && if_branch.parenthesized?
             if_branch.source.delete_suffix(')')
-          elsif arithmetic_operation
+          elsif binary_operator
             argument_source = if_branch.first_argument.source
 
             "#{if_branch.receiver.source} #{if_branch.method_name} (#{argument_source}"
@@ -257,8 +264,8 @@ module RuboCop
           end
         end
 
-        def else_source(else_branch, arithmetic_operation) # rubocop:disable Metrics/AbcSize
-          if arithmetic_operation
+        def else_source(else_branch, binary_operator) # rubocop:disable Metrics/AbcSize
+          if binary_operator
             "#{else_branch.first_argument.source})"
           elsif branches_have_method?(else_branch.parent)
             else_source_if_has_method(else_branch)
@@ -294,12 +301,12 @@ module RuboCop
         end
 
         def make_ternary_form(node)
-          _condition, if_branch, else_branch = *node # rubocop:disable InternalAffairs/NodeDestructuring
-          arithmetic_operation = use_arithmetic_operation?(if_branch)
+          _condition, if_branch, else_branch = *node # rubocop:disable InternalAffairs/NodeDestructuring -- takes all three branches in one step
+          binary_operator = branches_have_method?(node) && binary_operator?(if_branch)
 
           ternary_form = [
-            if_source(if_branch, arithmetic_operation),
-            else_source(else_branch, arithmetic_operation)
+            if_source(if_branch, binary_operator),
+            else_source(else_branch, binary_operator)
           ].join(' || ')
           ternary_form += ')' if branches_have_method?(node) && if_branch.parenthesized?
 
@@ -320,17 +327,27 @@ module RuboCop
 
         def require_parentheses?(node)
           (node.basic_conditional? && node.modifier_form?) ||
-            node.range_type? ||
-            node.rescue_type? ||
-            (node.respond_to?(:semantic_operator?) && node.semantic_operator?)
+            node.range_type? || node.rescue_type? ||
+            (node.respond_to?(:semantic_operator?) && node.semantic_operator?) ||
+            low_precedence_keyword?(node)
+        end
+
+        # e.g. `not foo`, `return foo`, and `yield foo`
+        def low_precedence_keyword?(node)
+          return node.prefix_not? if node.send_type?
+
+          node.type?(:return, :next, :break, :yield, :super) &&
+            node.arguments? && !node.parenthesized?
         end
 
         def require_braces?(node)
           node.hash_type? && !node.braces?
         end
 
-        def use_arithmetic_operation?(node)
-          node.respond_to?(:arithmetic_operation?) && node.arithmetic_operation?
+        # Any binary operator binds tighter than `||`, so the fallback must be
+        # parenthesized as its argument, e.g. `stack << (foo || :new)`.
+        def binary_operator?(node)
+          node.binary_operation? && !node.dot?
         end
 
         def without_argument_parentheses_method?(node)

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

@@ -25,6 +25,12 @@ module RuboCop
         MSG = 'Remove the redundant double splat and braces, use keyword arguments directly.'
         MERGE_METHODS = %i[merge merge!].freeze
 
+        # `Style/TrailingCommaInHashLiteral` adds a comma to the hash literal whose braces
+        # this cop removes in the same pass, which would leave a dangling comma.
+        def self.autocorrect_incompatible_with
+          [Style::TrailingCommaInHashLiteral]
+        end
+
         # rubocop:disable-next Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
         def on_hash(node)
           return if node.pairs.empty? || node.pairs.any?(&:hash_rocket?)
@@ -108,7 +114,7 @@ module RuboCop
 
           node.arguments.map do |arg|
             if arg.hash_type?
-              arg.source
+              hash_argument_source(arg)
             else
               "**#{arg.source}"
             end
@@ -122,6 +128,15 @@ module RuboCop
 
           mergeable?(parent)
         end
+
+        # A braced hash literal passed to `merge` must have its braces stripped so
+        # its pairs join the surrounding keyword arguments. Keeping the braces would
+        # produce a positional hash after keyword arguments, which is invalid Ruby.
+        def hash_argument_source(hash)
+          return hash.source unless hash.braces?
+
+          hash.pairs.map(&:source).join(', ')
+        end
       end
     end
   end