rubocop 1.92.0 → 1.92.2

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

@@ -85,7 +85,7 @@ module RuboCop
         /xi.freeze
 
         def self.autocorrect_incompatible_with
-          [Style::MethodCallWithArgsParentheses]
+          [Style::MethodCallWithArgsParentheses, Style::MethodDefParentheses]
         end
 
         def on_block(node)
@@ -122,8 +122,10 @@ module RuboCop
         def on_new_investigation
           @breakable_range_by_line_index = {}
           @breakable_string_delimiters = {}
+          @breakable_strings = {}
           @endless_methods_by_line = {}
           @heredocs = nil
+          @heredoc_openers = nil
 
           return unless processed_source.raw_source.include?(';')
 
@@ -207,37 +209,69 @@ module RuboCop
         def check_for_breakable_node(node)
           breakable_node = extract_breakable_node(node, max)
           return if breakable_node.nil?
+          return if compact_nested_array_break?(node, breakable_node)
 
           line_index = breakable_node.first_line - 1
           range = breakable_node.source_range
 
           existing = breakable_range_by_line_index[line_index]
-          return if existing
+          return if existing || after_heredoc_opener?(range)
 
           breakable_range_by_line_index[line_index] = range
         end
 
+        def after_heredoc_opener?(range)
+          heredoc_openers.any? do |opener|
+            opener.line == range.line && opener.begin_pos < range.begin_pos
+          end
+        end
+
+        def heredoc_openers
+          ast = processed_source.ast
+          return [] if ast.nil?
+
+          @heredoc_openers ||= ast.each_node(:any_str).select(&:heredoc?).map(&:source_range)
+        end
+
+        def compact_nested_array_break?(node, breakable_node)
+          return false if !node.array_type? || !node.square_brackets?
+          return false unless breakable_node.equal?(node.children.first)
+          return false unless breakable_node.source.start_with?('[')
+
+          compact_array_brackets_enforced?
+        end
+
+        def compact_array_brackets_enforced?
+          return false unless config.cop_enabled?('Layout/SpaceInsideArrayLiteralBrackets')
+
+          config.for_cop('Layout/SpaceInsideArrayLiteralBrackets')['EnforcedStyle'] == 'compact'
+        end
+
         def check_for_breakable_semicolons(processed_source)
           tokens = processed_source.tokens.select { |t| t.type == :tSEMI }
           tokens.reverse_each do |token|
             range = breakable_range_after_semicolon(token)
-            breakable_range_by_line_index[range.line - 1] = range if range
+            next if range.nil? || after_heredoc_opener?(range)
+
+            breakable_range_by_line_index[range.line - 1] = range
           end
         end
 
         def check_for_breakable_block(block_node)
           return unless block_node.single_line?
-          return if receiver_contains_heredoc?(block_node)
 
           line_index = block_node.loc.line - 1
           return if breakable_string_delimiters[line_index]
 
           range = breakable_block_range(block_node)
           pos = range.begin_pos + 1
+          range = range_between(pos, pos + 1)
+          return if after_heredoc_opener?(range)
 
-          breakable_range_by_line_index[line_index] = range_between(pos, pos + 1)
+          breakable_range_by_line_index[line_index] = range
         end
 
+        # rubocop:disable-next Metrics/AbcSize
         def check_for_breakable_str(node)
           line_index = node.loc.line - 1
           return if breakable_range_by_line_index[line_index]
@@ -248,6 +282,7 @@ module RuboCop
 
           breakable_range_by_line_index[line_index] = range_between(pos, pos + 1)
           breakable_string_delimiters[line_index] = delimiter
+          breakable_strings[line_index] = node
         end
 
         def check_for_breakable_dstr(node) # rubocop:disable Metrics/AbcSize
@@ -271,7 +306,8 @@ module RuboCop
             !node.heredoc? &&
             # TODO: strings inside hashes, kwargs and arrays are currently ignored,
             # but could be considered in the future
-            !node.parent&.type?(:pair, :kwoptarg, :array)
+            !node.parent&.type?(:pair, :kwoptarg, :array) &&
+            !after_heredoc_opener?(node.source_range)
         end
 
         def breakable_block_range(block_node)
@@ -301,7 +337,32 @@ module RuboCop
           return unless (pos = breakable_string_range(node))
 
           content_begin_pos = node.loc?(:begin) ? node.loc.begin.end_pos : source_range.begin_pos
-          pos.end_pos if pos.end_pos > content_begin_pos
+          if blank_left_part?(node, content_begin_pos, pos)
+            pos = breakable_string_range_at_limit(source_range)
+          end
+          pos.end_pos if pos && leaves_two_parts?(node, content_begin_pos, pos)
+        end
+
+        def leaves_two_parts?(node, content_begin_pos, pos)
+          pos.end_pos > content_begin_pos && !blank_rest?(node, pos.end_pos)
+        end
+
+        def blank_left_part?(node, content_begin_pos, pos)
+          return false unless pos.end_pos > content_begin_pos
+          return false unless starts_after_quote?(node)
+
+          blank_between?(content_begin_pos, pos.end_pos)
+        end
+
+        def starts_after_quote?(node)
+          return true if node.loc?(:begin)
+
+          quote = node.parent&.loc&.begin if node.parent&.dstr_type?
+          quote ? quote.end_pos == node.source_range.begin_pos : false
+        end
+
+        def blank_between?(begin_pos, end_pos)
+          range_between(begin_pos, end_pos).source.strip.empty?
         end
 
         # Locate where to break a string that is too long, ensuring that escape characters
@@ -325,11 +386,17 @@ module RuboCop
 
         def breakable_space_position(node, substr)
           limit = string_content_length(node) - 1
-          space_pos = substr.rindex(/\s/)
-          space_pos = substr[0, limit].rindex(/\s/) if space_pos && space_pos + 1 > limit
+          space_pos = space_before_word(node, substr.length - 1)
+          space_pos = space_before_word(node, limit - 1) if space_pos && space_pos + 1 > limit
           space_pos
         end
 
+        def space_before_word(node, max_pos)
+          return if max_pos.negative?
+
+          node.source.rindex(/\s(?=\S)/, max_pos)
+        end
+
         def escape_sequence_start(text)
           text.match(ESCAPE_SEQUENCE_TAIL)&.begin(1)
         end
@@ -339,10 +406,25 @@ module RuboCop
           return if adjustment.abs > source_range.size
 
           cut = source_range.adjust(end_pos: adjustment)
+          cut = cut.resize(size_before_whitespace_run(source_range.source, cut.size))
           escape_pos = escape_sequence_start(cut.source)
+
           escape_pos ? source_range.resize(escape_pos) : cut
         end
 
+        def size_before_whitespace_run(text, size)
+          return size if size.zero?
+          return size unless text[size]&.match?(/\s/)
+
+          text.rindex(/\S/, size - 1) || size
+        end
+
+        def blank_rest?(node, break_pos)
+          offset = break_pos - node.source_range.begin_pos
+
+          node.source[offset...string_content_length(node)].strip.empty?
+        end
+
         def string_content_length(node)
           content_end = node.loc?(:end) ? node.loc.end.begin_pos : node.source_range.end_pos
 
@@ -360,7 +442,9 @@ module RuboCop
         def opens_string?(begin_node)
           quote = begin_node.parent.loc.begin
 
-          quote && quote.end_pos == begin_node.source_range.begin_pos
+          return false unless quote
+
+          blank_between?(quote.end_pos, begin_node.source_range.begin_pos)
         end
 
         def breakable_range_by_line_index
@@ -375,6 +459,10 @@ module RuboCop
           @breakable_string_delimiters ||= {}
         end
 
+        def breakable_strings
+          @breakable_strings ||= {}
+        end
+
         def heredocs
           @heredocs ||= extract_heredocs(processed_source.ast)
         end
@@ -431,8 +519,36 @@ module RuboCop
                           "\n"
                         end
 
-            corrector.insert_before(breakable_range, insertion) unless breakable_range.nil?
+            break_ranges(line_index).each do |range|
+              corrector.insert_before(range, insertion)
+            end
+          end
+        end
+
+        def break_ranges(line_index)
+          return [] if breakable_range.nil?
+          return [breakable_range] unless (node = breakable_strings[line_index])&.loc?(:end)
+
+          string_break_ranges(node, breakable_string_delimiters[line_index])
+        end
+
+        def string_break_ranges(node, delimiter)
+          ranges = [breakable_range]
+          pos = breakable_range.begin_pos
+
+          while (pos = next_string_break_position(node, pos, delimiter))
+            ranges << range_between(pos, pos + 1)
           end
+
+          ranges
+        end
+
+        def next_string_break_position(node, pos, delimiter)
+          rest = parse("#{delimiter}#{node.source_range.with(begin_pos: pos).source}").ast
+          return unless rest&.str_type?
+          return unless (rest_pos = breakable_string_position(rest))
+
+          pos + rest_pos - delimiter.length
         end
 
         def excess_range(uri_range, line, line_index)

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

@@ -106,11 +106,13 @@ module RuboCop
         ALWAYS_SAME_LINE_MESSAGE = 'Closing hash brace must be on the same ' \
                                    'line as the last hash element.'
 
-        # Moving the closing brace while `Style/HashAsLastArrayItem` or
-        # `Style/RedundantDoubleSplatHashBraces` removes the braces in the same pass leaves
-        # the brace behind.
+        # Moving the closing brace after a method call value while
+        # `Layout/MultilineMethodCallBraceLayout` moves that call's closing parenthesis
+        # before a comment in the same pass places the brace after the comment.
+        # Moving it while `Style/HashAsLastArrayItem` or `Style/RedundantDoubleSplatHashBraces`
+        # removes the braces in the same pass leaves the brace behind.
         def self.autocorrect_incompatible_with
-          [Style::HashAsLastArrayItem, Style::RedundantDoubleSplatHashBraces]
+          [Layout::MultilineMethodCallBraceLayout, Style::HashAsLastArrayItem, Style::RedundantDoubleSplatHashBraces]
         end
 
         def on_hash(node)

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

@@ -102,7 +102,7 @@ module RuboCop
         def autocorrect(corrector, node)
           if @send_node.block_node
             correct_selector_only(corrector, node)
-            correct_block(corrector, @send_node.block_node)
+            correct_block(corrector, @send_node.block_node, node.first_line)
           else
             AlignmentCorrector.correct(corrector, processed_source, node, @column_delta)
           end
@@ -114,10 +114,21 @@ module RuboCop
           AlignmentCorrector.correct(corrector, processed_source, selector_range, @column_delta)
         end
 
-        def correct_block(corrector, block_node)
-          AlignmentCorrector.correct(corrector, processed_source, block_node.body, @column_delta)
-          end_range = range_by_whole_lines(block_node.loc.end, include_final_newline: false)
-          AlignmentCorrector.correct(corrector, processed_source, end_range, @column_delta)
+        def correct_block(corrector, block_node, selector_line)
+          lines_to_shift = block_lines(block_node) - [selector_line]
+
+          lines_to_shift.each do |line|
+            line_range = processed_source.buffer.line_range(line)
+
+            AlignmentCorrector.correct(corrector, processed_source, line_range, @column_delta)
+          end
+        end
+
+        def block_lines(block_node)
+          body = block_node.body
+          lines = body ? (body.first_line..body.last_line).to_a : []
+
+          (lines << block_node.loc.end.line).uniq
         end
 
         def relevant_node?(send_node)

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

@@ -115,7 +115,7 @@ module RuboCop
               node.loc.name
             when :sclass
               node.identifier.source_range
-            when :masgn
+            when :masgn, :op_asgn, :or_asgn, :and_asgn
               node.lhs.source_range
             else
               # It is a wrapper with receiver of object attribute or access modifier.

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

@@ -25,10 +25,10 @@ module RuboCop
 
         MSG = 'Put method call on a separate line if chained to a single line block.'
 
-        # `Style/FloatDivision` and `Style/NilComparison` rewrite a method chained to the block
-        # in the same pass, which must not start a line of its own.
+        # These cops rewrite a method chained to the block in the same pass,
+        # which must not start a line of its own.
         def self.autocorrect_incompatible_with
-          [Style::FloatDivision, Style::MapToHash, Style::NilComparison]
+          [Style::FloatDivision, Style::MapToHash, Style::MapToSet, Style::NilComparison, Style::RedundantSort]
         end
 
         def on_send(node)

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

@@ -245,20 +245,30 @@ module RuboCop
             return if with_space.is?(operator.source)
 
             "Space around operator `#{operator.source}` detected."
-          elsif !/^\s.*\s$/.match?(with_space.source)
+          elsif missing_surrounding_space?(with_space)
             "Surrounding space missing for operator `#{operator.source}`."
-          elsif excess_leading_space?(type, operator, with_space) ||
+          elsif excess_leading_space?(type, operator, with_space, right_operand) ||
                 excess_trailing_space?(right_operand.source_range, with_space)
             "Operator `#{operator.source}` should be surrounded " \
               'by a single space.'
           end
         end
 
-        def excess_leading_space?(type, operator, with_space)
+        def missing_surrounding_space?(with_space)
+          return false if /\A\s.*\s\z/m.match?(with_space.source)
+
+          !with_space.source.start_with?(/\s/) || !line_continuation_after?(with_space)
+        end
+
+        def line_continuation_after?(range)
+          processed_source.buffer.source[range.end_pos, 2] == "\\\n"
+        end
+
+        def excess_leading_space?(type, operator, with_space, right_operand)
           return false unless allow_for_alignment?
           return false unless with_space.source.start_with?(EXCESSIVE_SPACE)
 
-          return !aligned_with_operator?(operator) unless grouped_alignment_type?(type)
+          return !aligned?(type, operator, right_operand) unless grouped_alignment_type?(type)
 
           token            = Token.new(operator, nil, operator.source)
           align_preceding  = aligned_with_preceding_equals_operator(token)
@@ -269,6 +279,23 @@ module RuboCop
           aligned_with_subsequent_equals_operator(token) != :yes
         end
 
+        def aligned?(type, operator, right_operand)
+          return true if aligned_with_operator?(operator)
+
+          type == :pair && aligned_with_another_hash_rocket?(right_operand)
+        end
+
+        def aligned_with_another_hash_rocket?(pair)
+          hash_rocket_columns(pair.parent)[pair.loc.operator.column] > 1
+        end
+
+        def hash_rocket_columns(hash_node)
+          @hash_rocket_columns ||= {}.compare_by_identity
+          @hash_rocket_columns[hash_node] ||= hash_node.pairs.select(&:hash_rocket?).map do |pair|
+            pair.loc.operator.column
+          end.tally
+        end
+
         def grouped_alignment_type?(type)
           type == :assignment || (type == :special_asgn && force_equal_sign_alignment?)
         end

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

@@ -136,11 +136,23 @@ module RuboCop
 
         def autocorrect(corrector, range)
           case range.source
+          when /\n/ then remove_line_continuation(corrector, range)
           when /\s/ then corrector.remove(range)
           else           corrector.insert_before(range, ' ')
           end
         end
 
+        # When a heredoc body sits between the `\` and the brace, the newline before
+        # the brace ends the heredoc, and removing it would break the terminator.
+        def remove_line_continuation(corrector, range)
+          source = processed_source.buffer.source
+          return unless source[range.begin_pos - 1] == '\\'
+
+          begin_pos = range.begin_pos
+          begin_pos -= 1 while source[begin_pos - 1].match?(/[ \t\\]/)
+          corrector.remove(range_between(begin_pos, range.end_pos))
+        end
+
         def style_for_empty_braces
           case cop_config['EnforcedStyleForEmptyBraces']
           when 'space'    then :space

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

@@ -83,7 +83,7 @@ module RuboCop
         extend AutoCorrector
 
         def self.autocorrect_incompatible_with
-          [Style::BlockDelimiters]
+          [Layout::BlockAlignment, Style::BlockDelimiters]
         end
 
         def on_block(node)

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

@@ -18,6 +18,7 @@ module RuboCop
       #   # good
       #   'a'..'z'
       class SpaceInsideRangeLiteral < Base
+        include RangeHelp
         extend AutoCorrector
 
         MSG = 'Space inside range literal.'
@@ -33,21 +34,38 @@ module RuboCop
         private
 
         def check(node)
-          expression = node.source
-          op = node.loc.operator.source
-          escaped_op = op.gsub('.', '\.')
-
-          # account for multiline range literals
-          expression.sub!(/#{escaped_op}\n\s*/, op)
-
-          return unless /(\s#{escaped_op})|(#{escaped_op}\s)/.match?(expression)
+          operator = node.loc.operator
+          spaces = [space_before(node, operator), space_after(node, operator)].compact
+          return if spaces.all? { |space| line_break_after_operator?(space, operator) }
 
           add_offense(node) do |corrector|
-            corrector.replace(
-              node, expression.sub(/\s+#{escaped_op}/, op).sub(/#{escaped_op}\s+/, op)
-            )
+            spaces.each do |space|
+              corrector.remove(space)
+            end
           end
         end
+
+        def space_before(node, operator)
+          return unless node.begin
+
+          whitespace_range(node.begin.source_range.end_pos, operator.begin_pos)
+        end
+
+        def space_after(node, operator)
+          return unless node.end
+
+          whitespace_range(operator.end_pos, node.end.source_range.begin_pos)
+        end
+
+        def line_break_after_operator?(space, operator)
+          space.begin_pos == operator.end_pos && space.source.start_with?("\n")
+        end
+
+        def whitespace_range(begin_pos, end_pos)
+          range = range_between(begin_pos, end_pos)
+
+          range if range.source.match?(/\A\s+\z/)
+        end
       end
     end
   end

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

@@ -108,14 +108,9 @@ module RuboCop
         end
 
         def left_ref_bracket(node, tokens)
-          current_token = tokens.reverse.find(&:left_ref_bracket?)
-          previous_token = previous_token(current_token)
+          bracket_pos = node.loc.selector.begin_pos
 
-          if node.method?(:[]=) || (previous_token && !previous_token.right_bracket?)
-            tokens.find(&:left_ref_bracket?)
-          else
-            current_token
-          end
+          tokens.find { |token| token.left_ref_bracket? && token.begin_pos == bracket_pos }
         end
 
         def closing_bracket(tokens, opening_bracket)
@@ -129,11 +124,6 @@ module RuboCop
           end
         end
 
-        def previous_token(current_token)
-          index = processed_source.tokens.index(current_token)
-          index.nil? || index.zero? ? nil : processed_source.tokens[index - 1]
-        end
-
         def empty_config
           cop_config['EnforcedStyleForEmptyBrackets']
         end

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

@@ -55,7 +55,8 @@ module RuboCop
           return node if first_argument_is_regexp?(node) || !node.parent
 
           if (node.parent.send_type? && node.receiver) ||
-             method_chain_to_regexp_receiver?(node, regexp_receiver)
+             method_chain_to_regexp_receiver?(node, regexp_receiver) ||
+             part_of_hash_argument?(node)
             node = find_offense_node(node.parent, regexp_receiver)
           end
 
@@ -72,6 +73,10 @@ module RuboCop
 
           parent.parent && parent_receiver.receiver == regexp_receiver
         end
+
+        def part_of_hash_argument?(node)
+          node.pair_type? || node.parent.pair_type? || (node.hash_type? && !node.braces?)
+        end
       end
     end
   end

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

@@ -34,6 +34,10 @@ module RuboCop
 
         MSG = 'Put a method call with a HEREDOC receiver on the same line as the HEREDOC opening.'
 
+        def self.autocorrect_incompatible_with
+          [Style::MethodCallWithArgsParentheses]
+        end
+
         def on_send(node)
           heredoc = heredoc_node_descendent_receiver(node)
           return unless heredoc

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

@@ -41,26 +41,22 @@ module RuboCop
 
         private
 
-        # rubocop:disable-next Metrics/CyclomaticComplexity
         def check(node)
           return if node.parent&.regexp_type?
           return unless /(?<!\\)#\{.*\}/.match?(node.source)
           return if heredoc?(node)
-          return unless node.loc.begin && node.loc.end
+          return unless single_quoted?(node)
           return unless valid_syntax?(node)
 
           add_offense(node) { |corrector| autocorrect(corrector, node) }
         end
 
-        def autocorrect(corrector, node)
-          starting_token, ending_token = if node.source.include?('"')
-                                           ['%{', '}']
-                                         else
-                                           ['"', '"']
-                                         end
+        def single_quoted?(node)
+          node.loc.begin&.is?("'") && node.loc.end
+        end
 
-          corrector.replace(node.loc.begin, starting_token)
-          corrector.replace(node.loc.end, ending_token)
+        def autocorrect(corrector, node)
+          corrector.replace(node, interpolated_source(node))
         end
 
         def heredoc?(node)
@@ -68,15 +64,22 @@ module RuboCop
         end
 
         def valid_syntax?(node)
-          double_quoted_string = if node.source.include?('"')
-                                   node.source.sub(/\A'/, '%{').sub(/'\z/, '}')
-                                 else
-                                   node.source.gsub(/\A'|'\z/, '"')
-                                 end
-
-          processed_source = parse(double_quoted_string)
+          processed_source = parse(interpolated_source(node))
           processed_source.valid_syntax? && processed_source.ast.dstr_type?
         end
+
+        def interpolated_source(node)
+          content = node.source[1...-1]
+          return %("#{content}") unless content.include?('"')
+          return "%{#{content}}" unless continued_string_part?(node)
+
+          %("#{content.gsub(/\\.|"/) { |m| m == '"' ? '\"' : m }}")
+        end
+
+        # A percent literal right after another string part is parsed as the `%` operator.
+        def continued_string_part?(node)
+          node.parent&.dstr_type? && node.left_sibling
+        end
       end
     end
   end

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

@@ -40,6 +40,7 @@ module RuboCop
         # NestedPercentLiteral violation to be emitted.
         PERCENT_LITERAL_TYPES = PreferredDelimiters::PERCENT_LITERAL_TYPES
         REGEXES = PERCENT_LITERAL_TYPES.map { |percent_literal| /\A#{percent_literal}\W/ }.freeze
+        FORMAT_SEQUENCE = /\A#{RuboCop::Cop::Utils::FormatString::SEQUENCE}\z/.freeze
 
         def on_array(node)
           process(node, *PERCENT_LITERAL_TYPES)
@@ -54,6 +55,8 @@ module RuboCop
         def contains_percent_literals?(node)
           node.each_child_node.any? do |child|
             literal = child.children.first.to_s.scrub
+            next false if literal.match?(FORMAT_SEQUENCE)
+
             REGEXES.any? { |regex| literal.match?(regex) }
           end
         end

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

@@ -140,6 +140,8 @@ module RuboCop
               corrected_method: correct_sym_method(to_method)
             )
             add_offense(node, message: message) do |corrector|
+              next if part_of_ignored_node?(node)
+
               remove_parentheses(corrector, node) if node.parenthesized?
 
               corrector.replace(sym_node, correct_sym_method(to_method))

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

@@ -57,7 +57,7 @@ module RuboCop
           node = node.children.first while node&.begin_type? && node.children.one?
           return false unless node
 
-          keyword_operator?(node) || modifier_expression?(node)
+          keyword_operator?(node) || modifier_expression?(node) || command_call_operand?(node)
         end
 
         def keyword_operator?(node)
@@ -69,6 +69,27 @@ module RuboCop
           node.type?(:if, :while, :until) && node.modifier_form?
         end
 
+        def command_call_operand?(node)
+          if node.assignment? || (node.call_type? && node.assignment_method?)
+            command_call_value?(node.children.last)
+          elsif node.send_type? && node.prefix_bang?
+            command_call_value?(node.receiver)
+          else
+            false
+          end
+        end
+
+        def command_call_value?(node)
+          command_call?(node) || command_call_operand?(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?
+        end
+
         def chained_calls?(node)
           first_argument = node.first_argument
           first_argument.call_type? && (node.children.last&.children&.count || 0) > 1