sonicop 26.8.112 → 26.8.113

data/src/rules/lint/hash_compare_by_identity.rs

@@ -6,6 +6,7 @@ use crate::rules::send_node::{arguments, is_plain_send, send_range};
 
 use super::locals::LocalVariables;
 use crate::rules::node_ext::NodeExt;
+use crate::rules::send_node::named_children_of;
 
 const MSG: &str = "Use `Hash#compare_by_identity` instead of using `object_id` for keys.";
 
@@ -29,13 +30,13 @@ pub(super) fn check(context: &RuleContext<'_>, offenses: &mut Vec<Offense>) {
 /// reports it at.
 fn keyed_call<'tree>(
     node: Node<'tree>,
-    context: &RuleContext<'_>,
+    context: &'tree RuleContext<'_>,
 ) -> Option<(Node<'tree>, std::ops::Range<usize>)> {
     if node.kind_str() == "element_reference" {
         let object = node.field("object")?;
-        let mut cursor = node.walk();
-        let key = node
-            .named_children(&mut cursor)
+        let _cursor = node.walk();
+        let key = named_children_of(node, context)
+            .into_iter()
             .find(|child| child.id() != object.id())?;
         // `hash[k] = v` is one `[]=` send upstream, spanning the assignment rather than the
         // brackets. Written in a multiple assignment the send holds no value and stops at the

data/src/rules/lint/heredoc_method_call_position.rs

@@ -5,7 +5,8 @@ use tree_sitter::Node;
 use crate::diagnostic::{Edit, Offense};
 use crate::rules::RuleContext;
 use crate::rules::node_ext::NodeExt;
-use crate::rules::send_node::{arguments, heredoc_body, named_children};
+use crate::rules::send_node::{arguments, heredoc_body};
+use crate::rules::send_node::named_children_of;
 
 const MSG: &str =
     "Put a method call with a HEREDOC receiver on the same line as the HEREDOC opening.";
@@ -70,7 +71,7 @@ fn heredoc_receiver<'tree>(node: Node<'tree>) -> Option<Node<'tree>> {
 /// `heredoc.location.heredoc_end.end_pos`: where the terminator line ends.
 fn heredoc_end(heredoc: Node<'_>, context: &RuleContext<'_>) -> Option<usize> {
     let body = heredoc_body(heredoc, context)?;
-    named_children(body)
+    named_children_of(body, context)
         .into_iter()
         .find(|child| child.kind_str() == "heredoc_end")
         .map(|end| end.end_byte())

data/src/rules/lint/implicit_string_concatenation.rs

@@ -3,7 +3,9 @@ use tree_sitter::Node;
 use crate::diagnostic::{Edit, Offense};
 use crate::rules::RuleContext;
 use crate::rules::node_ext::NodeExt;
-use crate::rules::send_node::{is_plain_send, named_children, string_text};
+use crate::rules::send_node::{is_plain_send, string_text};
+use crate::rules::send_node::named_children_of;
+use crate::rules::send_node::all_children_of;
 
 const FOR_ARRAY: &str =
     " Or, if they were intended to be separate array elements, separate them with a comma.";
@@ -15,7 +17,7 @@ pub(super) fn check(context: &RuleContext<'_>, offenses: &mut Vec<Offense>) {
     // adjacent literals build: the parts of `"a\nb"` are fragments of a single literal, and the
     // delimiter test upstream applies is what tells the two apart.
     for node in context.nodes_of("chained_string") {
-        let parts = named_children(node);
+        let parts = named_children_of(node, context);
         let suffix = suffix(node, context);
         for pair in parts.windows(2) {
             let (left, right) = (pair[0], pair[1]);
@@ -91,9 +93,9 @@ fn display(node: Node<'_>, context: &RuleContext<'_>) -> String {
 /// nothing to `str_type?` -- so the recursion joins an empty string for it. Showing the source
 /// instead puts `#{...}` in a message that upstream writes without it.
 fn str_content(node: Node<'_>, context: &RuleContext<'_>) -> String {
-    let mut cursor = node.walk();
-    let parts: Vec<String> = node
-        .children(&mut cursor)
+    let _cursor = node.walk();
+    let parts: Vec<String> = all_children_of(node, context)
+        .into_iter()
         .filter(|child| child.is_named() && child.kind_str() != "interpolation")
         .map(|child| match child.kind_str() {
             // **`str_content` reads the value, not the source.** A `\` closing a line joins it to

data/src/rules/lint/ineffective_access_modifier.rs

@@ -5,6 +5,7 @@ use crate::diagnostic::Offense;
 use crate::rules::RuleContext;
 use crate::rules::send_node::symbol_name;
 use crate::rules::node_ext::NodeExt;
+use crate::rules::send_node::named_children_iter;
 
 const ALTERNATIVE_PRIVATE: &str =
     "`private_class_method` or `private` inside a `class << self` block";
@@ -109,15 +110,15 @@ fn private_class_method_names(context: &RuleContext<'_>, node: Node<'_>) -> Vec<
                 .is_some_and(|method| context.source.node_text(method) == "private_class_method")
             && let Some(arguments) = current.field("arguments")
         {
-            let mut cursor = arguments.walk();
-            for argument in arguments.named_children(&mut cursor) {
+            let _cursor = arguments.walk();
+            for argument in named_children_iter(arguments, context) {
                 if let Some(name) = symbol_name(argument, context) {
                     names.push(name.to_owned());
                 }
             }
         }
-        let mut cursor = current.walk();
-        stack.extend(current.named_children(&mut cursor));
+        let _cursor = current.walk();
+        stack.extend(named_children_iter(current, context));
     }
     names
 }

data/src/rules/lint/inherit_exception.rs

@@ -3,6 +3,7 @@ use tree_sitter::Node;
 use crate::diagnostic::{Edit, Offense};
 use crate::rules::RuleContext;
 use crate::rules::node_ext::NodeExt;
+use crate::rules::send_node::named_children_of;
 
 pub(super) fn check(context: &RuleContext<'_>, offenses: &mut Vec<Offense>) {
     // The indirect inheritance the cop can also report needs `AllCops/UseProjectIndex` and the
@@ -103,9 +104,9 @@ fn shadowed_by_a_sibling_definition(
     let Some(parent) = node.parent_of(context) else {
         return false;
     };
-    let mut cursor = parent.walk();
-    parent
-        .named_children(&mut cursor)
+    let _cursor = parent.walk();
+    named_children_of(parent, context)
+        .into_iter()
         .take_while(|sibling| sibling.id() != node.id())
         .any(|sibling| {
             matches!(sibling.kind_str(), "class" | "module")

data/src/rules/lint/literal_as_condition.rs

@@ -10,6 +10,8 @@ use crate::rules::send_node::named_children;
 use super::literals::{is_basic_literal, is_falsey_literal, is_literal, is_truthy_literal};
 use super::statements::{Branch, statements};
 use crate::rules::node_ext::NodeExt;
+use crate::rules::send_node::{named_children_of};
+use crate::rules::send_node::named_children_iter;
 
 /// The nodes whose `condition` the parser rewrites: a range there becomes a flip-flop and a regexp
 /// a match against `$_`, and neither is a literal any more.
@@ -315,11 +317,11 @@ fn check_case(node: Node<'_>, context: &RuleContext<'_>, offenses: &mut Vec<Offe
         check_case_condition(condition, context, offenses);
         return;
     }
-    for branch in named_children(node)
+    for branch in named_children_of(node, context)
         .into_iter()
         .filter(|child| child.kind_str() == "when")
     {
-        let conditions: Vec<Node<'_>> = named_children(branch)
+        let conditions: Vec<Node<'_>> = named_children_of(branch, context)
             .into_iter()
             .filter(|child| child.kind_str() == "pattern")
             .flat_map(named_children)
@@ -364,7 +366,7 @@ fn check_case_condition(
 
 /// `primitive_array?`.
 fn primitive_array(node: Node<'_>, context: &RuleContext<'_>) -> bool {
-    named_children(node).into_iter().all(|child| {
+    named_children_iter(node, context).all(|child| {
         if child.kind_str() == "array" {
             primitive_array(child, context)
         } else {

data/src/rules/lint/literal_assignment_in_condition.rs

@@ -4,6 +4,7 @@ use crate::diagnostic::Offense;
 use crate::rules::RuleContext;
 use crate::rules::node_ext::NodeExt;
 use crate::rules::send_node::{has_interpolation, heredoc_body, named_children};
+use crate::rules::send_node::named_children_of;
 
 pub(super) fn check(context: &RuleContext<'_>, offenses: &mut Vec<Offense>) {
     for node in context.nodes_of_any(&[
@@ -86,11 +87,11 @@ fn all_literals(node: Node<'_>, context: &RuleContext<'_>) -> bool {
         "chained_string" | "subshell" => false,
         "string" => !has_interpolation(node),
         "heredoc_beginning" => is_single_line_heredoc(node, context),
-        "array" | "string_array" | "symbol_array" | "right_assignment_list" => named_children(node)
+        "array" | "string_array" | "symbol_array" | "right_assignment_list" => named_children_of(node, context)
             .into_iter()
             .filter(|child| child.kind_str() != "comment")
             .all(|value| all_literals(value, context)),
-        "hash" => named_children(node)
+        "hash" => named_children_of(node, context)
             .into_iter()
             .filter(|child| child.kind_str() != "comment")
             .all(|pair| {
@@ -123,7 +124,7 @@ fn is_single_line_heredoc(node: Node<'_>, context: &RuleContext<'_>) -> bool {
     let Some(body) = heredoc_body(node, context) else {
         return false;
     };
-    let content: Vec<Node<'_>> = named_children(body)
+    let content: Vec<Node<'_>> = named_children_of(body, context)
         .into_iter()
         .filter(|child| child.kind_str() != "heredoc_end")
         .collect();

data/src/rules/lint/literal_in_interpolation.rs

@@ -4,6 +4,7 @@ use crate::diagnostic::{Edit, Offense};
 use crate::rules::RuleContext;
 use crate::rules::node_ext::NodeExt;
 use crate::rules::ruby_literal::{character_value, inspect_string, inspect_symbol, string_value};
+use crate::rules::send_node::named_children_of;
 
 const MSG: &str = "Literal interpolation detected.";
 
@@ -58,8 +59,7 @@ pub(super) fn check(context: &RuleContext<'_>, offenses: &mut Vec<Offense>) {
 /// evaluated and thrown away.
 fn last_statement<'tree>(interpolation: Node<'tree>) -> Option<Node<'tree>> {
     let mut cursor = interpolation.walk();
-    interpolation
-        .named_children(&mut cursor)
+    interpolation.named_children(&mut cursor)
         .filter(|child| {
             !matches!(
                 child.kind_str(),
@@ -370,9 +370,9 @@ fn array_value(node: Node<'_>, context: &RuleContext<'_>) -> String {
 }
 
 fn hash_value(node: Node<'_>, context: &RuleContext<'_>) -> String {
-    let mut cursor = node.walk();
-    let pairs: Vec<String> = node
-        .named_children(&mut cursor)
+    let _cursor = node.walk();
+    let pairs: Vec<String> = named_children_of(node, context)
+        .into_iter()
         .map(|pair| {
             let key = pair
                 .field("key")

data/src/rules/lint/literals.rs

@@ -11,6 +11,7 @@ use tree_sitter::Node;
 use crate::rules::RuleContext;
 use crate::rules::node_ext::NodeExt;
 use crate::rules::send_node::has_interpolation;
+use crate::rules::send_node::named_children_of;
 
 /// `BASIC_LITERALS`: a literal whose value is the node itself.
 const BASIC: &[&str] = &[
@@ -95,8 +96,9 @@ pub(crate) fn recursive_basic_literal(node: Node<'_>, context: &RuleContext<'_>)
 
 /// `children.compact.all?(&:recursive_basic_literal?)`.
 fn all_children(node: Node<'_>, context: &RuleContext<'_>) -> bool {
-    let mut cursor = node.walk();
-    node.named_children(&mut cursor)
+    let _cursor = node.walk();
+    named_children_of(node, context)
+        .into_iter()
         .filter(|child| child.kind_str() != "comment")
         .all(|child| match child.kind_str() {
             // The parts a quoted literal is written from are not nodes upstream at all: the text
@@ -189,9 +191,9 @@ fn string_type(node: Node<'_>, context: &RuleContext<'_>) -> &'static str {
     if has_interpolation(node) {
         return "dstr";
     }
-    let mut cursor = node.walk();
-    let broken = node
-        .named_children(&mut cursor)
+    let _cursor = node.walk();
+    let broken = named_children_of(node, context)
+        .into_iter()
         .filter(|child| child.kind_str() == "string_content")
         .any(|child| context.source.node_text(child).contains('\n'));
     if broken { "dstr" } else { "str" }
@@ -206,9 +208,9 @@ fn heredoc_type(node: Node<'_>, context: &RuleContext<'_>) -> &'static str {
     if has_interpolation(body) {
         return "dstr";
     }
-    let mut cursor = body.walk();
-    let lines: usize = body
-        .named_children(&mut cursor)
+    let _cursor = body.walk();
+    let lines: usize = named_children_of(body, context)
+        .into_iter()
         .filter(|child| child.kind_str() == "heredoc_content")
         .map(|child| context.source.node_text(child).matches('\n').count())
         .sum();

data/src/rules/lint/no_return_in_begin_end_blocks.rs

@@ -16,7 +16,7 @@ pub(super) fn check(context: &RuleContext<'_>, offenses: &mut Vec<Offense>) {
             continue;
         }
         for kwbegin in kwbegin_nodes(node) {
-            walk_named(kwbegin, &mut |inner| {
+            walk_named(kwbegin, context, &mut |inner| {
                 if inner.kind_str() != "return" || return_from_inner_scope(inner, kwbegin, context)
                 {
                     return;
@@ -84,7 +84,7 @@ fn return_from_inner_scope(node: Node<'_>, kwbegin: Node<'_>, context: &RuleCont
             return false;
         }
         if matches!(ancestor.kind_str(), "method" | "singleton_method" | "lambda")
-            || is_lambda(ancestor, context.source)
+            || is_lambda(ancestor, context.source, context.ast_index())
         {
             return true;
         }

data/src/rules/lint/node_equality.rs

@@ -10,6 +10,8 @@ use tree_sitter::Node;
 
 use crate::rules::RuleContext;
 use crate::rules::node_ext::NodeExt;
+use crate::rules::send_node::all_children_of;
+use crate::rules::send_node::named_children_of;
 
 /// Whether the two operands are the same node. Upstream compares structurally rather than by
 /// source -- `Node#==` looks at the type and the children -- so a difference in spacing is no
@@ -227,8 +229,9 @@ fn heredoc_parts<'tree>(body: Node<'tree>) -> Vec<Node<'tree>> {
 }
 
 fn operator_text(node: Node<'_>, context: &RuleContext<'_>) -> String {
-    let mut cursor = node.walk();
-    node.children(&mut cursor)
+    let _cursor = node.walk();
+    all_children_of(node, context)
+        .into_iter()
         .filter(|child| !child.is_named())
         .map(|child| context.source.node_text(child))
         .collect()
@@ -288,9 +291,9 @@ fn literal(node: Node<'_>, context: &RuleContext<'_>) -> Option<Literal> {
 /// is a `dstr`/`dsym` upstream and has no value of its own, and an escape this cannot resolve
 /// leaves the node to be compared structurally instead.
 fn quoted_value(node: Node<'_>, context: &RuleContext<'_>) -> Option<Vec<u8>> {
-    let mut cursor = node.walk();
-    if node
-        .named_children(&mut cursor)
+    let _cursor = node.walk();
+    if named_children_of(node, context)
+        .into_iter()
         .any(|child| child.kind_str() == "interpolation")
     {
         return None;

data/src/rules/lint/non_atomic_file_operation.rs

@@ -271,7 +271,7 @@ fn find_exist_call<'tree>(
             return Some(node);
         }
         let mut children = Vec::new();
-        crate::rules::push_named_children(node, &mut children);
+        crate::rules::push_named_children_in(node, context, &mut children);
         children.reverse();
         stack.extend(children);
     }

data/src/rules/lint/non_deterministic_require_order.rs

@@ -3,11 +3,13 @@ use tree_sitter::Node;
 use crate::diagnostic::{Edit, Offense};
 use crate::ruby_version::RubyVersion;
 use crate::rules::RuleContext;
-use crate::rules::send_node::{arguments, is_plain_send, named_children, send_range};
+use crate::rules::send_node::{arguments, is_plain_send, send_range};
 
 use super::blocks::{BLOCK_KINDS, BlockArgs};
 use super::locals::LocalVariables;
 use crate::rules::node_ext::NodeExt;
+use crate::rules::send_node::named_children_of;
+use crate::rules::send_node::named_children_iter;
 
 const MSG: &str = "Sort files before requiring them.";
 
@@ -190,7 +192,7 @@ fn is_method_require(node: Node<'_>, context: &RuleContext<'_>) -> bool {
     if node.kind_str() != "block_argument" {
         return false;
     }
-    let Some(call) = named_children(node).into_iter().next() else {
+    let Some(call) = named_children_iter(node, context).next() else {
         return false;
     };
     if call.kind_str() != "call"
@@ -226,7 +228,7 @@ fn requires_variable(node: Node<'_>, name: &str, context: &RuleContext<'_>) -> b
             return true;
         }
     }
-    named_children(node)
+    named_children_of(node, context)
         .into_iter()
         .any(|child| requires_variable(child, name, context))
 }

data/src/rules/lint/non_local_exit_from_iterator.rs

@@ -3,10 +3,11 @@ use tree_sitter::Node;
 use crate::diagnostic::Offense;
 use crate::rules::RuleContext;
 use crate::rules::node_ext::NodeExt;
-use crate::rules::send_node::{arguments, is_plain_send, named_children};
+use crate::rules::send_node::{arguments, is_plain_send};
 
 use super::blocks::BlockArgs;
 use super::locals::LocalVariables;
+use crate::rules::send_node::named_children_of;
 
 const MSG: &str = "Non-local exit from iterator, without return value. \
                    `next`, `break`, `Array#find`, `Array#any?`, etc. is preferred.";
@@ -15,7 +16,7 @@ pub(super) fn check(context: &RuleContext<'_>, offenses: &mut Vec<Offense>) {
     let locals = LocalVariables::new(context);
     for node in context.nodes_of("return") {
         // `return_value?`: a `return` handing back a value leaves the iterator on purpose.
-        if !named_children(node).is_empty() {
+        if !named_children_of(node, context).is_empty() {
             continue;
         }
         let Some(keyword) = node.child(0).filter(|child| child.kind_str() == "return") else {

data/src/rules/lint/number_conversion.rs

@@ -205,7 +205,7 @@ fn uses_safe_navigation(node: Node<'_>, context: &RuleContext<'_>) -> bool {
         {
             return true;
         }
-        crate::rules::push_named_children(current, &mut stack);
+        crate::rules::push_named_children_in(current, context, &mut stack);
     }
     false
 }

data/src/rules/lint/out_of_range_regexp_ref.rs

@@ -6,6 +6,8 @@ use crate::rules::send_node::{arguments, named_children};
 
 use super::regexp::{captures, interpolates, pattern};
 use crate::rules::node_ext::NodeExt;
+use crate::rules::send_node::named_children_of;
+use crate::rules::send_node::named_children_iter;
 
 /// The methods that leave `$~` set, which is what makes a numbered reference after them valid.
 /// `RESTRICT_ON_SEND` is this list, so a call to anything else leaves the state alone.
@@ -71,7 +73,7 @@ fn visit(node: Node<'_>, walk: &mut Walk, context: &RuleContext<'_>, offenses: &
             }
         }
         "when" => {
-            walk.valid_ref = named_children(node)
+            walk.valid_ref = named_children_of(node, context)
                 .into_iter()
                 .filter(|child| child.kind_str() == "pattern")
                 .flat_map(named_children)
@@ -100,7 +102,7 @@ fn visit(node: Node<'_>, walk: &mut Walk, context: &RuleContext<'_>, offenses: &
     // conditional puts its condition after its body here and before it upstream, for the same
     // reason: the walk has to see them in the order the parser's children are listed.
     let block = node.field("block");
-    let mut children = named_children(node);
+    let mut children = named_children_of(node, context);
     if matches!(
         node.kind_str(),
         "if_modifier" | "unless_modifier" | "while_modifier" | "until_modifier"
@@ -198,7 +200,7 @@ fn is_capture_call(node: Node<'_>, context: &RuleContext<'_>) -> bool {
 }
 
 /// `regexp_first_argument?` and `regexp_receiver?`, which is what the state is taken from.
-fn regexp_operand<'tree>(node: Node<'tree>, context: &RuleContext<'_>) -> Option<Node<'tree>> {
+fn regexp_operand<'tree>(node: Node<'tree>, context: &'tree RuleContext<'_>) -> Option<Node<'tree>> {
     let (name, first, receiver) = match node.kind_str() {
         "call" => (
             context
@@ -214,7 +216,7 @@ fn regexp_operand<'tree>(node: Node<'tree>, context: &RuleContext<'_>) -> Option
             node.field("right"),
             node.field("left"),
         ),
-        "element_reference" => ("[]", named_children(node).into_iter().nth(1), node.child(0)),
+        "element_reference" => ("[]", named_children_iter(node, context).nth(1), node.child(0)),
         _ => return None,
     };
     if let Some(first) = first

data/src/rules/lint/redundant_dir_glob_sort.rs

@@ -91,8 +91,7 @@ fn is_dir_glob(receiver: Node<'_>, context: &RuleContext<'_>) -> bool {
 fn glob_arguments<'tree>(receiver: Node<'tree>) -> Vec<Node<'tree>> {
     if receiver.kind_str() == "element_reference" {
         let mut cursor = receiver.walk();
-        return receiver
-            .named_children(&mut cursor)
+        return receiver.named_children(&mut cursor)
             .filter(|child| {
                 child.kind_str() != "comment"
                     && receiver

data/src/rules/lint/redundant_safe_navigation.rs

@@ -2,13 +2,14 @@ use tree_sitter::Node;
 
 use crate::diagnostic::{Edit, Offense};
 use crate::rules::RuleContext;
-use crate::rules::send_node::{arguments, named_children, string_text, symbol_name};
+use crate::rules::send_node::{arguments, string_text, symbol_name};
 
 use super::blocks::BLOCK_KINDS;
 use super::literals::{is_literal, literal_type};
 use super::nil_methods::NIL_METHODS;
 use super::nil_receiver::cant_be_nil;
 use crate::rules::node_ext::NodeExt;
+use crate::rules::send_node::named_children_of;
 
 const MSG: &str = "Redundant safe navigation detected, use `.` instead.";
 const MSG_LITERAL: &str = "Redundant safe navigation with default literal detected.";
@@ -217,8 +218,8 @@ fn check_conversion_with_default(
         .field("block")
         .is_some_and(|block| BLOCK_KINDS.contains(&block.kind_str()));
     let matched = match context.source.node_text(method) {
-        "to_h" => right.kind_str() == "hash" && named_children(right).is_empty(),
-        "to_a" if !has_block => right.kind_str() == "array" && named_children(right).is_empty(),
+        "to_h" => right.kind_str() == "hash" && named_children_of(right, context).is_empty(),
+        "to_a" if !has_block => right.kind_str() == "array" && named_children_of(right, context).is_empty(),
         "to_i" if !has_block => {
             right.kind_str() == "integer" && context.source.node_text(right) == "0"
         }

data/src/rules/lint/redundant_splat_expansion.rs

@@ -9,6 +9,8 @@ use crate::rules::send_node::{is_plain_send, named_children, top_level_constant}
 use super::literals::literal_type;
 use super::statements::statements;
 use crate::rules::node_ext::NodeExt;
+use crate::rules::send_node::named_children_of;
+use crate::rules::send_node::named_children_iter;
 
 const MSG: &str = "Replace splat expansion with comma separated values.";
 const ARRAY_PARAM_MSG: &str = "Pass array contents as separate arguments.";
@@ -48,7 +50,7 @@ pub(super) fn check(context: &RuleContext<'_>, offenses: &mut Vec<Offense>) {
         .setting::<bool>("AllowPercentLiteralArrayArgument")
         .unwrap_or(true);
     for node in context.nodes_of("splat_argument") {
-        let Some(expanded) = named_children(node).into_iter().next() else {
+        let Some(expanded) = named_children_iter(node, context).next() else {
             continue;
         };
         let (position, grandparent) = position_of(node);
@@ -67,7 +69,7 @@ pub(super) fn check(context: &RuleContext<'_>, offenses: &mut Vec<Offense>) {
             if !EXPANDABLE.contains(&kind) {
                 continue;
             }
-            if kind == "array" && named_children(expanded).is_empty() {
+            if kind == "array" && named_children_of(expanded, context).is_empty() {
                 continue;
             }
         }

data/src/rules/lint/redundant_string_coercion.rs

@@ -2,11 +2,12 @@ use tree_sitter::Node;
 
 use crate::diagnostic::{Edit, Offense};
 use crate::rules::RuleContext;
-use crate::rules::send_node::{arguments, named_children};
+use crate::rules::send_node::arguments;
 
 use super::locals::LocalVariables;
 use super::statements::statements;
 use crate::rules::node_ext::NodeExt;
+use crate::rules::send_node::named_children_of;
 
 /// The receiverless calls whose arguments coerce on their own.
 const PRINTERS: &[&str] = &["print", "puts", "warn"];
@@ -39,7 +40,7 @@ pub(super) fn check(context: &RuleContext<'_>, offenses: &mut Vec<Offense>) {
         let Some(list) = call.field("arguments") else {
             continue;
         };
-        for argument in named_children(list) {
+        for argument in named_children_of(list, context) {
             if let Some(offense) = coercion(argument, &context_name, context, &locals) {
                 offenses.push(offense);
             }

data/src/rules/lint/regexp_source.rs

@@ -11,9 +11,9 @@ use tree_sitter::Node;
 
 use crate::rules::RuleContext;
 use crate::rules::node_ext::NodeExt;
-use crate::rules::send_node::named_children;
 
 use super::regexp_tree::{self, Tree};
+use crate::rules::send_node::named_children_of;
 
 /// A regexp literal, parsed.
 pub(super) struct Pattern {
@@ -48,7 +48,7 @@ pub(super) fn parse(node: Node<'_>, context: &RuleContext<'_>) -> Option<Pattern
     let mut blanked = String::with_capacity(body.end - body.start);
     let mut interpolations = Vec::new();
     let mut cursor = body.start;
-    for child in named_children(node) {
+    for child in named_children_of(node, context) {
         if child.kind_str() != "interpolation" {
             continue;
         }

data/src/rules/lint/require_range_parentheses.rs

@@ -13,6 +13,7 @@ use crate::rules::RuleContext;
 use crate::rules::node_ext::NodeExt;
 
 use super::statements::{holds_statements, statements};
+use crate::rules::send_node::all_children_iter;
 
 pub(super) fn check(context: &RuleContext<'_>, offenses: &mut Vec<Offense>) {
     for node in context.nodes_of("range") {
@@ -53,9 +54,9 @@ pub(super) fn check(context: &RuleContext<'_>, offenses: &mut Vec<Offense>) {
 }
 
 /// `node.loc.operator`.
-fn operator<'tree>(node: Node<'tree>, context: &RuleContext<'_>) -> Option<Node<'tree>> {
-    let mut cursor = node.walk();
-    node.children(&mut cursor)
+fn operator<'tree>(node: Node<'tree>, context: &'tree RuleContext<'_>) -> Option<Node<'tree>> {
+    let _cursor = node.walk();
+    all_children_iter(node, context)
         .find(|child| !child.is_named() && matches!(context.source.node_text(*child), ".." | "..."))
 }
 
@@ -106,8 +107,7 @@ fn innermost<'tree>(node: Node<'tree>) -> Node<'tree> {
     let mut current = node;
     loop {
         let mut cursor = current.walk();
-        let first = current
-            .named_children(&mut cursor)
+        let first = current.named_children(&mut cursor)
             .find(|child| !skippable(*child));
         match first {
             Some(child) => current = child,

data/src/rules/lint/rescue_exception.rs

@@ -2,6 +2,7 @@ use super::rescue_clause::{body, const_name, end};
 use crate::diagnostic::Offense;
 use crate::rules::RuleContext;
 use crate::rules::node_ext::NodeExt;
+use crate::rules::send_node::named_children_of;
 
 const MSG: &str =
     "Avoid rescuing the `Exception` class. Perhaps you meant to rescue `StandardError`?";
@@ -11,9 +12,9 @@ pub(super) fn check(context: &RuleContext<'_>, offenses: &mut Vec<Offense>) {
         let Some(exceptions) = node.field("exceptions") else {
             continue;
         };
-        let mut cursor = exceptions.walk();
-        let targets_exception = exceptions
-            .named_children(&mut cursor)
+        let _cursor = exceptions.walk();
+        let targets_exception = named_children_of(exceptions, context)
+            .into_iter()
             .any(|exception| const_name(exception, context.source).as_deref() == Some("Exception"));
         if !targets_exception {
             continue;

data/src/rules/lint/rescue_type.rs

@@ -5,6 +5,7 @@ use crate::rules::RuleContext;
 
 use super::literals::literal_type;
 use crate::rules::node_ext::NodeExt;
+use crate::rules::send_node::named_children_iter;
 
 /// `INVALID_TYPES`: the literals that name a value rather than a class, so that `rescue` raises a
 /// `TypeError` when it tries to match against them.
@@ -21,8 +22,8 @@ pub(super) fn check(context: &RuleContext<'_>, offenses: &mut Vec<Offense>) {
         let Some(list) = clause.field("exceptions") else {
             continue;
         };
-        let mut cursor = list.walk();
-        let exceptions: Vec<Node<'_>> = list.named_children(&mut cursor).collect();
+        let _cursor = list.walk();
+        let exceptions: Vec<Node<'_>> = named_children_iter(list, context).collect();
         let invalid: Vec<&Node<'_>> = exceptions
             .iter()
             .filter(|exception| is_invalid(**exception, context))