evilution 1.1.0 → 1.3.0

data/lib/evilution/mutator/operator/argument_propagation.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+require_relative "../operator"
+
+# Replace a call with its only argument: `normalize(value)` becomes `value`.
+#
+# A survivor means the method's transformation of its input is never
+# observed — the tests would pass if the value went through untouched.
+# Distinct from method_call_removal, which keeps the receiver instead.
+#
+# Only identifier-named methods with a single positional argument qualify.
+# Operator methods (`a + b`, `a[i]`) are left to binary operand promotion,
+# attribute writes to attribute_write_to_read, and a call in void statement
+# position to statement_deletion, since there the promoted argument's value
+# is discarded anyway.
+class Evilution::Mutator::Operator::ArgumentPropagation < Evilution::Mutator::Base
+  NON_POSITIONAL = [
+    Prism::SplatNode,
+    Prism::KeywordHashNode,
+    Prism::BlockArgumentNode,
+    Prism::ForwardingArgumentsNode
+  ].freeze
+  private_constant :NON_POSITIONAL
+
+  IDENTIFIER = /\A[[:alpha:]_]/
+  private_constant :IDENTIFIER
+
+  def call(subject, **)
+    @void_statements = Set.new
+    super
+  end
+
+  def visit_statements_node(node)
+    @void_statements.merge(node.body[...-1])
+    super
+  end
+
+  def visit_call_node(node)
+    promote_child(node, sole_positional_argument(node)) if propagatable?(node)
+    super
+  end
+
+  private
+
+  def sole_positional_argument(node)
+    return unless node.arguments in Prism::ArgumentsNode[arguments: [argument]]
+
+    argument unless NON_POSITIONAL.any? { |type| argument.is_a?(type) }
+  end
+
+  def propagatable?(node)
+    node.name.match?(IDENTIFIER) && !node.attribute_write? && !@void_statements.include?(node)
+  end
+end

data/lib/evilution/mutator/operator/array_coercion_to_literal.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require_relative "../operator"
+
+# Replace an `Array()` coercion with an array literal: `Array(value)` becomes
+# `[value]`, and the same for `Kernel.Array(value)` / `Kernel::Array(value)`.
+#
+# The two agree only on a plain scalar. `Array(nil)` is `[]` where `[nil]`
+# is not, an array or hash is converted rather than wrapped, and anything
+# responding to `to_ary` / `to_a` is unpacked. A survivor means no test
+# passes nil or a collection through the coercion.
+class Evilution::Mutator::Operator::ArrayCoercionToLiteral < Evilution::Mutator::Base
+  def visit_call_node(node)
+    rewrite(node) if node.name == :Array && kernel_receiver?(node.receiver) && node.block.nil?
+    super
+  end
+
+  private
+
+  def rewrite(node)
+    return unless node.arguments in Prism::ArgumentsNode[arguments: [argument]]
+    return if argument.is_a?(Prism::SplatNode)
+
+    replace_span(node: node, target: node, replacement: "[#{source_of(argument)}]")
+  end
+
+  def kernel_receiver?(receiver)
+    case receiver
+    when nil then true
+    when Prism::ConstantReadNode then receiver.name == :Kernel
+    when Prism::ConstantPathNode then receiver.parent.nil? && receiver.name == :Kernel
+    end
+  end
+end

data/lib/evilution/mutator/operator/attribute_write_to_read.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require_relative "../operator"
+
+# Replace an attribute or index write with the matching read: `a.foo = b`
+# becomes `a.foo`, `a[i] = b` becomes `a[i]`.
+#
+# A survivor means nothing observes the write. Only positions
+# statement_deletion does not reach are mutated: a write that is one of
+# several statements in a body is already deleted there, and turning it into
+# a read differs from that only by the reader call.
+class Evilution::Mutator::Operator::AttributeWriteToRead < Evilution::Mutator::Base
+  def call(subject, **)
+    @deletable_statements = Set.new
+    super
+  end
+
+  def visit_statements_node(node)
+    @deletable_statements.merge(node.body) if node.body.length > 1
+    super
+  end
+
+  def visit_call_node(node)
+    mutate_to_read(node) if node.attribute_write? && !@deletable_statements.include?(node)
+    super
+  end
+
+  private
+
+  def mutate_to_read(node)
+    read_length = node.message_loc.end_offset - node.start_offset
+    replace_span(node: node, target: node, replacement: byteslice_source(node.start_offset, read_length))
+  end
+end

data/lib/evilution/mutator/operator/bang_method.rb

@@ -3,10 +3,18 @@
 require_relative "../operator"
 
 class Evilution::Mutator::Operator::BangMethod < Evilution::Mutator::Base
+  # Methods that have an in-place bang twin on at least one of String, Array,
+  # Hash or Set (the same set on every supported Ruby, 3.3+), plus `update` /
+  # `save` for ActiveRecord. String's `succ` / `next` are left out: those
+  # names are far more often called on Integer, which has no bang twin.
   KNOWN_BANG_PAIRS = %i[
-    sort map collect select reject uniq compact flatten
-    shuffle reverse slice gsub sub strip chomp chop squeeze
-    delete encode merge update save
+    sort sort_by map collect select filter reject uniq compact flatten
+    shuffle reverse rotate slice
+    gsub sub tr tr_s strip lstrip rstrip chomp chop squeeze delete
+    delete_prefix delete_suffix capitalize downcase upcase swapcase
+    scrub encode unicode_normalize
+    merge transform_keys transform_values
+    update save
   ].to_set.freeze
 
   def visit_call_node(node)

data/lib/evilution/mutator/operator/binary_operand_promotion.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+require_relative "../operator"
+
+# Replace an arithmetic or bitwise expression with one of its operands:
+# `a + b` becomes `a` and `b`.
+#
+# A survivor means one operand never affects the tested result. Comparisons
+# are left to the comparison and conditional operators.
+#
+# An operand is not promoted when the other side is the operator's integer
+# identity — `a + 0` or `a * 1` already equals `a`. A float literal does not
+# count (`a + 0.0` turns an Integer into a Float), and neither do shifts,
+# since `<<` also appends. A binary send in void statement position is left
+# to statement_deletion.
+class Evilution::Mutator::Operator::BinaryOperandPromotion < Evilution::Mutator::Base
+  OPERATORS = %i[+ - * / % ** & | ^ << >>].to_set.freeze
+  private_constant :OPERATORS
+
+  # The literal on the right that makes `left <op> literal` equal `left`.
+  RIGHT_IDENTITIES = { :+ => 0, :- => 0, :* => 1, :/ => 1, :** => 1, :| => 0, :^ => 0 }.freeze
+  private_constant :RIGHT_IDENTITIES
+
+  # The literal on the left that makes `literal <op> right` equal `right`.
+  LEFT_IDENTITIES = { :+ => 0, :* => 1, :| => 0, :^ => 0 }.freeze
+  private_constant :LEFT_IDENTITIES
+
+  def call(subject, **)
+    @void_statements = Set.new
+    super
+  end
+
+  def visit_statements_node(node)
+    @void_statements.merge(node.body[...-1])
+    super
+  end
+
+  def visit_call_node(node)
+    right = right_operand(node)
+    promote_operands(node, node.receiver, right) if right && !@void_statements.include?(node)
+    super
+  end
+
+  private
+
+  # The single argument of a binary operator send; nil otherwise. An operator
+  # send always has a receiver — `+b` without one is the unary `+@`.
+  def right_operand(node)
+    return unless OPERATORS.include?(node.name)
+    return unless node.arguments in Prism::ArgumentsNode[arguments: [right]]
+
+    right
+  end
+
+  def promote_operands(node, left, right)
+    promote_child(node, left) unless integer_literal?(right, RIGHT_IDENTITIES[node.name])
+    promote_child(node, right) unless integer_literal?(left, LEFT_IDENTITIES[node.name])
+  end
+
+  def integer_literal?(operand, value)
+    operand.is_a?(Prism::IntegerNode) && operand.value == value
+  end
+end

data/lib/evilution/mutator/operator/block_body_promotion.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require_relative "../operator"
+
+# Replace a call with its parameter-less block's body, run once in place:
+# `Base.transaction { account.save! }` becomes `account.save!`, and
+# `3.times { retry_call }` becomes `retry_call`. A multi-statement body is
+# grouped in parentheses so it still evaluates to its last statement where
+# the call's value is used.
+#
+# A survivor means the wrapping call is never observed: a transaction whose
+# rollback no test triggers, a lock nothing contends for, an iteration count
+# nothing checks.
+#
+# Blocks with parameters (including `_1` / `it` and block-locals) are
+# skipped — the unwrapped body would reference a variable that no longer
+# exists; explicitly empty pipes `{ || ... }` count as parameter-less. So are
+# bodies with a rescue / ensure clause, and bodies using `break` / `next` /
+# `redo`, which do not parse outside a block and are dropped by the parse
+# guard.
+class Evilution::Mutator::Operator::BlockBodyPromotion < Evilution::Mutator::Base
+  def visit_call_node(node)
+    block = node.block
+    unwrap(node, block.body) if block.is_a?(Prism::BlockNode) && parameterless?(block.parameters)
+    super
+  end
+
+  private
+
+  # No parameters at all, or explicitly empty pipes `{ || ... }`. Block-local
+  # variables (`{ |;tmp| ... }`) count as parameters: unwrapping would turn
+  # them into method locals.
+  def parameterless?(parameters)
+    parameters.nil? ||
+      (parameters.is_a?(Prism::BlockParametersNode) && parameters.parameters.nil? && parameters.locals.empty?)
+  end
+
+  def unwrap(node, body)
+    return unless body.is_a?(Prism::StatementsNode)
+
+    statements = body.body
+    replacement = statements.length == 1 ? source_of(statements.first) : "(#{source_of(body)})"
+    replace_span(node: node, target: node, replacement: replacement)
+  end
+end

data/lib/evilution/mutator/operator/block_body_to_nil.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+require_relative "../operator"
+
+# Replace a block's body with `nil`: `items.map { |item| item * 2 }` becomes
+# `items.map { |item| nil }`. Unlike block_removal, the iteration itself
+# stays, so a survivor means the block runs but nothing observes what it
+# does.
+#
+# A `do ... rescue ... end` block keeps its rescue / ensure clauses; only
+# the main statements become nil.
+#
+# Blocks that are themselves the loop are skipped — `loop { }` and an
+# endless `cycle { }` or `cycle(nil) { }` — since with a nil body nothing
+# breaks out and the mutant would hang until the per-mutation timeout (see
+# EV-170m.7).
+class Evilution::Mutator::Operator::BlockBodyToNil < Evilution::Mutator::Base
+  def visit_call_node(node)
+    block = node.block
+    empty_body(node, block) if block.is_a?(Prism::BlockNode) && !endless_iteration?(node)
+    super
+  end
+
+  private
+
+  def empty_body(node, block)
+    body = block.body
+    statements = body.is_a?(Prism::BeginNode) ? body.statements : body
+    mutate_to_nil(node, target: statements)
+  end
+
+  def endless_iteration?(node)
+    case node.name
+    when :loop then kernel_receiver?(node.receiver)
+    when :cycle then endless_count?(node.arguments)
+    end
+  end
+
+  # `loop`, `Kernel.loop` or `::Kernel.loop` — not a namespaced `Acme::Kernel`.
+  def kernel_receiver?(receiver)
+    case receiver
+    when nil then true
+    when Prism::ConstantReadNode then receiver.name == :Kernel
+    when Prism::ConstantPathNode then receiver.parent.nil? && receiver.name == :Kernel
+    end
+  end
+
+  # `cycle` and `cycle(nil)` both repeat forever.
+  def endless_count?(arguments)
+    arguments.nil? || (arguments in Prism::ArgumentsNode[arguments: [Prism::NilNode]])
+  end
+end

data/lib/evilution/mutator/operator/block_body_to_raise.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require_relative "../operator"
+
+# Replace a block's body with a bare `raise`: `items.map { |item| item * 2 }`
+# becomes `items.map { |item| raise }`.
+#
+# A survivor means no test ever invokes the block — every collection it
+# iterates is empty, or the callback is never called. The raise ends the
+# block on its first call, so unlike block_body_to_nil a `loop { }` is safe
+# here.
+#
+# A block whose body has a `rescue` clause is skipped: that clause would
+# catch the raise, and the mutant would exercise the rescue path instead of
+# the invocation. An `ensure` clause does not swallow it and stays.
+class Evilution::Mutator::Operator::BlockBodyToRaise < Evilution::Mutator::Base
+  def visit_call_node(node)
+    block = node.block
+    raise_in_body(node, block.body) if block.is_a?(Prism::BlockNode)
+    super
+  end
+
+  private
+
+  def raise_in_body(node, body)
+    if body.is_a?(Prism::BeginNode)
+      return if body.rescue_clause
+
+      body = body.statements
+    end
+
+    replace_span(node: node, target: body, replacement: "raise")
+  end
+end

data/lib/evilution/mutator/operator/block_destructuring_expansion.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+require "prism"
+
+require_relative "../operator"
+
+# Flatten a destructuring group in a block's parameter list:
+# `pairs.each_with_index { |(key, value), index| ... }` becomes
+# `pairs.each_with_index { |key, value, index| ... }`.
+#
+# The two forms bind differently once the group has a sibling: given `[1, 2]`
+# and `3`, the grouped form binds key=1, value=2, index=3, while the flat form
+# binds key=[1, 2], value=3, index=nil. A survivor means nothing asserts the
+# shape of what the yielder hands over.
+#
+# A lone group is left alone. With one parameter and a single yielded array —
+# what `each` over pairs, and `Hash#each`, actually yield — both forms bind the
+# same values, so the mutation would be behaviour-preserving and survive every
+# suite. The forms do diverge there for a yielder that passes several values,
+# but which one a block is handed cannot be known from the source, and a
+# guaranteed survivor on the common idiom is the worse trade.
+#
+# Methods and lambdas are left alone as well: both bind by arity, so flattening
+# a group in their signatures raises ArgumentError at every call site instead of
+# changing how arguments are distributed.
+class Evilution::Mutator::Operator::BlockDestructuringExpansion < Evilution::Mutator::Base
+  def visit_block_node(node)
+    expand_groups(node)
+    super
+  end
+
+  private
+
+  def expand_groups(node)
+    parameters = node.parameters
+    return unless parameters.is_a?(Prism::BlockParametersNode)
+
+    inner = parameters.parameters
+    return unless inner.is_a?(Prism::ParametersNode)
+    return unless siblings?(inner)
+
+    groups(inner).each { |group| flatten_group(group) }
+  end
+
+  # Both lists can hold a destructuring group: `|(a, b), c|` puts it in
+  # requireds, `|*rest, (a, b)|` in posts.
+  def groups(parameters)
+    [*parameters.requireds, *parameters.posts].grep(Prism::MultiTargetNode)
+  end
+
+  def siblings?(parameters)
+    parameter_count(parameters) > 1
+  end
+
+  # Block-local variables (`|a; tmp|`) are not parameters and so are not
+  # siblings — they change nothing about how arguments bind.
+  def parameter_count(parameters)
+    [
+      *parameters.requireds,
+      *parameters.optionals,
+      parameters.rest,
+      *parameters.posts,
+      *parameters.keywords,
+      parameters.keyword_rest,
+      parameters.block
+    ].compact.length
+  end
+
+  # Only the group's own parentheses go; anything nested inside keeps its own.
+  # A group written in a block's parameter list always carries them — the
+  # parenthesis-free MultiTargetNode belongs to multiple assignment, which is
+  # not reachable from here.
+  def flatten_group(group)
+    lparen = group.lparen_loc
+    rparen = group.rparen_loc
+
+    inner_start = lparen.start_offset + lparen.length
+    add_mutation(
+      offset: group.location.start_offset,
+      length: group.location.length,
+      replacement: byteslice_source(inner_start, rparen.start_offset - inner_start),
+      node: group
+    )
+  end
+end

data/lib/evilution/mutator/operator/block_parameter_drop.rb

@@ -0,0 +1,96 @@
+# frozen_string_literal: true
+
+require "prism"
+
+require_relative "../operator"
+
+# Drop the single parameter of a block: `users.each { |u| touch(u) }` becomes
+# `users.each { touch(u) }`.
+#
+# A block tolerates being handed more arguments than it declares, so the mutant
+# runs until the body reads the dropped name, where it raises NameError. A
+# survivor therefore means the block never ran on a path the suite asserts —
+# the collection was empty, or the call was stubbed away.
+#
+# Not to be confused with BlockParamRemoval, which removes a method's `&block`
+# parameter from its signature.
+#
+# Two shapes are deliberately left alone. A parameter the body never reads makes
+# the mutation behaviour-preserving, so it would survive every suite and report
+# a coverage gap that is not there. A lambda checks its arity, so dropping its
+# parameter raises ArgumentError on every call, whatever the body does.
+class Evilution::Mutator::Operator::BlockParameterDrop < Evilution::Mutator::Base
+  def visit_block_node(node)
+    drop_parameter(node)
+    super
+  end
+
+  private
+
+  def drop_parameter(node)
+    return unless droppable?(node)
+
+    location = node.parameters.location
+    leading = leading_space(location)
+
+    add_mutation(
+      offset: location.start_offset - leading,
+      length: location.length + leading,
+      replacement: "",
+      node: node
+    )
+  end
+
+  def droppable?(node)
+    parameters = node.parameters
+    return false unless parameters.is_a?(Prism::BlockParametersNode)
+    return false unless parameters.locals.empty?
+
+    names = single_parameter_names(parameters.parameters)
+    names.any? { |name| body_reads?(node.body, name) }
+  end
+
+  # The space the block keyword leaves in front of the parameters goes with
+  # them, so `{ |u| body }` mutates to `{ body }` and `do |u|` to `do` rather
+  # than leaving a double space or a trailing one.
+  def leading_space(location)
+    preceding = @file_source.byteslice(location.start_offset - 1, 1)
+    preceding == " " ? 1 : 0
+  end
+
+  # The names bound by a lone required parameter, which is either a plain name
+  # or a destructuring target (`|(key, value)|`). Anything else — a second
+  # parameter, an optional, a rest, a keyword, a block pass, or the implicit
+  # rest Prism reports for the trailing comma in `|key,|` — means this is not a
+  # single-parameter block, and numbered parameters carry no node to remove.
+  def single_parameter_names(parameters)
+    return [] unless parameters.is_a?(Prism::ParametersNode)
+    return [] unless parameters.requireds.length == 1
+    return [] unless other_parameters_absent?(parameters)
+
+    parameter_names(parameters.requireds.first)
+  end
+
+  # Post-required parameters are not checked: block syntax only produces them
+  # after a rest parameter, which is rejected here anyway.
+  def other_parameters_absent?(parameters)
+    parameters.optionals.empty? && parameters.keywords.empty? &&
+      parameters.rest.nil? && parameters.keyword_rest.nil? && parameters.block.nil?
+  end
+
+  def parameter_names(node)
+    case node
+    when Prism::RequiredParameterNode then [node.name.to_s]
+    when Prism::MultiTargetNode then node.lefts.flat_map { |child| parameter_names(child) }
+    else []
+    end
+  end
+
+  # An underscore-prefixed name announces a parameter that is not meant to be
+  # read, so it is treated as unused even where the body happens to mention it.
+  def body_reads?(body, name)
+    return false if name.start_with?("_")
+
+    Evilution::AST::LocalReads.new.call(body, name)
+  end
+end

data/lib/evilution/mutator/operator/call_to_nil.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require_relative "../operator"
+
+# Replace a method call with `nil`: `user.name` becomes `nil`, and the same
+# for implicit-self calls, operator calls and calls carrying a block.
+#
+# The broadest value-level probe on a call site. The survivor it targets is a
+# call whose result is never asserted — the test runs the code but checks
+# nothing that depends on what the call returned.
+#
+# Three positions are skipped as noise. A call in void statement position
+# (every statement of a body except the last) has no value to replace;
+# deleting it is statement_deletion's job. A call used as the receiver of
+# another call turns into `nil.foo`, a NoMethodError any test that reaches it
+# kills; the outer call is nil-ified instead. An attribute or index write
+# (`a.b = c`, `a[i] = c`) is a side effect, not a value.
+class Evilution::Mutator::Operator::CallToNil < Evilution::Mutator::Base
+  def call(subject, **)
+    @skipped_calls = Set.new
+    super
+  end
+
+  def visit_statements_node(node)
+    @skipped_calls.merge(node.body[...-1])
+    super
+  end
+
+  def visit_call_node(node)
+    @skipped_calls.add(node.receiver)
+    mutate_to_nil(node) unless @skipped_calls.include?(node) || node.attribute_write?
+    super
+  end
+end

data/lib/evilution/mutator/operator/coercion_emptying.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+require_relative "../operator"
+
+# Replace a conversion with an empty value of its target type: `value.to_a`
+# becomes `[]`, `value.to_h` becomes `{}`, `value.to_s` becomes `""`, and the
+# same for the implicit `to_ary` / `to_hash` / `to_str` forms.
+#
+# The type stays right, so a survivor means tests check what kind of value
+# comes out but never what it contains.
+#
+# An empty hash that is the first argument of an unparenthesized call,
+# `yield` or `super` is written `({})`: bare `{}` there would be parsed as a
+# block. A nil receiver is skipped — its conversion is already empty.
+class Evilution::Mutator::Operator::CoercionEmptying < Evilution::Mutator::Base
+  EMPTY_VALUES = {
+    to_a: "[]", to_ary: "[]",
+    to_h: "{}", to_hash: "{}",
+    to_s: '""', to_str: '""'
+  }.freeze
+  private_constant :EMPTY_VALUES
+
+  def call(subject, **)
+    @bare_first_arguments = Set.new
+    super
+  end
+
+  def visit_call_node(node)
+    note_bare_first_argument(node, node.opening_loc)
+    empty(node) if emptiable?(node)
+    super
+  end
+
+  def visit_yield_node(node)
+    note_bare_first_argument(node, node.lparen_loc)
+    super
+  end
+
+  def visit_super_node(node)
+    note_bare_first_argument(node, node.lparen_loc)
+    super
+  end
+
+  private
+
+  def note_bare_first_argument(node, opening)
+    @bare_first_arguments.add(node.arguments.arguments.first) if opening.nil? && node.arguments
+  end
+
+  def emptiable?(node)
+    EMPTY_VALUES.key?(node.name) && node.receiver && !node.receiver.is_a?(Prism::NilNode) &&
+      node.arguments.nil? && node.block.nil?
+  end
+
+  def empty(node)
+    value = EMPTY_VALUES.fetch(node.name)
+    value = "(#{value})" if value == "{}" && @bare_first_arguments.include?(node)
+    replace_span(node: node, target: node, replacement: value)
+  end
+end

data/lib/evilution/mutator/operator/collection_replacement.rb

@@ -12,10 +12,10 @@ class Evilution::Mutator::Operator::CollectionReplacement < Evilution::Mutator::
     collect: [:each],
     sort: [:sort_by],
     sort_by: [:sort],
-    find: [:detect],
-    detect: [:find],
-    any?: [:all?],
-    all?: [:any?],
+    find: %i[detect first last],
+    detect: %i[find first last],
+    any?: %i[all? empty? none?],
+    all?: %i[any? none?],
     count: [:length],
     length: [:count],
     pop: [:shift],
@@ -30,10 +30,10 @@ class Evilution::Mutator::Operator::CollectionReplacement < Evilution::Mutator::
     grep_v: [:grep],
     take: [:drop],
     drop: [:take],
-    min: [:max],
-    max: [:min],
-    min_by: [:max_by],
-    max_by: [:min_by],
+    min: %i[max first last],
+    max: %i[min first last],
+    min_by: %i[max_by first last],
+    max_by: %i[min_by first last],
     compact: [:flatten],
     flatten: [:compact],
     zip: [:product],
@@ -41,7 +41,17 @@ class Evilution::Mutator::Operator::CollectionReplacement < Evilution::Mutator::
     first: [:last],
     last: [:first],
     keys: [:values],
-    values: [:keys]
+    values: [:keys],
+    sample: %i[first last],
+    fetch: [:key?],
+    at: %i[fetch key?],
+    delete_if: [:reject],
+    keep_if: [:select],
+    filter_map: [:map],
+    chunk: [:each],
+    chunk_while: [:each],
+    each_with_index: [:each],
+    slice_when: [:each]
   }.freeze
 
   def visit_call_node(node)