rubocop 1.92.0 → 1.92.1

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

@@ -132,10 +132,11 @@ module RuboCop
       #     private alias_method :qux, :foo
       #
       #   end
-      class AccessModifierDeclarations < Base
+      class AccessModifierDeclarations < Base # rubocop:disable Metrics/ClassLength
         extend AutoCorrector
 
         include ConfigurableEnforcedStyle
+        include EndlessMethodBodyHelp
         include RangeHelp
 
         GROUP_STYLE_MESSAGE = [
@@ -169,6 +170,10 @@ module RuboCop
             (send nil? :alias_method _ _))
         PATTERN
 
+        def self.autocorrect_incompatible_with
+          [Style::EndlessMethod, Style::SingleLineMethods]
+        end
+
         def on_send(node)
           return if allowed?(node)
 
@@ -248,10 +253,33 @@ module RuboCop
 
             access_modifier_is_inlined?(node) && !right_siblings_same_inline_method?(node)
           else
-            access_modifier_is_not_inlined?(node) && select_grouped_def_nodes(node).any?
+            access_modifier_is_not_inlined?(node) && inlinable?(select_grouped_def_nodes(node))
           end
         end
 
+        def inlinable?(def_nodes)
+          return false if def_nodes.empty?
+
+          def_nodes.none? { |def_node| def_node.endless? && body_unsafe_to_inline?(def_node.body) }
+        end
+
+        def body_unsafe_to_inline?(body)
+          return true if body.each_node(:any_block).any? { |block| do_end_block?(block) }
+
+          target_ruby_version < 4.0 && command_body?(body)
+        end
+
+        def do_end_block?(block)
+          block.keywords? && !block.send_node.lambda_literal?
+        end
+
+        def command_body?(body)
+          body = body.body while body.rescue_type?
+          return true if body.send_type? && body.prefix_not? && !body.parenthesized?
+
+          command_call?(body)
+        end
+
         def correctable_group_offense?(node)
           return false unless group_style?
           return false if allowed?(node)

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

@@ -49,7 +49,7 @@ module RuboCop
         MSG = 'Use `%<prefer>s` instead of `%<current>s`.'
 
         def self.autocorrect_incompatible_with
-          [Style::MethodCallWithArgsParentheses, Style::ReturnNilInPredicateMethodDefinition]
+          [Style::MethodCallWithArgsParentheses, Style::ReturnNil, Style::ReturnNilInPredicateMethodDefinition]
         end
 
         def on_and(node)
@@ -73,7 +73,7 @@ module RuboCop
           message = message(node)
           add_offense(node.loc.operator, message: message) do |corrector|
             node.each_child_node do |expr|
-              if expr.send_type?
+              if expr.call_type?
                 correct_send(expr, corrector)
               elsif expr.type?(:return, :next, :break, :yield) || expr.assignment?
                 correct_other(expr, corrector)
@@ -120,7 +120,7 @@ module RuboCop
         # however, 'not x' also parses as (send x :!)
         def correct_not(node, receiver, corrector)
           if node.prefix_bang?
-            return unless receiver.send_type?
+            return unless receiver.call_type?
 
             correct_send(receiver, corrector)
           elsif node.prefix_not?

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

@@ -169,7 +169,7 @@ module RuboCop
 
           return if send_classifications.empty?
 
-          if only_forwards_all?(send_classifications)
+          if forward_all?(send_nodes, send_classifications)
             add_forward_all_offenses(node, send_classifications, forwardable_args)
           elsif target_ruby_version >= 3.2
             add_post_ruby_32_offenses(node, send_classifications, forwardable_args)
@@ -192,11 +192,33 @@ module RuboCop
           [restarg_node, kwrestarg_node, blockarg_node]
         end
 
+        def forward_all?(send_nodes, send_classifications)
+          only_forwards_all?(send_classifications) &&
+            !anonymous_forwarding_elsewhere?(send_nodes, send_classifications)
+        end
+
         def only_forwards_all?(send_classifications)
           all_classifications = %i[all all_anonymous].freeze
           send_classifications.all? { |_, c, _, _| all_classifications.include?(c) }
         end
 
+        def anonymous_forwarding_elsewhere?(send_nodes, send_classifications)
+          classified = send_classifications.map(&:first)
+
+          send_nodes.any? do |send_node|
+            classified.none? { |node| node.equal?(send_node) } &&
+              forwards_anonymous_args?(send_node)
+          end
+        end
+
+        def forwards_anonymous_args?(send_node)
+          send_node.arguments.any? do |arg|
+            next arg.children.any?(&:forwarded_kwrestarg_type?) if arg.hash_type?
+
+            arg.forwarded_restarg_type?
+          end
+        end
+
         # rubocop:disable-next Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity
         def add_forward_all_offenses(node, send_classifications, forwardable_args)
           rest_arg, kwrest_arg, block_arg = *forwardable_args
@@ -376,12 +398,16 @@ module RuboCop
 
         def add_parens_if_missing(node, corrector)
           return if parentheses?(node)
-          return if node.send_type? && node.method?(:[])
+          return if node.call_type? && operator_or_setter_call?(node)
           return unless (@parenthesized_nodes ||= Set.new.compare_by_identity).add?(node)
 
           add_parentheses(node, corrector)
         end
 
+        def operator_or_setter_call?(node)
+          node.setter_method? || (node.operator_method? && !node.loc.dot)
+        end
+
         # Classifies send nodes for possible rest/kwrest/all (including block) forwarding.
         class SendNodeClassifier
           extend NodePattern::Macros

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

@@ -306,6 +306,8 @@ module RuboCop
         end
 
         def move_comment_before_block(corrector, comment, block_node, closing_brace)
+          return if directive_comment?(comment)
+
           range = block_node.chained? ? end_of_chain(block_node.parent).source_range : closing_brace
 
           # It is possible that there is code between the block and the comment
@@ -319,6 +321,10 @@ module RuboCop
           corrector.insert_before(block_node, "#{comment.text}\n")
         end
 
+        def directive_comment?(comment)
+          comment.text.match?(DirectiveComment::DIRECTIVE_COMMENT_REGEXP)
+        end
+
         def source_range_before_comment(range, comment)
           range = range.end.join(comment.source_range.begin)
 

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

@@ -152,7 +152,9 @@ module RuboCop
           # making autocorrection ping-pong between the two forms.
           return if style_for_kind(node.body.type) == :nested
           return unless compactible_namespace?(node)
+          return if node.each_ancestor(:class, :module).any? { |ancestor| ignored_node?(ancestor) }
 
+          ignore_node(node)
           compact_node(corrector, node)
           remove_end(corrector, node.body)
           unindent(corrector, node)

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

@@ -75,7 +75,10 @@ module RuboCop
           return unless def_nodes(node).all? { |def_node| no_code_after?(def_node.source_range) }
 
           add_offense(node, message: MSG_SCLASS) do |corrector|
+            next if inside_corrected_sclass?(node)
+
             autocorrect_sclass(node, corrector)
+            ignore_node(node)
           end
         end
 
@@ -120,6 +123,10 @@ module RuboCop
           trailing.empty? || trailing.start_with?('#')
         end
 
+        def inside_corrected_sclass?(node)
+          node.each_ancestor(:sclass).any? { |ancestor| ignored_node?(ancestor) }
+        end
+
         def autocorrect_sclass(node, corrector)
           rewritten_defs = []
 

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

@@ -15,31 +15,24 @@ module RuboCop
       # would yield false positives. For example, `String` implements `length`
       # and `size`, but it doesn't include `Enumerable`.
       #
+      # When `count` is used without a block, it measures the collection's
+      # size, so the offense is corrected to `empty?` or `!empty?`. The
+      # predicate methods `any?`, `none?` and `one?` test element truthiness
+      # instead and would return different results for collections with falsey
+      # elements (e.g. `[false].count.zero?` is `false`, but `[false].none?`
+      # is `true`). For the same reason, `count == 1` and `count > 1` without
+      # a block are not flagged.
+      #
       # @safety
       #   The cop is unsafe because receiver might not include `Enumerable`, or
       #   it has nonstandard implementation of `count` or any replacement
       #   methods.
       #
-      #   It's also unsafe because for collections with falsey values, expressions
-      #   with `count` without a block return a different result than methods `any?`,
-      #   `none?` and `one?`:
-      #
-      #   [source,ruby]
-      #   ----
-      #   [nil, false].count.positive?
-      #   [nil].count == 1
-      #   # => true
-      #
-      #   [nil, false].any?
-      #   [nil].one?
-      #   # => false
-      #
-      #   [nil].count == 0
-      #   # => false
-      #
-      #   [nil].none?
-      #   # => true
-      #   ----
+      #   Blockless `count` is corrected to `empty?`, which `Enumerable` doesn't
+      #   define. `Range`, `Enumerator` (including lazy ones), `Struct`, `StringIO`
+      #   and any class that just includes `Enumerable` respond to `count` but not
+      #   to `empty?`, so `(1...1).count.zero?` is `true` while `(1...1).empty?`
+      #   raises `NoMethodError`.
       #
       #   Autocorrection is unsafe when replacement methods don't iterate over
       #   every element in collection and the given block runs side effects:
@@ -60,12 +53,14 @@ module RuboCop
       #   x.count > 0
       #   x.count != 0
       #
+      #   # good
+      #   !x.empty?
+      #
+      #   # bad
       #   x.count(&:foo?).positive?
       #   x.count { |item| item.foo? }.positive?
       #
       #   # good
-      #   x.any?
-      #
       #   x.any?(&:foo?)
       #   x.any? { |item| item.foo? }
       #
@@ -74,24 +69,33 @@ module RuboCop
       #   x.count == 0
       #
       #   # good
-      #   x.none?
+      #   x.empty?
       #
       #   # bad
-      #   x.count == 1
-      #   x.one?
+      #   x.count(&:foo?).zero?
+      #   x.count(&:foo?) == 0
+      #
+      #   # good
+      #   x.none?(&:foo?)
+      #
+      #   # bad
+      #   x.count(&:foo?) == 1
+      #
+      #   # good
+      #   x.one?(&:foo?)
       #
       # @example AllCops:ActiveSupportExtensionsEnabled: false (default)
       #
       #   # good
-      #   x.count > 1
+      #   x.count(&:foo?) > 1
       #
       # @example AllCops:ActiveSupportExtensionsEnabled: true
       #
       #   # bad
-      #   x.count > 1
+      #   x.count(&:foo?) > 1
       #
       #   # good
-      #   x.many?
+      #   x.many?(&:foo?)
       #
       class CollectionQuerying < Base
         include RangeHelp
@@ -102,13 +106,21 @@ module RuboCop
         RESTRICT_ON_SEND = %i[positive? > != zero? ==].freeze
 
         REPLACEMENTS = {
-          [:positive?, nil] => :any?,
-          [:>, 0] => :any?,
-          [:!=, 0] => :any?,
-          [:zero?, nil] => :none?,
-          [:==, 0] => :none?,
-          [:==, 1] => :one?,
-          [:>, 1] => :many?
+          [:positive?, nil] => 'any?',
+          [:>, 0] => 'any?',
+          [:!=, 0] => 'any?',
+          [:zero?, nil] => 'none?',
+          [:==, 0] => 'none?',
+          [:==, 1] => 'one?',
+          [:>, 1] => 'many?'
+        }.freeze
+
+        NO_BLOCK_REPLACEMENTS = {
+          [:positive?, nil] => '!empty?',
+          [:>, 0] => '!empty?',
+          [:!=, 0] => '!empty?',
+          [:zero?, nil] => 'empty?',
+          [:==, 0] => 'empty?'
         }.freeze
 
         # @!method count_predicate(node)
@@ -132,28 +144,49 @@ module RuboCop
         def on_send(node)
           return unless (count_node = count_predicate(node))
 
-          replacement_method = replacement_method(node)
+          replacement = replacement_method(node, count_node)
 
-          return unless replacement_supported?(replacement_method)
+          return unless replacement_supported?(node, replacement)
 
           offense_range = count_node.loc.selector.join(node.source_range.end)
-          add_offense(offense_range,
-                      message: format(MSG, prefer: replacement_method)) do |corrector|
-            corrector.replace(count_node.loc.selector, replacement_method)
-            corrector.remove(removal_range(node))
+          add_offense(offense_range, message: format(MSG, prefer: replacement)) do |corrector|
+            autocorrect(corrector, node, count_node, replacement)
           end
         end
 
         private
 
-        def replacement_method(node)
-          REPLACEMENTS.fetch([node.method_name, node.first_argument&.value])
+        def replacement_method(node, count_node)
+          key = [node.method_name, node.first_argument&.value]
+          return REPLACEMENTS.fetch(key) if block_given_to_count?(count_node)
+
+          NO_BLOCK_REPLACEMENTS[key]
+        end
+
+        def block_given_to_count?(count_node)
+          count_node.parent&.any_block_type? || count_node.last_argument&.block_pass_type?
+        end
+
+        def replacement_supported?(node, replacement)
+          return false unless replacement
+          return false if replacement == 'many?' && !active_support_extensions_enabled?
+
+          !(replacement.start_with?('!') && receiver_of_call?(node))
         end
 
-        def replacement_supported?(method_name)
-          return true if active_support_extensions_enabled?
+        def receiver_of_call?(node)
+          node.parent&.call_type? && node.parent.receiver == node && node.parent.loc.dot
+        end
+
+        def autocorrect(corrector, node, count_node, replacement)
+          if replacement.start_with?('!')
+            corrector.insert_before(count_node, '!')
+            corrector.replace(count_node.loc.selector, 'empty?')
+          else
+            corrector.replace(count_node.loc.selector, replacement)
+          end
 
-          method_name != :many?
+          corrector.remove(removal_range(node))
         end
 
         def removal_range(node)

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

@@ -65,6 +65,10 @@ module RuboCop
 
         MSG = 'Combine this loop with the previous loop.'
 
+        def self.autocorrect_incompatible_with
+          [Layout::BlockEndNewline, Layout::RedundantLineBreak]
+        end
+
         def on_block(node)
           return unless node.parent&.begin_type?
           return unless collection_looping_method?(node)

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

@@ -118,7 +118,8 @@ module RuboCop
           # A comment or a heredoc body there can't be moved out of the way.
           return unless closing_ranges.all? { |range| range.source.match?(/\A[\s,]*\]\z/) }
 
-          corrector.replace(node.loc.selector, 'push')
+          replace_selector(corrector, node)
+
           node.arguments.zip(closing_ranges) do |argument, closing_range|
             corrector.remove(argument.loc.begin)
             corrector.remove(closing_range)
@@ -133,6 +134,17 @@ module RuboCop
 
           range_between(argument.children.last.source_range.end_pos, argument.loc.end.end_pos)
         end
+
+        def replace_selector(corrector, node)
+          if node.parenthesized? || node.single_line?
+            corrector.replace(node.loc.selector, 'push')
+          else
+            range = node.loc.selector.join(node.first_argument.source_range.begin)
+
+            corrector.replace(range, 'push(')
+            corrector.insert_after(node.last_argument.loc.end, ')')
+          end
+        end
       end
     end
   end

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

@@ -45,6 +45,8 @@ module RuboCop
         MSG_TRAILING_CONDITIONAL = 'Do not use trailing conditionals in string interpolation.'
         MSG_TERNARY = 'Do not return empty strings in string interpolation.'
 
+        INTERPOLATED_TYPES = %i[dstr dsym regexp xstr].freeze
+
         def on_interpolation(node)
           node.each_child_node(:if) do |child_node|
             if style == :trailing_conditional
@@ -63,28 +65,54 @@ module RuboCop
           return if child_node.modifier_form?
 
           if empty_if_outcome?(child_node)
-            ternary_style_autocorrect(child_node, child_node.else_branch.source, 'unless')
+            ternary_style_autocorrect(child_node, child_node.else_branch, 'unless')
           end
 
           return unless empty_else_outcome?(child_node)
 
-          ternary_style_autocorrect(child_node, child_node.if_branch.source, 'if')
+          ternary_style_autocorrect(child_node, child_node.if_branch, 'if')
         end
 
         def ternary_correction(node, child_node)
           return unless child_node.modifier_form?
 
-          ternary_component = if child_node.unless?
-                                "'' : #{child_node.if_branch.source}"
-                              else
-                                "#{child_node.if_branch.source} : ''"
-                              end
-
           add_offense(node, message: MSG_TRAILING_CONDITIONAL) do |corrector|
-            corrector.replace(node, "\#{#{child_node.condition.source} ? #{ternary_component}}")
+            next if nested_trailing_conditional?(child_node)
+
+            autocorrect_to_ternary(corrector, child_node)
+          end
+        end
+
+        def nested_trailing_conditional?(if_node)
+          if_node.each_descendant(:if).any? do |node|
+            node.modifier_form? && node.parent.parent&.type?(*INTERPOLATED_TYPES)
           end
         end
 
+        def autocorrect_to_ternary(corrector, if_node)
+          condition = if_node.condition.source
+          branch = ternary_branch_source(if_node.if_branch)
+          outcomes = if_node.unless? ? "'' : #{branch}" : "#{branch} : ''"
+
+          corrector.replace(if_node, "#{condition} ? #{outcomes}")
+        end
+
+        def ternary_branch_source(branch)
+          return branch.source unless command_call?(branch)
+
+          arguments = branch.first_argument.source_range.join(branch.last_argument.source_range)
+          method = branch.source_range.begin.join(arguments.begin).source.rstrip
+
+          "#{method}(#{arguments.source})"
+        end
+
+        def command_call?(node)
+          return false unless node.type?(:call, :super, :yield) && node.arguments?
+          return false if node.call_type? && (node.operator_method? || node.setter_method?)
+
+          !node.parenthesized?
+        end
+
         def empty_if_outcome?(node)
           empty_branch_outcome?(node.if_branch)
         end
@@ -99,9 +127,23 @@ module RuboCop
           branch.nil_type? || (branch.str_type? && branch.value.empty?)
         end
 
-        def ternary_style_autocorrect(node, outcome, condition)
+        def ternary_style_autocorrect(node, outcome, keyword)
           add_offense(node, message: MSG_TERNARY) do |corrector|
-            corrector.replace(node, "#{outcome} #{condition} #{node.condition.source}")
+            next if empty_string_conditional_in_condition?(node)
+
+            head = node.source_range.begin.join(outcome.source_range.begin)
+            tail = outcome.source_range.end.join(node.source_range.end)
+
+            corrector.remove(head)
+            corrector.replace(tail, " #{keyword} #{node.condition.source}")
+          end
+        end
+
+        def empty_string_conditional_in_condition?(if_node)
+          if_node.condition.each_descendant(:if).any? do |node|
+            next false if node.modifier_form? || !node.parent.parent&.type?(*INTERPOLATED_TYPES)
+
+            empty_if_outcome?(node) || empty_else_outcome?(node)
           end
         end
       end

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

@@ -147,8 +147,12 @@ module RuboCop
 
         # `Style/MethodDefParentheses` adds the same parentheses a parameter list needs in
         # an endless definition, so letting both correct in the same pass would double them.
+        # `Style/GuardClause` turns a single `if` body into several statements,
+        # which an endless definition cannot hold.
+        # `Style/RaiseArgs` would drop the parentheses of a `raise` that becomes
+        # the body in the same pass, which a method passed as an argument needs.
         def self.autocorrect_incompatible_with
-          [Style::MethodCallWithArgsParentheses, Style::MethodDefParentheses]
+          [Style::GuardClause, Style::MethodCallWithArgsParentheses, Style::MethodDefParentheses, Style::RaiseArgs]
         end
 
         def on_def(node)

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

@@ -56,8 +56,10 @@ module RuboCop
 
         # `Style/RedundantBegin` removes the `begin` of a block body in the same pass,
         # leaving a `rescue` or `ensure` clause directly in the `for` body.
+        # `Style/ItBlockParameter` replaces block parameter references in the body
+        # with `it` in the same pass, while they become `for` loop variables.
         def self.autocorrect_incompatible_with
-          [Style::RedundantBegin]
+          [Style::RedundantBegin, Style::ItBlockParameter]
         end
 
         def on_for(node)
@@ -78,6 +80,7 @@ module RuboCop
 
           if style == :for
             return unless node.receiver
+            return unless convertible_to_for?(node)
             return if rescue_or_ensure_body?(node) || do_end_block_in_collection?(node)
 
             add_offense(node, message: PREFER_FOR) do |corrector|
@@ -123,6 +126,16 @@ module RuboCop
           node.multiline? && node.method?(:each) && !node.send_node.arguments?
         end
 
+        def convertible_to_for?(node)
+          return false if node.type?(:numblock, :itblock)
+          return true unless node.arguments?
+
+          arguments = node.arguments
+          return false if arguments.children.one? && arguments.children.first.restarg_type?
+
+          arguments.each_descendant.all? { |arg| arg.type?(:arg, :restarg, :mlhs) }
+        end
+
         def rescue_or_ensure_body?(node)
           node.body&.type?(:rescue, :ensure)
         end

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

@@ -186,40 +186,37 @@ module RuboCop
             return if trivial?(node)
 
             example = "#{conditional_keyword} #{condition.source}; #{scope_exiting_keyword}; end"
-            replacement = <<~RUBY.chomp
-              #{conditional_keyword} #{condition.source}
-                #{scope_exiting_keyword}
-              end
-            RUBY
+            replacement = "#{conditional_keyword} #{condition.source}\n  #{scope_exiting_keyword}"
           end
 
           add_offense(node.loc.keyword, message: format(MSG, example: example)) do |corrector|
             next if node.else? && guard.nil?
 
-            autocorrect(corrector, node, condition, replacement || example, guard)
+            autocorrect(corrector, node, example, replacement, guard)
           end
         end
 
         # rubocop:disable-next Metrics/AbcSize
-        def autocorrect(corrector, node, condition, replacement, guard)
-          corrector.replace(node.loc.keyword.join(condition.source_range), replacement)
-
-          if_branch = node.if_branch
-          else_branch = node.else_branch
-
+        def autocorrect(corrector, node, example, multiline_replacement, guard)
+          range = node.loc.keyword.join(node.condition.source_range)
+          corrector.replace(range, multiline_replacement || example)
           corrector.replace(node.loc.begin, "\n") if node.then?
 
-          if (if_heredoc = find_heredoc_argument(if_branch))
-            autocorrect_heredoc_argument(corrector, node, if_heredoc, else_branch, guard)
-          elsif (else_heredoc = find_heredoc_argument(else_branch))
-            autocorrect_heredoc_argument(corrector, node, else_heredoc, if_branch, guard)
-          else
-            corrector.remove(node.loc.end)
-            return unless node.else?
+          branches = [node.if_branch, node.else_branch]
+          guard_branch, leave_branch = guard == :else ? branches.reverse : branches
 
-            corrector.remove(node.loc.else)
-            corrector.remove(range_of_branch_to_remove(node, guard))
+          heredoc = find_heredoc_argument(guard_branch)
+          close_multiline_guard_clause(corrector, range, heredoc, guard) if multiline_replacement
+
+          if heredoc
+            return autocorrect_heredoc_argument(corrector, node, heredoc, leave_branch, guard)
           end
+
+          corrector.remove(node.loc.end)
+          return unless node.else?
+
+          corrector.remove(node.loc.else)
+          corrector.remove(range_of_branch_to_remove(node, guard))
         end
 
         def heredoc?(argument)
@@ -241,6 +238,10 @@ module RuboCop
           find_heredoc_argument(node.receiver)
         end
 
+        def close_multiline_guard_clause(corrector, range, heredoc, guard)
+          corrector.insert_after(guard && heredoc ? heredoc.loc.heredoc_end : range, "\nend")
+        end
+
         def autocorrect_heredoc_argument(corrector, node, heredoc_node, leave_branch, guard)
           remove_whole_lines(corrector, node.loc.end)
           return unless node.else?

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

@@ -44,6 +44,10 @@ module RuboCop
         include ConfigurableEnforcedStyle
         extend AutoCorrector
 
+        def self.autocorrect_incompatible_with
+          [Style::TrailingCommaInArrayLiteral]
+        end
+
         def on_hash(node)
           return if node.children.first&.kwsplat_type?
           return unless (array = containing_array(node))