sonicop 26.8.112 → 26.8.113

data/src/rules/lint/ambiguity.rs

@@ -17,7 +17,7 @@ use tree_sitter::Node;
 use crate::diagnostic::Edit;
 use crate::rules::RuleContext;
 use crate::rules::node_ext::NodeExt;
-use crate::rules::send_node::named_children;
+use crate::rules::send_node::named_children_iter;
 
 /// One ambiguity the lexer would have warned about.
 pub(super) struct Ambiguity<'tree> {
@@ -70,7 +70,7 @@ pub(super) fn scan<'tree>(
             continue;
         }
 
-        let Some(first) = named_children(list).into_iter().next() else {
+        let Some(first) = named_children_iter(list, context).next() else {
             continue;
         };
         let text = context.source.node_text(first);

data/src/rules/lint/ambiguous_block_association.rs

@@ -4,6 +4,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::named_children_of;
+use crate::rules::send_node::named_children_iter;
 
 /// The enumerable methods a trailing `do` block was probably meant for.
 const BLOCK_METHODS: &[&str] = &[
@@ -84,7 +86,7 @@ fn check_brace_block_argument(
     let Some(arguments) = node.field("arguments") else {
         return;
     };
-    let list = named_children(arguments);
+    let list = named_children_of(arguments, context);
     let (Some(&first), Some(&last)) = (list.first(), list.last()) else {
         return;
     };
@@ -173,7 +175,7 @@ fn check_do_block(
     let Some(arguments) = call.field("arguments") else {
         return;
     };
-    let Some(&last) = named_children(arguments).last() else {
+    let Some(&last) = named_children_of(arguments, context).last() else {
         return;
     };
     if parenthesized(call, arguments, context) {
@@ -202,7 +204,7 @@ fn check_do_block(
 fn trailing_block_method<'tree>(
     node: Node<'tree>,
     end: usize,
-    context: &RuleContext<'_>,
+    context: &'tree RuleContext<'_>,
 ) -> Option<Node<'tree>> {
     let mut stack = vec![node];
     while let Some(current) = stack.pop() {
@@ -214,18 +216,13 @@ fn trailing_block_method<'tree>(
             return Some(current);
         }
         let start = stack.len();
-        let mut cursor = current.walk();
-        stack.extend(current.named_children(&mut cursor));
+        let _cursor = current.walk();
+        stack.extend(named_children_iter(current, context));
         stack[start..].reverse();
     }
     None
 }
 
-fn named_children<'tree>(node: Node<'tree>) -> Vec<Node<'tree>> {
-    let mut cursor = node.walk();
-    node.named_children(&mut cursor).collect()
-}
-
 /// The block written on a call, which upstream holds one level above the call instead.
 fn block_of(node: Node<'_>) -> Option<Node<'_>> {
     (node.kind_str() == "call")

data/src/rules/lint/ambiguous_regexp_literal.rs

@@ -5,6 +5,8 @@ use crate::rules::RuleContext;
 use crate::rules::node_ext::NodeExt;
 
 use super::ambiguity::scan;
+use crate::rules::send_node::named_children_of;
+use crate::rules::send_node::named_children_iter;
 
 const MSG: &str = "Ambiguous regexp literal. Parenthesize the method arguments if it's surely a \
      regexp literal, or add a whitespace to the right of the `/` if it should be a division.";
@@ -31,8 +33,8 @@ fn matches_a_static_regexp(owner: Node<'_>, context: &RuleContext<'_>) -> bool {
     let Some(arguments) = owner.field("arguments") else {
         return false;
     };
-    let mut cursor = arguments.walk();
-    let Some(first) = arguments.named_children(&mut cursor).next() else {
+    let _cursor = arguments.walk();
+    let Some(first) = named_children_iter(arguments, context).next() else {
         return false;
     };
     if first.kind_str() != "binary"
@@ -47,9 +49,9 @@ fn matches_a_static_regexp(owner: Node<'_>, context: &RuleContext<'_>) -> bool {
         .field("left")
         .filter(|left| left.kind_str() == "regex")
         .is_some_and(|left| {
-            let mut cursor = left.walk();
-            !left
-                .named_children(&mut cursor)
+            let _cursor = left.walk();
+            !named_children_of(left, context)
+                .into_iter()
                 .any(|part| part.kind_str() == "interpolation")
         })
 }

data/src/rules/lint/array_literal_in_regexp.rs

@@ -3,9 +3,10 @@ use tree_sitter::Node;
 use crate::diagnostic::{Edit, Offense};
 use crate::rules::RuleContext;
 use crate::rules::node_ext::NodeExt;
-use crate::rules::send_node::{has_interpolation, named_children, string_text, symbol_name};
+use crate::rules::send_node::{has_interpolation, string_text, symbol_name};
 
 use super::node_equality::numeric_value;
+use crate::rules::send_node::named_children_of;
 
 const MSG_CHARACTER_CLASS: &str =
     "Use a character class instead of interpolating an array in a regexp.";
@@ -21,7 +22,7 @@ pub(super) fn check(context: &RuleContext<'_>, offenses: &mut Vec<Offense>) {
         {
             continue;
         }
-        let Some(array) = named_children(node)
+        let Some(array) = named_children_of(node, context)
             .into_iter()
             .rfind(|child| child.kind_str() != "comment")
             // `%w[…]` and `%i[…]` are `array` nodes upstream. The grammar gives each percent form
@@ -30,7 +31,7 @@ pub(super) fn check(context: &RuleContext<'_>, offenses: &mut Vec<Offense>) {
         else {
             continue;
         };
-        let elements: Vec<Node<'_>> = named_children(array)
+        let elements: Vec<Node<'_>> = named_children_of(array, context)
             .into_iter()
             .filter(|child| child.kind_str() != "comment")
             .collect();

data/src/rules/lint/assignment_in_condition.rs

@@ -6,6 +6,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_iter;
 
 const MSG_WITH_SAFE_ASSIGNMENT_ALLOWED: &str = "Use `==` if you meant to do a comparison or wrap the expression in parentheses to \
      indicate you meant to assign in a condition.";
@@ -191,8 +192,8 @@ fn traverse(
         }
         Shape::Other => {}
     }
-    let mut cursor = node.walk();
-    let children: Vec<Node<'_>> = node.named_children(&mut cursor).collect();
+    let _cursor = node.walk();
+    let children: Vec<Node<'_>> = named_children_iter(node, context).collect();
     for child in children {
         traverse(child, context, allow_safe, reported, offenses);
     }

data/src/rules/lint/blocks.rs

@@ -14,6 +14,7 @@ use crate::rules::send_node::named_children;
 
 use super::locals::LocalVariables;
 use crate::rules::node_ext::NodeExt;
+use crate::rules::send_node::named_children_of;
 
 /// The kinds tree-sitter writes a block as. A `lambda` is `-> { }`, which upstream also reaches
 /// through `on_block`.
@@ -87,7 +88,7 @@ fn scan(
     highest: &mut usize,
     it: &mut bool,
 ) {
-    for child in named_children(node) {
+    for child in named_children_of(node, context) {
         if BLOCK_KINDS.contains(&child.kind_str()) || child.kind_str() == "lambda" {
             continue;
         }

data/src/rules/lint/boolean_symbol.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_iter;
 
 /// The node kinds a `sym` reaches tree-sitter as. A `%i[]` element is a `bare_symbol` instead,
 /// which is how the percent literal upstream exempts stays exempt.
@@ -53,8 +54,8 @@ fn boolean_name<'a>(node: Node<'_>, context: &'a RuleContext<'_>) -> Option<&'a
 
 /// The text between the quotes, when that is all there is between them.
 fn quoted_content<'a>(node: Node<'_>, context: &'a RuleContext<'_>) -> Option<&'a str> {
-    let mut cursor = node.walk();
-    let parts: Vec<Node<'_>> = node.named_children(&mut cursor).collect();
+    let _cursor = node.walk();
+    let parts: Vec<Node<'_>> = named_children_iter(node, context).collect();
     match parts.as_slice() {
         [content] if content.kind_str() == "string_content" => Some(context.source.node_text(*content)),
         _ => None,
@@ -68,8 +69,7 @@ fn colon_pair(pair: Node<'_>) -> bool {
 
 fn separator(pair: Node<'_>) -> Option<Node<'_>> {
     let mut cursor = pair.walk();
-    let separator = pair
-        .children(&mut cursor)
+    let separator = pair.children(&mut cursor)
         .find(|child| !child.is_named() && matches!(child.kind_str(), ":" | "=>"))?;
     Some(separator)
 }

data/src/rules/lint/constant_definition_in_block.rs

@@ -43,8 +43,7 @@ fn enclosing_block(node: Node<'_>) -> Option<Node<'_>> {
     // statements one level further down again -- so nothing in such a block is written directly in
     // it any more.
     let mut cursor = body.walk();
-    if body
-        .named_children(&mut cursor)
+    if body.named_children(&mut cursor)
         .any(|child| matches!(child.kind_str(), "rescue" | "else" | "ensure"))
     {
         return None;

data/src/rules/lint/constant_reassignment.rs

@@ -7,6 +7,7 @@ use crate::rules::RuleContext;
 use crate::rules::node_ext::NodeExt;
 use crate::rules::send_node::{arguments, named_children, string_text, symbol_name};
 use crate::rules::support::spurious_assignment_list;
+use crate::rules::send_node::named_children_of;
 
 /// The parts of a constant path, as `each_path` walks them.
 struct ConstantPath {
@@ -45,7 +46,7 @@ pub(super) fn check(context: &RuleContext<'_>, offenses: &mut Vec<Offense>) {
             },
             _ => namespaces.clone(),
         };
-        let mut children = named_children(node);
+        let mut children = named_children_of(node, context);
         children.reverse();
         for child in children {
             stack.push((child, inner.clone()));

data/src/rules/lint/deprecated_open_ssl_constant.rs

@@ -223,7 +223,6 @@ fn sanitize_arguments(
 /// `loc.double_colon`: the `::` the name was written after.
 fn separator<'tree>(receiver: Node<'tree>, name: Node<'_>) -> Option<Node<'tree>> {
     let mut cursor = receiver.walk();
-    receiver
-        .children(&mut cursor)
+    receiver.children(&mut cursor)
         .find(|child| !child.is_named() && child.end_byte() <= name.start_byte())
 }

data/src/rules/lint/disjunctive_assignment_in_constructor.rs

@@ -2,8 +2,8 @@ use tree_sitter::Node;
 
 use crate::diagnostic::{Edit, Offense};
 use crate::rules::RuleContext;
-use crate::rules::send_node::named_children;
 use crate::rules::node_ext::NodeExt;
+use crate::rules::send_node::named_children_of;
 
 const MSG: &str = "Unnecessary disjunctive assignment. Use plain assignment.";
 
@@ -20,7 +20,7 @@ pub(super) fn check(context: &RuleContext<'_>, offenses: &mut Vec<Offense>) {
         };
         // A body with a `rescue` or an `ensure` is one node of that type upstream rather than the
         // `begin` this walks, so the very first line already fails the `or_asgn` test.
-        let lines = named_children(body);
+        let lines = named_children_of(body, context);
         if lines
             .iter()
             .any(|line| matches!(line.kind_str(), "rescue" | "ensure" | "else"))

data/src/rules/lint/duplicate_branch.rs

@@ -5,10 +5,11 @@ use tree_sitter::Node;
 use crate::diagnostic::Offense;
 use crate::rules::RuleContext;
 use crate::rules::node_ext::NodeExt;
-use crate::rules::send_node::named_children;
 
 use super::node_equality::identical;
 use super::statements::{body_children, statements};
+use crate::rules::send_node::named_children_of;
+use crate::rules::send_node::named_children_iter;
 
 /// One branch, with what upstream would report it at.
 struct Branch<'tree> {
@@ -53,7 +54,7 @@ pub(super) fn check(context: &RuleContext<'_>, offenses: &mut Vec<Offense>) {
     // `on_rescue`: the clauses of one body, which the grammar keeps as siblings rather than under
     // a node of their own.
     for container in context.nodes_of_any(&["begin", "body_statement", "block_body", "do"]) {
-        let clauses: Vec<Node<'_>> = named_children(container)
+        let clauses: Vec<Node<'_>> = named_children_of(container, context)
             .into_iter()
             .filter(|child| matches!(child.kind_str(), "rescue" | "else"))
             .collect();
@@ -135,8 +136,8 @@ fn branches<'tree>(node: Node<'tree>, context: &'tree RuleContext<'_>) -> Vec<Br
     let mut collected = Vec::new();
     match node.kind_str() {
         "case" | "case_match" => {
-            let mut cursor = node.walk();
-            for clause in node.named_children(&mut cursor) {
+            let _cursor = node.walk();
+            for clause in named_children_iter(node, context) {
                 match clause.kind_str() {
                     "when" | "in_clause" => collected.push(Branch {
                         nodes: clause.field("body").map(statements).unwrap_or_default(),
@@ -235,7 +236,7 @@ fn is_literal_branch(
         return true;
     }
     let mut all = true;
-    crate::rules::walk_named(only, &mut |node| {
+    crate::rules::walk_named(only, context, &mut |node| {
         if node.id() == only.id() || !all {
             return;
         }

data/src/rules/lint/duplicate_case_condition.rs

@@ -5,15 +5,16 @@ use crate::rules::RuleContext;
 
 use super::node_equality::identical;
 use crate::rules::node_ext::NodeExt;
+use crate::rules::send_node::named_children_of;
 
 const MSG: &str = "Duplicate `when` condition detected.";
 
 pub(super) fn check(context: &RuleContext<'_>, offenses: &mut Vec<Offense>) {
     for case in context.nodes_of("case") {
         let mut seen: Vec<Node<'_>> = Vec::new();
-        let mut cursor = case.walk();
-        let branches: Vec<Node<'_>> = case
-            .named_children(&mut cursor)
+        let _cursor = case.walk();
+        let branches: Vec<Node<'_>> = named_children_of(case, context)
+            .into_iter()
             .filter(|child| child.kind_str() == "when")
             .collect();
         for branch in branches {
@@ -35,8 +36,7 @@ pub(super) fn check(context: &RuleContext<'_>, offenses: &mut Vec<Offense>) {
 /// condition, so what upstream reports is the node inside it.
 fn conditions<'tree>(branch: Node<'tree>) -> Vec<Node<'tree>> {
     let mut cursor = branch.walk();
-    branch
-        .named_children(&mut cursor)
+    branch.named_children(&mut cursor)
         .filter(|child| child.kind_str() == "pattern")
         .filter_map(|pattern| pattern.named_child(0))
         .collect()

data/src/rules/lint/duplicate_hash_key.rs

@@ -6,6 +6,7 @@ use crate::rules::RuleContext;
 use super::literals::{is_constant, recursive_basic_literal};
 use super::node_equality::equality_key;
 use crate::rules::node_ext::NodeExt;
+use crate::rules::send_node::named_children_of;
 
 const MSG: &str = "Duplicated key in hash literal.";
 
@@ -14,10 +15,10 @@ pub(super) fn check(context: &RuleContext<'_>, offenses: &mut Vec<Offense>) {
     // the argument list, so a call's keyword arguments are no hash node here -- and every duplicate
     // written that way went unreported.
     for hash in context.nodes_of_any(&["hash", "argument_list"]) {
-        let mut cursor = hash.walk();
+        let _cursor = hash.walk();
         // `HashNode#keys`: a `**splat` entry is no pair and contributes no key.
-        let keys: Vec<_> = hash
-            .named_children(&mut cursor)
+        let keys: Vec<_> = named_children_of(hash, context)
+            .into_iter()
             .filter(|child| child.kind_str() == "pair")
             .filter_map(|pair| pair.field("key"))
             .filter(|key| recursive_basic_literal(*key, context) || is_constant(*key, context))

data/src/rules/lint/duplicate_match_pattern.rs

@@ -6,15 +6,17 @@ use crate::diagnostic::Offense;
 use crate::rules::RuleContext;
 use crate::rules::node_ext::NodeExt;
 use crate::ruby_version::RubyVersion;
+use crate::rules::send_node::named_children_of;
+use crate::rules::send_node::named_children_iter;
 
 pub(super) fn check(context: &RuleContext<'_>, offenses: &mut Vec<Offense>) {
     if context.target_ruby_version() < RubyVersion::new(2, 7) {
         return;
     }
     for case in context.nodes_of("case_match") {
-        let mut cursor = case.walk();
+        let _cursor = case.walk();
         let mut seen: HashSet<String> = HashSet::new();
-        for branch in case.named_children(&mut cursor) {
+        for branch in named_children_iter(case, context) {
             if branch.kind_str() != "in_clause" {
                 continue;
             }
@@ -52,9 +54,9 @@ fn pattern_identity(branch: Node<'_>, pattern: Node<'_>, context: &RuleContext<'
 /// Upstream builds an alternation of three from an alternation of two, so its children are the run
 /// up to the last alternative and that last one -- not the flat list the grammar keeps.
 fn sorted_parts(pattern: Node<'_>, context: &RuleContext<'_>) -> Vec<String> {
-    let mut cursor = pattern.walk();
-    let parts: Vec<Node<'_>> = pattern
-        .named_children(&mut cursor)
+    let _cursor = pattern.walk();
+    let parts: Vec<Node<'_>> = named_children_of(pattern, context)
+        .into_iter()
         .filter(|child| child.kind_str() != "comment")
         .collect();
     let mut sources: Vec<String> = if pattern.kind_str() == "alternative_pattern" && parts.len() > 2

data/src/rules/lint/duplicate_methods.rs

@@ -8,6 +8,7 @@ use crate::rules::node_ext::NodeExt;
 
 use super::blocks::BlockArgs;
 use super::locals::LocalVariables;
+use crate::rules::send_node::named_children_iter;
 
 pub(super) fn check(context: &RuleContext<'_>, offenses: &mut Vec<Offense>) {
     let mut tracker = Tracker {
@@ -821,9 +822,9 @@ fn literal_arguments(context: &RuleContext<'_>, node: Node<'_>) -> Vec<String> {
     let Some(arguments) = node.field("arguments") else {
         return Vec::new();
     };
-    let mut cursor = arguments.walk();
+    let _cursor = arguments.walk();
     let mut names = Vec::new();
-    for argument in arguments.named_children(&mut cursor) {
+    for argument in named_children_iter(arguments, context) {
         match symbol_name(context.source.node_text(argument)) {
             Some(name) if matches!(argument.kind_str(), "simple_symbol" | "string") => {
                 names.push(name.to_owned());
@@ -861,7 +862,7 @@ fn attr_with_writer(node: Node<'_>) -> bool {
 /// `literal_arguments` from answering.
 fn attr_first_name(context: &RuleContext<'_>, node: Node<'_>) -> Option<String> {
     let list = node.field("arguments")?;
-    let first = *crate::rules::send_node::named_children(list).first()?;
+    let first = *crate::rules::send_node::named_children_of(list, context).first()?;
     if !matches!(first.kind_str(), "simple_symbol" | "string") {
         return None;
     }

data/src/rules/lint/duplicate_require.rs

@@ -156,7 +156,6 @@ fn body_parent(container: Node<'_>) -> Parent {
 /// statements it holds.
 fn split_body(container: Node<'_>) -> bool {
     let mut cursor = container.walk();
-    container
-        .named_children(&mut cursor)
+    container.named_children(&mut cursor)
         .any(|child| matches!(child.kind_str(), "rescue" | "else" | "ensure"))
 }

data/src/rules/lint/duplicate_set_element.rs

@@ -6,6 +6,7 @@ use crate::rules::node_ext::NodeExt;
 use crate::rules::send_node::{arguments, named_children};
 
 use super::node_equality::identical;
+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(&["call", "element_reference"]) {
@@ -41,12 +42,12 @@ pub(super) fn check(context: &RuleContext<'_>, offenses: &mut Vec<Offense>) {
 /// `set_init_elements`, paired with the name the message calls the class by.
 fn set_init_elements<'tree>(
     node: Node<'tree>,
-    context: &RuleContext<'_>,
+    context: &'tree RuleContext<'_>,
 ) -> Option<(String, Vec<Node<'tree>>)> {
     if node.kind_str() == "element_reference" {
         let object = node.field("object")?;
         let name = set_class_name(object, context)?;
-        let elements = named_children(node)
+        let elements = named_children_of(node, context)
             .into_iter()
             .filter(|child| child.kind_str() != "comment" && child.id() != object.id())
             .collect();

data/src/rules/lint/empty_conditional_body.rs

@@ -5,6 +5,7 @@ use crate::rules::RuleContext;
 
 use super::statements::statements;
 use crate::rules::node_ext::NodeExt;
+use crate::rules::send_node::all_children_iter;
 
 /// The three conditionals whose branch can be written empty. A modifier form always has a body.
 const CONDITIONALS: &[&str] = &["if", "unless", "elsif"];
@@ -181,7 +182,7 @@ fn enclosing_end<'tree>(node: Node<'tree>, context: &RuleContext<'_>) -> Option<
 /// `node.loc.begin`: the `then` or `;` the branch was introduced with. The grammar puts a `then`
 /// inside the branch it opens, but a `;` stays beside the condition -- and a branch holding nothing
 /// is no node at all, which leaves the `;` as the only trace of it.
-fn then_keyword<'tree>(node: Node<'tree>, context: &RuleContext<'_>) -> Option<Node<'tree>> {
+fn then_keyword<'tree>(node: Node<'tree>, context: &'tree RuleContext<'_>) -> Option<Node<'tree>> {
     if let Some(first) = node
         .field("consequence")
         .and_then(|branch| branch.child(0))
@@ -190,8 +191,8 @@ fn then_keyword<'tree>(node: Node<'tree>, context: &RuleContext<'_>) -> Option<N
         return Some(first);
     }
     let condition = node.field("condition")?;
-    let mut cursor = node.walk();
-    node.children(&mut cursor).find(|child| {
+    let _cursor = node.walk();
+    all_children_iter(node, context).find(|child| {
         child.start_byte() >= condition.end_byte()
             && matches!(context.source.node_text(*child), "then" | ";")
     })

data/src/rules/lint/empty_in_pattern.rs

@@ -11,6 +11,7 @@ use super::comments_help::comment_search_lines;
 use crate::ruby_version::RubyVersion;
 
 use super::statements::statements;
+use crate::rules::send_node::named_children_iter;
 
 const MSG: &str = "Avoid `in` branches without a body.";
 
@@ -20,8 +21,8 @@ pub(super) fn check(context: &RuleContext<'_>, offenses: &mut Vec<Offense>) {
     }
     let allow_comments: bool = context.setting("AllowComments").unwrap_or(true);
     for case in context.nodes_of("case_match") {
-        let mut cursor = case.walk();
-        let children: Vec<Node<'_>> = case.named_children(&mut cursor).collect();
+        let _cursor = case.walk();
+        let children: Vec<Node<'_>> = named_children_iter(case, context).collect();
         for (index, &branch) in children.iter().enumerate() {
             if branch.kind_str() != "in_clause" || has_body(branch) {
                 continue;

data/src/rules/lint/empty_when.rs

@@ -8,14 +8,15 @@ use crate::rules::RuleContext;
 use crate::rules::node_ext::NodeExt;
 
 use super::comments_help::comment_search_lines;
+use crate::rules::send_node::named_children_iter;
 
 const MSG: &str = "Avoid `when` branches without a body.";
 
 pub(super) fn check(context: &RuleContext<'_>, offenses: &mut Vec<Offense>) {
     let allow_comments: bool = context.setting("AllowComments").unwrap_or(true);
     for case in context.nodes_of("case") {
-        let mut cursor = case.walk();
-        let children: Vec<Node<'_>> = case.named_children(&mut cursor).collect();
+        let _cursor = case.walk();
+        let children: Vec<Node<'_>> = named_children_iter(case, context).collect();
         for (index, &branch) in children.iter().enumerate() {
             if branch.kind_str() != "when" || has_body(branch) {
                 continue;
@@ -32,8 +33,7 @@ pub(super) fn check(context: &RuleContext<'_>, offenses: &mut Vec<Offense>) {
 /// the `;` or `then` that separates it from the body it does not have is no part of it.
 fn reported_range(branch: Node<'_>) -> std::ops::Range<usize> {
     let mut cursor = branch.walk();
-    let last = branch
-        .named_children(&mut cursor)
+    let last = branch.named_children(&mut cursor)
         .filter(|child| child.kind_str() == "pattern")
         .last();
     branch.start_byte()..last.map_or_else(|| branch.end_byte(), |last| last.end_byte())

data/src/rules/lint/ensure_return.rs

@@ -5,6 +5,7 @@ use crate::rules::RuleContext;
 
 use super::statements::statements;
 use crate::rules::node_ext::NodeExt;
+use crate::rules::send_node::named_children_iter;
 
 const MSG: &str = "Do not return from an `ensure` block.";
 
@@ -26,8 +27,8 @@ fn collect(
     if node.kind_str() == "return" && !returns_from_inner_scope(node, ensure_node, context) {
         offenses.push(context.offense(MSG, node.byte_range()));
     }
-    let mut cursor = node.walk();
-    let children: Vec<Node<'_>> = node.named_children(&mut cursor).collect();
+    let _cursor = node.walk();
+    let children: Vec<Node<'_>> = named_children_iter(node, context).collect();
     for child in children {
         collect(child, ensure_node, context, offenses);
     }

data/src/rules/lint/float_comparison.rs

@@ -2,8 +2,10 @@ use tree_sitter::Node;
 
 use crate::diagnostic::Offense;
 use crate::rules::RuleContext;
-use crate::rules::send_node::{Argument, arguments, named_children, send_range};
+use crate::rules::send_node::{Argument, arguments, send_range};
 use crate::rules::node_ext::NodeExt;
+use crate::rules::send_node::named_children_of;
+use crate::rules::send_node::named_children_iter;
 
 const MSG_EQUALITY: &str = "Avoid equality comparisons of floats as they are unreliable.";
 const MSG_INEQUALITY: &str = "Avoid inequality comparisons of floats as they are unreliable.";
@@ -52,15 +54,15 @@ pub(super) fn check(context: &RuleContext<'_>, offenses: &mut Vec<Offense>) {
 
 /// `on_case`: every condition of every `when` branch, taken on its own.
 fn case_conditions(node: Node<'_>, context: &RuleContext<'_>, offenses: &mut Vec<Offense>) {
-    for branch in named_children(node) {
+    for branch in named_children_of(node, context) {
         if branch.kind_str() != "when" {
             continue;
         }
-        for pattern in named_children(branch) {
+        for pattern in named_children_of(branch, context) {
             if pattern.kind_str() != "pattern" {
                 continue;
             }
-            let Some(condition) = named_children(pattern).into_iter().next() else {
+            let Some(condition) = named_children_iter(pattern, context).next() else {
                 continue;
             };
             if is_float(condition, context) && !literal_safe(condition, context) {
@@ -110,7 +112,7 @@ fn is_float(node: Node<'_>, context: &RuleContext<'_>) -> bool {
         // The parser folds a sign into the numeric literal it stands before.
         "unary" => signed_numeric(node, context).is_some_and(|operand| operand.kind_str() == "float"),
         "binary" | "call" => float_send(node, context),
-        "parenthesized_statements" => named_children(node)
+        "parenthesized_statements" => named_children_of(node, context)
             .into_iter()
             .next()
             .is_some_and(|first| is_float(first, context)),
@@ -167,7 +169,7 @@ fn literal_safe(node: Node<'_>, context: &RuleContext<'_>) -> bool {
         "nil" => true,
         "integer" | "float" | "rational" | "complex" => is_zero(node, context),
         "unary" => signed_numeric(node, context).is_some_and(|operand| is_zero(operand, context)),
-        "parenthesized_statements" => named_children(node)
+        "parenthesized_statements" => named_children_of(node, context)
             .into_iter()
             .next()
             .is_some_and(|first| literal_safe(first, context)),

data/src/rules/lint/format_parameter_mismatch.rs

@@ -9,6 +9,7 @@ use crate::rules::send_node::{arguments, is_plain_send};
 use super::format_string::{is_valid, parse};
 use super::literals::literal_type;
 use crate::rules::node_ext::NodeExt;
+use crate::rules::send_node::named_children_of;
 
 const MSG_INVALID: &str = "Format string is invalid because formatting sequence types \
      (numbered, named or unnumbered) are mixed.";
@@ -222,9 +223,9 @@ fn count_matches(call: &Call<'_>, context: &RuleContext<'_>) -> Count {
             .is_some_and(|first| first.first.kind_str() == "array")
     {
         let list = call.given[0].first;
-        let mut cursor = list.walk();
-        let passed = list
-            .named_children(&mut cursor)
+        let _cursor = list.walk();
+        let passed = named_children_of(list, context)
+            .into_iter()
             .filter(|child| child.kind_str() != "comment")
             .count();
         let Some(receiver) = call.receiver else {