sonicop 26.8.112 → 26.8.113

data/src/rules/gemspec/deprecated_attribute_assignment.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::push_named_children;
-use crate::rules::send_node::{arguments, is_plain_send, named_children, top_level_constant};
+use crate::rules::{push_named_children_in};
+use crate::rules::send_node::{arguments, is_plain_send, top_level_constant};
 use crate::rules::support::whole_lines;
+use crate::rules::send_node::named_children_of;
 
 /// The attributes RubyGems deprecated, in the order upstream tries them. The order is what the cop
 /// reports, and it is also load-bearing for `+=`: see [`deprecated_attribute`].
@@ -87,7 +88,7 @@ fn is_specification(call: Node<'_>, context: &RuleContext<'_>) -> bool {
 /// has. A destructured `|(a, b)|` yields `(a, b)`, which no receiver can be written as.
 fn block_parameter<'a>(call: Node<'_>, context: &'a RuleContext<'_>) -> Option<&'a str> {
     let parameters = call.field("block")?.field("parameters")?;
-    let first = named_children(parameters).first().copied()?;
+    let first = named_children_of(parameters, context).first().copied()?;
     Some(context.source.node_text(first))
 }
 
@@ -100,15 +101,15 @@ fn block_parameter<'a>(call: Node<'_>, context: &'a RuleContext<'_>) -> Option<&
 fn first_deprecated<'tree>(
     call: Node<'tree>,
     parameter: &str,
-    context: &RuleContext<'_>,
+    context: &'tree RuleContext<'_>,
 ) -> Option<(Node<'tree>, &'static str)> {
     let mut stack = Vec::new();
-    push_named_children(call, &mut stack);
+    push_named_children_in(call, context, &mut stack);
     while let Some(node) = stack.pop() {
         if let Some(attribute) = deprecated_attribute(node, parameter, context) {
             return Some((node, attribute));
         }
-        push_named_children(node, &mut stack);
+        push_named_children_in(node, context, &mut stack);
     }
     None
 }

data/src/rules/gemspec/duplicated_assignment.rs

@@ -2,12 +2,13 @@ use tree_sitter::Node;
 
 use crate::diagnostic::Offense;
 use crate::rules::RuleContext;
-use crate::rules::send_node::{first_line_range, is_plain_send, literal_key, named_children};
+use crate::rules::send_node::{first_line_range, is_plain_send, literal_key};
 
 use super::support::{
     enclosing_specification, first_specification_variable, is_literal, is_specification_receiver,
 };
 use crate::rules::node_ext::NodeExt;
+use crate::rules::send_node::named_children_of;
 
 /// The specification block an assignment was made in, and the target it named. Two assignments
 /// are duplicates of one another only when both agree.
@@ -30,7 +31,7 @@ pub(super) fn check(context: &RuleContext<'_>, offenses: &mut Vec<Offense>) {
         };
         // `spec.a, spec.b = 1, 2` assigns through one node per target.
         let targets = match left.kind_str() {
-            "left_assignment_list" => named_children(left),
+            "left_assignment_list" => named_children_of(left, context),
             _ => vec![left],
         };
         for target in targets {
@@ -92,7 +93,7 @@ fn assignment<'tree>(
                 return None;
             }
             let method = context.source.node_text(object.field("method")?);
-            let indices = named_children(target);
+            let indices = named_children_of(target, context);
             let [index] = indices.get(1..)? else {
                 return None;
             };

data/src/rules/gemspec/require_mfa.rs

@@ -5,13 +5,14 @@ use tree_sitter::Node;
 use crate::diagnostic::{Edit, Offense};
 use crate::rules::RuleContext;
 use crate::rules::node_ext::NodeExt;
-use crate::rules::push_named_children;
+use crate::rules::{push_named_children_in};
 use crate::rules::send_node::{
     has_interpolation, is_plain_send, is_string, named_children, pair_key_symbol, string_text,
     symbol_name,
 };
 
 use super::support::{local_variables, specification_variable};
+use crate::rules::send_node::named_children_of;
 
 const KEY: &str = "rubygems_mfa_required";
 const MSG: &str = "`metadata['rubygems_mfa_required']` must be set to `'true'`.";
@@ -41,7 +42,7 @@ fn specifications_within<'a>(block: Node<'_>, context: &'a RuleContext<'_>) -> V
         if let Some(variable) = specification_variable(node, context) {
             found.push(variable);
         }
-        push_named_children(node, &mut stack);
+        push_named_children_in(node, context, &mut stack);
     }
     found
 }
@@ -84,7 +85,7 @@ fn report(
 fn metadata_value<'tree>(
     block: Node<'tree>,
     locals: &HashSet<&str>,
-    context: &RuleContext<'_>,
+    context: &'tree RuleContext<'_>,
 ) -> Option<Node<'tree>> {
     let mut stack = vec![block];
     while let Some(node) = stack.pop() {
@@ -102,7 +103,7 @@ fn metadata_value<'tree>(
                 return node.field("right");
             }
         }
-        push_named_children(node, &mut stack);
+        push_named_children_in(node, context, &mut stack);
     }
     None
 }
@@ -111,7 +112,7 @@ fn metadata_value<'tree>(
 /// hash gives the `rubygems_mfa_required` key.
 fn mfa_value<'tree>(
     metadata: Option<Node<'tree>>,
-    context: &RuleContext<'_>,
+    context: &'tree RuleContext<'_>,
 ) -> Option<Node<'tree>> {
     let metadata = metadata?;
     if is_string(metadata, context) {
@@ -122,7 +123,7 @@ fn mfa_value<'tree>(
         if node.kind_str() == "pair" && is_mfa_pair(node, context) {
             return node.field("value");
         }
-        push_named_children(node, &mut stack);
+        push_named_children_in(node, context, &mut stack);
     }
     None
 }
@@ -139,7 +140,7 @@ fn insertion(
         // `correct_metadata`: a new pair goes after the last one, or between the braces of an empty
         // hash. Metadata assigned anything other than a hash literal cannot be corrected at all.
         Some(hash) if hash.kind_str() == "hash" => {
-            let pairs: Vec<Node<'_>> = named_children(hash)
+            let pairs: Vec<Node<'_>> = named_children_of(hash, context)
                 .into_iter()
                 .filter(|child| child.kind_str() == "pair")
                 .collect();
@@ -183,7 +184,7 @@ fn insertion(
 fn last_metadata_assignment<'tree>(
     block: Node<'tree>,
     locals: &HashSet<&str>,
-    context: &RuleContext<'_>,
+    context: &'tree RuleContext<'_>,
 ) -> Option<Node<'tree>> {
     let mut last = None;
     let mut stack = vec![block];
@@ -196,7 +197,7 @@ fn last_metadata_assignment<'tree>(
         {
             last = Some(node);
         }
-        push_named_children(node, &mut stack);
+        push_named_children_in(node, context, &mut stack);
     }
     last
 }

data/src/rules/gemspec/required_ruby_version.rs

@@ -6,6 +6,7 @@ use crate::rules::send_node::{
     FILE_KEYWORD, arguments, is_plain_send, is_string, named_children, string_text,
 };
 use crate::rules::node_ext::NodeExt;
+use crate::rules::send_node::named_children_of;
 
 pub(super) fn check(context: &RuleContext<'_>, offenses: &mut Vec<Offense>) {
     let assignments: Vec<Node<'_>> = context
@@ -66,7 +67,7 @@ fn dynamic_version(node: Node<'_>, context: &RuleContext<'_>) -> bool {
     {
         return true;
     }
-    named_children(node)
+    named_children_of(node, context)
         .into_iter()
         .any(|child| dynamic_descendant(child, context))
 }
@@ -74,7 +75,7 @@ fn dynamic_version(node: Node<'_>, context: &RuleContext<'_>) -> bool {
 fn dynamic_descendant(node: Node<'_>, context: &RuleContext<'_>) -> bool {
     is_variable(node, context)
         || is_send(node, context)
-        || named_children(node)
+        || named_children_of(node, context)
             .into_iter()
             .any(|child| dynamic_descendant(child, context))
 }

data/src/rules/gemspec/support.rs

@@ -8,7 +8,8 @@ use crate::rules::RuleContext;
 use crate::rules::lint::blocks::BlockArgs;
 use crate::rules::lint::locals::LocalVariables;
 use crate::rules::node_ext::NodeExt;
-use crate::rules::send_node::{arguments, named_children, top_level_constant};
+use crate::rules::send_node::named_children_of;
+use crate::rules::send_node::{arguments, top_level_constant};
 
 /// The block parameter of `Gem::Specification.new do |spec|`, or `None` when the call is not one.
 ///
@@ -38,7 +39,7 @@ pub(super) fn specification_variable<'a>(
         return None;
     }
     let parameters = call.field("block")?.field("parameters")?;
-    match named_children(parameters).as_slice() {
+    match named_children_of(parameters, context).as_slice() {
         [only] if only.kind_str() == "identifier" => Some(context.source.node_text(*only)),
         _ => None,
     }

data/src/rules/layout/array_alignment.rs

@@ -101,8 +101,7 @@ fn inspect(
 /// `node.children`, where a run of `key: value` pairs is a single `hash` value upstream.
 fn elements(node: Node<'_>) -> Vec<Range<usize>> {
     let mut cursor = node.walk();
-    let children: Vec<Node<'_>> = node
-        .named_children(&mut cursor)
+    let children: Vec<Node<'_>> = node.named_children(&mut cursor)
         .filter(|child| !matches!(child.kind_str(), "comment" | "heredoc_body"))
         .collect();
     let mut elements = Vec::new();

data/src/rules/layout/block_end_newline.rs

@@ -8,6 +8,7 @@ use super::support::{begins_its_line, heredoc_terminators};
 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>) {
     let text = context.source.text();
@@ -108,9 +109,9 @@ fn last_heredoc_argument(
     let terminators = heredoc_terminators(context);
     loop {
         if let Some(list) = argument_list(node) {
-            let mut cursor = list.walk();
-            let found = list
-                .named_children(&mut cursor)
+            let _cursor = list.walk();
+            let found = named_children_of(list, context)
+                .into_iter()
                 .filter(|child| child.kind_str() == "heredoc_beginning")
                 .filter_map(|child| plain_heredoc(context, &bodies, &terminators, child))
                 .last();
@@ -131,8 +132,7 @@ fn body_call<'tree>(block: Node<'tree>) -> Option<Node<'tree>> {
         matches!(child.kind_str(), "body_statement" | "block_body") && child.named_child_count() > 0
     })?;
     let mut cursor = body.walk();
-    let statements: Vec<Node<'tree>> = body
-        .named_children(&mut cursor)
+    let statements: Vec<Node<'tree>> = body.named_children(&mut cursor)
         .filter(|child| !matches!(child.kind_str(), "comment" | "heredoc_body"))
         .collect();
     match statements.as_slice() {

data/src/rules/layout/class_structure.rs

@@ -8,6 +8,8 @@ use crate::rules::lint::access_modifier::send_name;
 use crate::rules::node_ext::NodeExt;
 use crate::rules::send_node::{arguments, named_children, symbol_name};
 use crate::rules::visibility::{node_visibility, siblings, statements};
+use crate::rules::send_node::all_children_iter;
+use crate::rules::send_node::named_children_iter;
 
 pub(super) fn check(context: &RuleContext<'_>, offenses: &mut Vec<Offense>) {
     let expected: Vec<String> = context.setting("ExpectedOrder").unwrap_or_default();
@@ -204,7 +206,7 @@ fn is_private_constant(node: Node<'_>, context: &RuleContext<'_>) -> bool {
     let Some(parent) = node.parent_of(context) else {
         return false;
     };
-    named_children(parent).into_iter().any(|sibling| {
+    named_children_iter(parent, context).any(|sibling| {
         sibling.kind_str() == "call"
             && sibling
                 .field("method")
@@ -358,8 +360,8 @@ fn is_upstream_send(node: Node<'_>, context: &RuleContext<'_>) -> bool {
 }
 
 fn operator_text<'a>(node: Node<'_>, context: &'a RuleContext<'_>) -> Option<&'a str> {
-    let mut cursor = node.walk();
-    node.children(&mut cursor)
+    let _cursor = node.walk();
+    all_children_iter(node, context)
         .find(|child| !child.is_named())
         .map(|child| context.source.node_text(child))
 }

data/src/rules/layout/closing_heredoc_indentation.rs

@@ -7,6 +7,7 @@ use crate::rules::RuleContext;
 
 use super::support::is_send_like;
 use crate::rules::node_ext::NodeExt;
+use crate::rules::send_node::named_children_of;
 
 pub(super) fn check(context: &RuleContext<'_>, offenses: &mut Vec<Offense>) {
     let openers: Vec<Node<'_>> = context.nodes_of("heredoc_beginning").collect();
@@ -25,9 +26,9 @@ pub(super) fn check(context: &RuleContext<'_>, offenses: &mut Vec<Offense>) {
         if heredoc_type(&text[opener.byte_range()]) == Some("<<") {
             continue;
         }
-        let mut cursor = body.walk();
-        let Some(delimiter) = body
-            .named_children(&mut cursor)
+        let _cursor = body.walk();
+        let Some(delimiter) = named_children_of(body, context)
+            .into_iter()
             .find(|child| child.kind_str() == "heredoc_end")
         else {
             continue;

data/src/rules/layout/closing_parenthesis_indentation.rs

@@ -153,8 +153,7 @@ fn delimited<'tree>(node: Node<'tree>) -> Option<Delimited<'tree>> {
         "call" => grouped(node),
         _ => {
             let mut cursor = container.walk();
-            container
-                .named_children(&mut cursor)
+            container.named_children(&mut cursor)
                 .filter(|child| !matches!(child.kind_str(), "comment" | "heredoc_body"))
                 .map(|child| (child.start_byte(), hash_parts(child)))
                 .collect()

data/src/rules/layout/condition_position.rs

@@ -5,6 +5,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;
 
 pub(super) fn check(context: &RuleContext<'_>, offenses: &mut Vec<Offense>) {
     // The modifier forms and the ternary have their own node kinds here, so reaching one of these
@@ -54,8 +55,8 @@ fn removal(context: &RuleContext<'_>, node: Node<'_>, condition: Node<'_>) -> Ed
     let body = node.field("consequence").or_else(|| node.field("body"));
     let body_start = body
         .and_then(|body| {
-            let mut cursor = body.walk();
-            body.named_children(&mut cursor)
+            let _cursor = body.walk();
+            named_children_iter(body, context)
                 .find(|child| !matches!(child.kind_str(), "comment" | "heredoc_body"))
         })
         .map(|first| first.start_byte());

data/src/rules/layout/def_end_alignment.rs

@@ -6,7 +6,7 @@ use tree_sitter::Node;
 
 use super::support::{effective_character_column, end_keyword, end_keyword_alignment};
 use crate::diagnostic::Offense;
-use crate::rules::{RuleContext, push_named_children};
+use crate::rules::{RuleContext, push_named_children_in};
 use crate::rules::node_ext::NodeExt;
 
 pub(super) fn check(context: &RuleContext<'_>, offenses: &mut Vec<Offense>) {
@@ -63,7 +63,7 @@ pub(super) fn check(context: &RuleContext<'_>, offenses: &mut Vec<Offense>) {
             }
             _ => {}
         }
-        push_named_children(node, &mut stack);
+        push_named_children_in(node, context, &mut stack);
     }
 }
 

data/src/rules/layout/dot_position.rs

@@ -136,8 +136,7 @@ fn last_heredoc(heredocs: &[(usize, Range<usize>)], receiver: Node<'_>) -> Optio
     }
     let arguments = receiver.field("arguments")?;
     let mut cursor = arguments.walk();
-    arguments
-        .named_children(&mut cursor)
+    arguments.named_children(&mut cursor)
         .filter(|argument| argument.kind_str() == "heredoc_beginning")
         .filter_map(|argument| terminator_of(argument.start_byte()))
         .max_by_key(|terminator| terminator.end)

data/src/rules/layout/empty_line_after_guard_clause.rs

@@ -215,8 +215,7 @@ fn if_branch<'tree>(node: Node<'tree>) -> Option<Node<'tree>> {
             // A `then` clause holding more than one statement is a `begin` upstream, which is
             // never a guard clause.
             let mut cursor = branch.walk();
-            let mut statements = branch
-                .named_children(&mut cursor)
+            let mut statements = branch.named_children(&mut cursor)
                 .filter(|child| !matches!(child.kind_str(), "heredoc_body" | "comment"));
             let first = statements.next()?;
             statements.next().is_none().then_some(first)
@@ -279,8 +278,7 @@ fn next_statement<'tree>(node: Node<'tree>) -> Option<(Node<'tree>, bool)> {
         _ => return None,
     };
     let mut cursor = parent.walk();
-    let statements: Vec<Node<'tree>> = parent
-        .named_children(&mut cursor)
+    let statements: Vec<Node<'tree>> = parent.named_children(&mut cursor)
         .filter(|child| {
             !matches!(
                 child.kind_str(),
@@ -382,8 +380,7 @@ fn is_and(text: &str, node: Node<'_>) -> bool {
 
 fn call_arguments<'tree>(node: Node<'tree>) -> Vec<Node<'tree>> {
     let mut cursor = node.walk();
-    let Some(list) = node
-        .children(&mut cursor)
+    let Some(list) = node.children(&mut cursor)
         .find(|child| child.kind_str() == "argument_list")
     else {
         return Vec::new();

data/src/rules/layout/empty_line_after_multiline_condition.rs

@@ -5,8 +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::named_children;
 use crate::rules::support;
+use crate::rules::send_node::named_children_of;
 
 const MSG: &str = "Use empty line after multiline condition.";
 
@@ -98,11 +98,11 @@ fn block_delimiters(node: Node<'_>) -> Option<Range<usize>> {
 /// `on_case`: each `when` whose own list of conditions spans more than one line.
 fn when_branches(node: Node<'_>, context: &RuleContext<'_>) -> Vec<Offense> {
     let mut offenses = Vec::new();
-    for branch in named_children(node) {
+    for branch in named_children_of(node, context) {
         if branch.kind_str() != "when" {
             continue;
         }
-        let conditions: Vec<Node<'_>> = named_children(branch)
+        let conditions: Vec<Node<'_>> = named_children_of(branch, context)
             .into_iter()
             .filter(|child| child.kind_str() == "pattern")
             .collect();
@@ -123,7 +123,7 @@ fn when_branches(node: Node<'_>, context: &RuleContext<'_>) -> Vec<Offense> {
 
 /// `on_rescue`: each `resbody` that names more than one exception across more than one line.
 fn rescue_branch(node: Node<'_>, context: &RuleContext<'_>) -> Option<Offense> {
-    let exceptions = named_children(node.field("exceptions")?);
+    let exceptions = named_children_of(node.field("exceptions")?, context);
     // `multiline_rescue_exceptions?`: one exception is never enough.
     if exceptions.len() <= 1 {
         return None;
@@ -170,7 +170,7 @@ fn next_statement<'tree>(
     if !CONTAINERS.contains(&parent.kind_str()) {
         return None;
     }
-    let siblings: Vec<Node<'_>> = named_children(parent)
+    let siblings: Vec<Node<'_>> = named_children_of(parent, context)
         .into_iter()
         .filter(|child| child.kind_str() != "comment")
         .collect();

data/src/rules/layout/empty_lines_around_access_modifier.rs

@@ -23,7 +23,7 @@ pub(super) fn check(context: &RuleContext<'_>, offenses: &mut Vec<Offense>) {
     // RuboCop keeps the enclosing class and block on instance variables that its callbacks fill in
     // as the walk reaches them, so what a modifier sees is whatever was visited last -- never
     // unwound on the way back out. A single pre-order pass reproduces that.
-    walk_named(context.root_node(), &mut |node| match node.kind_str() {
+    walk_named(context.root_node(), context, &mut |node| match node.kind_str() {
         "class" => {
             let header = node
                 .field("superclass")
@@ -270,8 +270,7 @@ fn enclosing_body<'tree>(node: Node<'tree>) -> Option<Body<'tree>> {
         return None;
     }
     let mut cursor = container.walk();
-    let statements: Vec<Node<'tree>> = container
-        .named_children(&mut cursor)
+    let statements: Vec<Node<'tree>> = container.named_children(&mut cursor)
         .filter(|child| !matches!(child.kind_str(), "rescue" | "ensure" | "else"))
         .collect();
     let wrapped_in_begin = statements.len() > 1;

data/src/rules/layout/empty_lines_around_arguments.rs

@@ -84,7 +84,7 @@ fn send_view(context: &RuleContext<'_>, node: Node<'_>) -> Option<SendView> {
         "call" => {
             // An attribute write is one `:name=` send spanning the assignment, so the call on its
             // own is not what upstream inspects.
-            if is_assignment_target(node) {
+            if is_assignment_target(node, context) {
                 return None;
             }
             let list = child_of_kind(node, "argument_list");
@@ -100,7 +100,7 @@ fn send_view(context: &RuleContext<'_>, node: Node<'_>) -> Option<SendView> {
             })
         }
         "element_reference" => {
-            if is_assignment_target(node) {
+            if is_assignment_target(node, context) {
                 return None;
             }
             let bracket = child_of_kind(node, "[")?;
@@ -161,8 +161,8 @@ fn selector<'tree>(node: Node<'tree>) -> Option<Node<'tree>> {
         .filter(|method| !method.byte_range().is_empty())
 }
 
-fn is_assignment_target(node: Node<'_>) -> bool {
-    node.parent().is_some_and(|parent| {
+fn is_assignment_target(node: Node<'_>, context: &RuleContext<'_>) -> bool {
+    context.parent(node).is_some_and(|parent| {
         parent.kind_str() == "assignment" && parent.field("left") == Some(node)
     })
 }

data/src/rules/layout/empty_lines_around_exception_handling_keywords.rs

@@ -98,8 +98,7 @@ fn body_clauses<'tree>(node: Node<'tree>) -> Vec<Node<'tree>> {
         },
     };
     let mut cursor = container.walk();
-    container
-        .named_children(&mut cursor)
+    container.named_children(&mut cursor)
         .filter(|child| matches!(child.kind_str(), "rescue" | "else" | "ensure"))
         .collect()
 }

data/src/rules/layout/empty_lines_around_method_body.rs

@@ -6,6 +6,7 @@ use super::empty_lines_around_body::{Target, body_container, body_of, check as c
 use crate::diagnostic::{Edit, Offense};
 use crate::rules::RuleContext;
 use crate::rules::node_ext::NodeExt;
+use crate::rules::send_node::all_children_iter;
 
 pub(super) fn check(context: &RuleContext<'_>, offenses: &mut Vec<Offense>) {
     let mut targets = Vec::new();
@@ -45,8 +46,8 @@ fn check_endless(context: &RuleContext<'_>, node: Node<'_>, offenses: &mut Vec<O
     let Some(body) = node.field("body") else {
         return;
     };
-    let mut cursor = node.walk();
-    let Some(assignment) = node.children(&mut cursor).find(|child| child.kind_str() == "=") else {
+    let _cursor = node.walk();
+    let Some(assignment) = all_children_iter(node, context).find(|child| child.kind_str() == "=") else {
         return;
     };
     let assignment_line = assignment.start_position().row + 1;

data/src/rules/layout/end_alignment.rs

@@ -11,7 +11,7 @@ use super::support::{
 };
 use crate::diagnostic::Offense;
 use crate::rules::node_ext::NodeExt;
-use crate::rules::{RuleContext, push_named_children};
+use crate::rules::{RuleContext, push_named_children_in};
 
 /// `EnforcedStyleAlignWith`.
 #[derive(Clone, Copy, Eq, PartialEq)]
@@ -42,7 +42,7 @@ pub(super) fn check(context: &RuleContext<'_>, offenses: &mut Vec<Offense>) {
     let mut stack = vec![context.root_node()];
     while let Some(node) = stack.pop() {
         checker.visit(node, offenses);
-        push_named_children(node, &mut stack);
+        push_named_children_in(node, context, &mut stack);
     }
 }
 

data/src/rules/layout/extra_spacing.rs

@@ -19,6 +19,7 @@ use super::tokens::{Token, tokens};
 use crate::diagnostic::{Edit, Offense};
 use crate::rules::RuleContext;
 use crate::rules::node_ext::NodeExt;
+use crate::rules::send_node::named_children_of;
 
 const MSG_UNNECESSARY: &str = "Unnecessary spacing detected.";
 const MSG_UNALIGNED_ASGN: &str = "`=` is not aligned with the preceding assignment.";
@@ -246,7 +247,7 @@ fn aligned_comment_lines(context: &RuleContext<'_>) -> HashSet<usize> {
 fn ignored_ranges(context: &RuleContext<'_>) -> Vec<Range<usize>> {
     let mut ranges = Vec::new();
     for elements in hash_literals(context) {
-        let Some(span) = hash_span(&elements) else {
+        let Some(span) = hash_span(&elements, context) else {
             continue;
         };
         if context.source.line_column(span.start).0 == context.source.line_column(span.end).0 {
@@ -265,10 +266,10 @@ fn ignored_ranges(context: &RuleContext<'_>) -> Vec<Range<usize>> {
 /// Where the `hash` node upstream builds for these elements begins and ends. A braced literal is a
 /// node of its own, whose braces count towards `single_line?`; a brace-less one is only the run of
 /// pairs the parser folded together.
-fn hash_span(elements: &[Node<'_>]) -> Option<Range<usize>> {
+fn hash_span(elements: &[Node<'_>], context: &RuleContext<'_>) -> Option<Range<usize>> {
     let first = elements.first()?;
     let last = elements.last()?;
-    match first.parent().filter(|parent| parent.kind_str() == "hash") {
+    match context.parent(*first).filter(|parent| parent.kind_str() == "hash") {
         Some(hash) => Some(hash.byte_range()),
         None => Some(first.start_byte()..last.end_byte()),
     }
@@ -287,8 +288,8 @@ fn previous_character(text: &str, offset: usize) -> Option<usize> {
 /// nothing but comments.
 fn is_blank(context: &RuleContext<'_>) -> bool {
     let root = context.root_node();
-    let mut cursor = root.walk();
-    !root
-        .named_children(&mut cursor)
+    let _cursor = root.walk();
+    !named_children_of(root, context)
+        .into_iter()
         .any(|child| child.kind_str() != "comment")
 }

data/src/rules/layout/first_array_element_indentation.rs

@@ -100,8 +100,7 @@ fn inspect(
 /// first element spans the whole run rather than just its first pair.
 fn first_element<'tree>(array: Node<'tree>) -> Option<(Range<usize>, Option<Node<'tree>>)> {
     let mut cursor = array.walk();
-    let children: Vec<Node<'tree>> = array
-        .named_children(&mut cursor)
+    let children: Vec<Node<'tree>> = array.named_children(&mut cursor)
         .filter(|child| !matches!(child.kind_str(), "comment" | "heredoc_body"))
         .collect();
     let first = *children.first()?;

data/src/rules/layout/first_hash_element_indentation.rs

@@ -11,6 +11,8 @@ use super::support::{
 use crate::diagnostic::Offense;
 use crate::rules::RuleContext;
 use crate::rules::node_ext::NodeExt;
+use crate::rules::send_node::named_children_of;
+use crate::rules::send_node::all_children_of;
 
 pub(super) fn check(context: &RuleContext<'_>, offenses: &mut Vec<Offense>) {
     let style: String = context
@@ -93,9 +95,9 @@ fn first_pair<'tree>(hash: Node<'tree>) -> Option<Node<'tree>> {
 }
 
 fn separator_style(context: &RuleContext<'_>, first: Node<'_>) -> bool {
-    let mut cursor = first.walk();
-    let rocket = first
-        .children(&mut cursor)
+    let _cursor = first.walk();
+    let rocket = all_children_of(first, context)
+        .into_iter()
         .any(|child| child.kind_str() == "=>");
     let key = if rocket {
         "EnforcedHashRocketStyle"
@@ -109,9 +111,9 @@ fn separator_style(context: &RuleContext<'_>, first: Node<'_>) -> bool {
 }
 
 fn longest_key_overhang(context: &RuleContext<'_>, hash: Node<'_>) -> i64 {
-    let mut cursor = hash.walk();
-    let lengths: Vec<i64> = hash
-        .named_children(&mut cursor)
+    let _cursor = hash.walk();
+    let lengths: Vec<i64> = named_children_of(hash, context)
+        .into_iter()
         .filter(|child| child.kind_str() == "pair")
         .filter_map(|pair| pair.field("key"))
         .map(|key| context.source.text()[key.byte_range()].chars().count() as i64)

data/src/rules/layout/hash_alignment.rs

@@ -9,6 +9,7 @@ use super::support::{Edits, begins_its_line, hash_literals};
 use crate::diagnostic::{Edit, Offense};
 use crate::rules::RuleContext;
 use crate::rules::node_ext::NodeExt;
+use crate::rules::send_node::named_children_iter;
 
 const KEY_MESSAGE: &str = "Align the keys of a hash literal if they span more than one line.";
 const SEPARATOR_MESSAGE: &str =
@@ -648,10 +649,9 @@ fn ignored_last_argument(elements: &[Node<'_>], context: &RuleContext<'_>, style
     let is_last_argument = match list.kind_str() {
         // `on_send`, `on_csend`, `on_super` and `on_yield`: an array literal is none of them.
         "argument_list" | "element_reference" => {
-            let mut cursor = list.walk();
-            list.named_children(&mut cursor)
-                .filter(|child| !matches!(child.kind_str(), "comment" | "heredoc_body"))
-                .last()
+            let _cursor = list.walk();
+            named_children_iter(list, context)
+                .rfind(|child| !matches!(child.kind_str(), "comment" | "heredoc_body"))
                 .is_some_and(|node| node.id() == wanted.id())
         }
         // `x.foo = { … }` and `x[k] = { … }` are `send :foo=` and `send :[]=` to upstream's