sonicop 26.8.112 → 26.8.113

data/src/rules/lint/return_in_void_context.rs

@@ -2,8 +2,8 @@ use tree_sitter::Node;
 
 use crate::diagnostic::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;
 
 /// `SCOPE_CHANGING_METHODS`: a block handed to one of these gives the `return` a scope of its own.
 const SCOPE_CHANGING_METHODS: [&str; 3] = ["lambda", "define_method", "define_singleton_method"];
@@ -14,7 +14,7 @@ const COMPARISON_METHODS: [&str; 5] = ["==", "===", "!=", "<=", ">="];
 pub(super) fn check(context: &RuleContext<'_>, offenses: &mut Vec<Offense>) {
     for node in context.nodes_of("return") {
         // `return_node.descendants.any?`: a bare `return` hands back nothing to discard.
-        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/safe_navigation_chain.rs

@@ -5,11 +5,12 @@ 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};
+use crate::rules::send_node::{arguments, is_plain_send};
 
 use super::nil_methods::nil_methods;
 use super::node_equality;
 use crate::rules::node_ext::NodeExt;
+use crate::rules::send_node::named_children_of;
 
 const MSG: &str = "Do not chain ordinary method call after safe navigation operator.";
 
@@ -129,7 +130,7 @@ fn read_chain<'tree>(node: Node<'tree>, context: &'tree RuleContext<'_>) -> Opti
             (node.field("operand")?, method, None, Vec::new())
         }
         _ => {
-            let children = named_children(node);
+            let children = named_children_of(node, context);
             (
                 *children.first()?,
                 "[]".to_owned(),

data/src/rules/lint/self_assignment.rs

@@ -7,6 +7,7 @@ use crate::rules::send_node::{arguments, named_children, send_range};
 use super::locals::LocalVariables;
 use super::node_equality::identical;
 use crate::rules::node_ext::NodeExt;
+use crate::rules::send_node::named_children_of;
 
 const MSG: &str = "Self-assignment detected.";
 
@@ -224,10 +225,10 @@ fn multiple_self_assignment(left: Node<'_>, right: Node<'_>, context: &RuleConte
     // `rhs.array_type?`. `a, b = c` hands over one value rather than a list, and `a, b = *c` builds
     // an array holding a `splat`, which is no variable read.
     let values = match right.kind_str() {
-        "right_assignment_list" | "array" => named_children(right),
+        "right_assignment_list" | "array" => named_children_of(right, context),
         _ => return false,
     };
-    let targets = named_children(left);
+    let targets = named_children_of(left, context);
     targets.len() == values.len()
         && targets.iter().zip(&values).all(|(target, value)| {
             VARIABLE_KINDS.contains(&target.kind_str())

data/src/rules/lint/shadowed_argument.rs

@@ -2,10 +2,10 @@ use tree_sitter::Node;
 
 use crate::diagnostic::Offense;
 use crate::rules::RuleContext;
-use crate::rules::send_node::named_children;
 
 use super::variable_force::{Analysis, Assignment, Declaration, Scope, Variable};
 use crate::rules::node_ext::NodeExt;
+use crate::rules::send_node::named_children_of;
 
 /// The scope kinds `method_argument?` and `block_argument?` accept: a `def`, a `defs`, and the
 /// `block` a literal lambda is one of.
@@ -172,7 +172,7 @@ fn uses_variable(
     {
         return true;
     }
-    named_children(node)
+    named_children_of(node, context)
         .into_iter()
         .any(|child| uses_variable(child, name, analysis, context))
 }

data/src/rules/lint/shadowed_exception.rs

@@ -5,11 +5,11 @@ use tree_sitter::Node;
 
 use crate::diagnostic::Offense;
 use crate::rules::RuleContext;
-use crate::rules::send_node::named_children;
 
 use super::exception_hierarchy::{compare, is_exception, is_system_call_error, resolve};
 use super::rescue_clause;
 use crate::rules::node_ext::NodeExt;
+use crate::rules::send_node::named_children_of;
 
 const MSG: &str = "Do not shadow rescued Exceptions.";
 
@@ -60,7 +60,7 @@ fn evaluate_exceptions(clause: Node<'_>, context: &RuleContext<'_>) -> Group {
     let Some(list) = clause.field("exceptions") else {
         return vec![resolve("StandardError")];
     };
-    let listed: Vec<Node<'_>> = named_children(list);
+    let listed: Vec<Node<'_>> = named_children_of(list, context);
     if listed.is_empty() {
         return vec![resolve("StandardError")];
     }

data/src/rules/lint/suppressed_exception_in_number_conversion.rs

@@ -4,9 +4,10 @@ use crate::diagnostic::{Edit, Offense};
 use crate::ruby_version::RubyVersion;
 use crate::rules::RuleContext;
 use crate::rules::node_ext::NodeExt;
-use crate::rules::send_node::{arguments, named_children, pair_key_symbol, top_level_constant};
+use crate::rules::send_node::{arguments, pair_key_symbol, top_level_constant};
 
 use super::statements::statements;
+use crate::rules::send_node::named_children_of;
 
 /// `EXPECTED_EXCEPTION_CLASSES`: the two the conversion itself raises.
 const EXPECTED_EXCEPTION_CLASSES: [&str; 4] = [
@@ -32,7 +33,7 @@ pub(super) fn check(context: &RuleContext<'_>, offenses: &mut Vec<Offense>) {
     }
     // `begin Integer(x) rescue [classes]; [nil] end`, which the parser keeps as a `kwbegin`.
     for node in context.nodes_of("begin") {
-        let children = named_children(node);
+        let children = named_children_of(node, context);
         let [body, clause] = children.as_slice() else {
             continue;
         };
@@ -135,7 +136,7 @@ fn expected_exception_classes_only(clause: Node<'_>, context: &RuleContext<'_>)
     let Some(exceptions) = clause.field("exceptions") else {
         return true;
     };
-    named_children(exceptions)
+    named_children_of(exceptions, context)
         .into_iter()
         .filter(|child| child.kind_str() != "comment")
         .all(|exception| EXPECTED_EXCEPTION_CLASSES.contains(&context.source.node_text(exception)))

data/src/rules/lint/symbol_conversion.rs

@@ -3,7 +3,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::{has_interpolation, named_children, string_text, symbol_name};
+use crate::rules::send_node::{has_interpolation, string_text, symbol_name};
+use crate::rules::send_node::named_children_of;
 
 pub(super) fn check(context: &RuleContext<'_>, offenses: &mut Vec<Offense>) {
     let consistent = context
@@ -24,7 +25,7 @@ pub(super) fn check(context: &RuleContext<'_>, offenses: &mut Vec<Offense>) {
         // pairs directly under the argument list. `on_hash` therefore has a second structural
         // spelling here even though no braces were written.
         for list in context.nodes_of("argument_list") {
-            let keys: Vec<Node<'_>> = named_children(list)
+            let keys: Vec<Node<'_>> = named_children_of(list, context)
                 .into_iter()
                 .filter(|child| child.kind_str() == "pair")
                 .filter_map(|pair| pair.field("key"))
@@ -76,8 +77,8 @@ fn conversion_correction(receiver: Node<'_>, context: &RuleContext<'_>) -> Optio
         // was written and strips the quotes around every part.
         "chained_string" => {
             let mut out = String::from(":\"");
-            for part in named_children(receiver) {
-                for inner in named_children(part) {
+            for part in named_children_of(receiver, context) {
+                for inner in named_children_of(part, context) {
                     out.push_str(context.source.node_text(inner));
                 }
             }
@@ -181,7 +182,7 @@ fn inconsistent_keys(
     hash: Node<'_>,
     ignored: &mut Vec<usize>,
 ) {
-    let keys: Vec<Node<'_>> = named_children(hash)
+    let keys: Vec<Node<'_>> = named_children_of(hash, context)
         .into_iter()
         .filter(|child| child.kind_str() == "pair")
         .filter_map(|pair| pair.field("key"))

data/src/rules/lint/syntax.rs

@@ -6,6 +6,7 @@ use crate::diagnostic::Offense;
 use crate::ruby_version::RubyVersion;
 use crate::rules::RuleContext;
 use crate::rules::node_ext::NodeExt;
+use crate::rules::send_node::named_children_of;
 
 /// The first Ruby version whose grammar accepts each construct.
 ///
@@ -170,9 +171,9 @@ fn multiline_array_pattern(error: Node<'_>, context: &RuleContext<'_>) -> bool {
 /// the body where the interpolation still is, and never finds the terminator.
 fn opens_heredoc_in_interpolation(context: &RuleContext<'_>) -> bool {
     context.nodes_of("interpolation").any(|interpolation| {
-        let mut cursor = interpolation.walk();
-        interpolation
-            .named_children(&mut cursor)
+        let _cursor = interpolation.walk();
+        named_children_of(interpolation, context)
+            .into_iter()
             .any(|child| child.kind_str() == "heredoc_beginning")
     })
 }

data/src/rules/lint/triple_quotes.rs

@@ -3,13 +3,14 @@ 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>) {
     // `on_dstr`: the only `dstr` written as one literal per quote is the run of adjacent literals
     // the grammar keeps as a `chained_string`.
     for node in context.nodes_of("chained_string") {
-        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();
         let mut empty: Vec<Node<'_>> = children
             .iter()
             .copied()

data/src/rules/lint/unescaped_bracket_in_regexp.rs

@@ -128,7 +128,7 @@ fn holds_interpolation(node: Node<'_>, context: &RuleContext<'_>) -> bool {
         if interpolates && current.id() != node.id() {
             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/unexpected_block_arity.rs

@@ -8,6 +8,7 @@ use crate::rules::node_ext::NodeExt;
 
 use super::blocks::BlockArgs;
 use super::locals::LocalVariables;
+use crate::rules::send_node::all_children_iter;
 
 pub(super) fn check(context: &RuleContext<'_>, offenses: &mut Vec<Offense>) {
     let Some(methods) = context.setting::<BTreeMap<String, usize>>("Methods") else {
@@ -55,8 +56,8 @@ fn arg_count(
         });
     };
     let mut count = 0;
-    let mut cursor = parameters.walk();
-    for parameter in parameters.children(&mut cursor) {
+    let _cursor = parameters.walk();
+    for parameter in all_children_iter(parameters, context) {
         // `{ |a; b| }`: what follows the `;` is a block-local variable. Upstream's parser never
         // puts it among the arguments; the grammar keeps it in the same node.
         if parameter.kind_str() == ";" {

data/src/rules/lint/unmodified_reduce_accumulator.rs

@@ -8,6 +8,7 @@ use crate::rules::send_node::{arguments, named_children};
 use super::blocks::{BLOCK_KINDS, BlockArgs};
 use super::locals::LocalVariables;
 use super::statements::statements;
+use crate::rules::send_node::named_children_of;
 
 pub(super) fn check(context: &RuleContext<'_>, offenses: &mut Vec<Offense>) {
     let locals = LocalVariables::new(context);
@@ -58,7 +59,7 @@ fn argument_list(parameters: &[Node<'_>], context: &RuleContext<'_>) -> Vec<Stri
     let mut names = Vec::new();
     for parameter in parameters {
         if parameter.kind_str() == "destructured_parameter" {
-            names.extend(argument_list(&named_children(*parameter), context));
+            names.extend(argument_list(&named_children_of(*parameter, context), context));
             continue;
         }
         let node = parameter.field("name").unwrap_or(*parameter);
@@ -128,7 +129,7 @@ fn return_values<'tree>(
         {
             values.push(argument);
         }
-        crate::rules::push_named_children(node, &mut stack);
+        crate::rules::push_named_children_in(node, context, &mut stack);
     }
     values
 }
@@ -230,7 +231,7 @@ fn lvar_used(node: Node<'_>, name: &str, context: &RuleContext<'_>) -> bool {
         }
         // `(dstr (begin (lvar %1)))`: a string holding nothing but the variable.
         "string" => {
-            let parts: Vec<Node<'_>> = named_children(node)
+            let parts: Vec<Node<'_>> = named_children_of(node, context)
                 .into_iter()
                 .filter(|child| child.kind_str() != "comment")
                 .collect();
@@ -260,7 +261,7 @@ fn element_modified(body: Node<'_>, element: &str, context: &RuleContext<'_>) ->
         if modifies_element(node, element, context) {
             return true;
         }
-        crate::rules::push_named_children(node, &mut stack);
+        crate::rules::push_named_children_in(node, context, &mut stack);
     }
     false
 }
@@ -330,7 +331,7 @@ fn holds_lvar(node: Node<'_>, name: &str, context: &RuleContext<'_>) -> bool {
         if is_lvar_named(current, name, context) {
             return true;
         }
-        crate::rules::push_named_children(current, &mut stack);
+        crate::rules::push_named_children_in(current, context, &mut stack);
     }
     false
 }
@@ -377,7 +378,7 @@ fn expression_values(node: Node<'_>, context: &RuleContext<'_>) -> Vec<String> {
         let method = (current.kind_str() == "call")
             .then(|| current.field("method"))
             .flatten();
-        for child in named_children(current) {
+        for child in named_children_of(current, context) {
             if method.is_some_and(|method| method.id() == child.id()) {
                 continue;
             }

data/src/rules/lint/unreachable_pattern_branch.rs

@@ -4,16 +4,17 @@ use crate::diagnostic::Offense;
 use crate::ruby_version::RubyVersion;
 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>) {
     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 catch_all_found = false;
         let mut else_clause = None;
-        for branch in case.named_children(&mut cursor) {
+        for branch in named_children_iter(case, context) {
             match branch.kind_str() {
                 "else" => else_clause = Some(branch),
                 "in_clause" => {
@@ -59,8 +60,7 @@ fn is_catch_all(pattern: Node<'_>) -> bool {
         "parenthesized_pattern" => pattern.named_child(0).is_some_and(is_catch_all),
         "alternative_pattern" => {
             let mut cursor = pattern.walk();
-            pattern
-                .named_children(&mut cursor)
+            pattern.named_children(&mut cursor)
                 .any(|alternative| is_catch_all(alternative))
         }
         _ => false,

data/src/rules/lint/unused_block_argument.rs

@@ -68,7 +68,7 @@ fn message(
         .filter(|variable| block_argument(variable, scope))
         .collect();
     let none_referenced = !arguments.iter().any(|argument| argument.referenced);
-    let augmentation = if is_lambda(scope.node, context.source) {
+    let augmentation = if is_lambda(scope.node, context.source, context.ast_index()) {
         let mut message = underscore_message(name);
         if none_referenced {
             message.push_str(
@@ -77,7 +77,7 @@ fn message(
             );
         }
         message
-    } else if none_referenced && block_method(scope.node, context.source) != Some("define_method") {
+    } else if none_referenced && block_method(scope.node, context.source, context.ast_index()) != Some("define_method") {
         if arguments.len() > 1 {
             "You can omit all the arguments if you don't care about them.".to_owned()
         } else {

data/src/rules/lint/unused_method_argument.rs

@@ -86,8 +86,7 @@ fn method_body(node: Node<'_>) -> Option<MethodBody<'_>> {
         });
     }
     let mut cursor = body.walk();
-    let statements: Vec<Node<'_>> = body
-        .named_children(&mut cursor)
+    let statements: Vec<Node<'_>> = body.named_children(&mut cursor)
         .filter(|child| !NOT_A_STATEMENT.contains(&child.kind_str()))
         .collect();
     match statements.len() {

data/src/rules/lint/useless_assignment.rs

@@ -11,6 +11,7 @@ use crate::diagnostic::{Edit, Offense};
 use crate::rules::RuleContext;
 use crate::rules::node_ext::NodeExt;
 use crate::rules::support::spurious_assignment_list;
+use crate::rules::send_node::named_children_of;
 
 pub(super) fn check(context: &RuleContext<'_>, offenses: &mut Vec<Offense>) {
     let analysis = context.variable_analysis();
@@ -143,7 +144,7 @@ fn variable_like_invocation(
     match node.kind_str() {
         // A bare name standing where a value is read is a `send` upstream unless it resolved to a
         // local, and a read of a local is an `lvar` that contributes nothing of its own here.
-        "identifier" if is_variable_read(node) && !analysis.is_variable_reference(node) => {
+        "identifier" if is_variable_read(node, context.ast_index()) && !analysis.is_variable_reference(node) => {
             Some(context.source.node_text(node).to_owned())
         }
         "call" => {
@@ -354,7 +355,7 @@ fn reads_name(node: Node<'_>, name: &str, context: &RuleContext<'_>) -> bool {
                 .is_some_and(|method| method.id() == node.id());
         return !target && !method;
     }
-    named_children(node)
+    named_children_of(node, context)
         .into_iter()
         .any(|child| reads_name(child, name, context))
 }

data/src/rules/lint/useless_constant_scoping.rs

@@ -3,9 +3,10 @@ use tree_sitter::Node;
 use crate::diagnostic::Offense;
 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::send_node::{arguments, string_text, symbol_name};
 
 use super::access_modifier::{bare_access_modifier, send_name};
+use crate::rules::send_node::named_children_of;
 
 pub(super) fn check(context: &RuleContext<'_>, offenses: &mut Vec<Offense>) {
     for node in context.nodes_of("assignment") {
@@ -15,7 +16,7 @@ pub(super) fn check(context: &RuleContext<'_>, offenses: &mut Vec<Offense>) {
         let Some(parent) = node.parent_of(context) else {
             continue;
         };
-        let siblings = named_children(parent);
+        let siblings = named_children_of(parent, context);
         let Some(position) = siblings
             .iter()
             .position(|sibling| sibling.id() == node.id())

data/src/rules/lint/useless_else_without_rescue.rs

@@ -2,6 +2,7 @@ use crate::diagnostic::Offense;
 use crate::ruby_version::RubyVersion;
 use crate::rules::RuleContext;
 use crate::rules::node_ext::NodeExt;
+use crate::rules::send_node::named_children_of;
 
 const MSG: &str = "`else` without `rescue` is useless.";
 
@@ -24,9 +25,9 @@ pub(super) fn check(context: &RuleContext<'_>, offenses: &mut Vec<Offense>) {
         if !matches!(body.kind_str(), "begin" | "body_statement" | "block_body") {
             continue;
         }
-        let mut cursor = body.walk();
-        if body
-            .named_children(&mut cursor)
+        let _cursor = body.walk();
+        if named_children_of(body, context)
+            .into_iter()
             .any(|child| child.kind_str() == "rescue")
         {
             continue;

data/src/rules/lint/useless_rescue.rs

@@ -3,9 +3,10 @@ use tree_sitter::Node;
 use crate::diagnostic::Offense;
 use crate::rules::RuleContext;
 use crate::rules::node_ext::NodeExt;
-use crate::rules::send_node::{arguments, named_children};
+use crate::rules::send_node::arguments;
 
 use super::statements::statements;
+use crate::rules::send_node::named_children_of;
 
 pub(super) fn check(context: &RuleContext<'_>, offenses: &mut Vec<Offense>) {
     for node in context.nodes_of("rescue") {
@@ -23,7 +24,7 @@ fn is_last_branch(node: Node<'_>, context: &RuleContext<'_>) -> bool {
         return true;
     };
     let mut seen = false;
-    for sibling in named_children(parent) {
+    for sibling in named_children_of(parent, context) {
         if sibling.id() == node.id() {
             seen = true;
             continue;
@@ -92,7 +93,7 @@ fn uses_exception_variable_in_ensure(
     let Some(parent) = node.parent_of(context) else {
         return false;
     };
-    let Some(ensure_clause) = named_children(parent)
+    let Some(ensure_clause) = named_children_of(parent, context)
         .into_iter()
         .find(|child| child.kind_str() == "ensure")
     else {
@@ -100,7 +101,7 @@ fn uses_exception_variable_in_ensure(
     };
     let analysis = context.variable_analysis();
     let mut found = false;
-    crate::rules::walk_named(ensure_clause, &mut |inner| {
+    crate::rules::walk_named(ensure_clause, context, &mut |inner| {
         if found || inner.kind_str() != "identifier" || context.source.node_text(inner) != variable
         {
             return;

data/src/rules/lint/useless_ruby2_keywords.rs

@@ -4,6 +4,7 @@ use crate::diagnostic::Offense;
 use crate::rules::RuleContext;
 use crate::rules::node_ext::NodeExt;
 use crate::rules::send_node::{arguments, named_children, symbol_name};
+use crate::rules::send_node::named_children_of;
 
 pub(super) fn check(context: &RuleContext<'_>, offenses: &mut Vec<Offense>) {
     for node in context.nodes_of("call") {
@@ -60,7 +61,7 @@ fn find_method_definition<'tree>(
 ) -> Option<Option<Node<'tree>>> {
     let mut current = node.parent_of(context);
     while let Some(ancestor) = current {
-        for child in named_children(ancestor) {
+        for child in named_children_of(ancestor, context) {
             if let Some(parameters) = definition_parameters(child, name, context) {
                 return Some(parameters);
             }

data/src/rules/lint/useless_setter_call.rs

@@ -4,12 +4,13 @@ use tree_sitter::Node;
 
 use crate::diagnostic::{Edit, Offense};
 use crate::rules::RuleContext;
-use crate::rules::send_node::named_children;
 
 use super::literals::is_literal;
 use super::locals::LocalVariables;
 use super::statements::body_children;
 use crate::rules::node_ext::NodeExt;
+use crate::rules::send_node::named_children_of;
+use crate::rules::send_node::named_children_iter;
 
 /// `ASSIGNMENT_TYPES`: the variable kinds the tracker follows. A constant is deliberately missing.
 const ASSIGNMENT_TARGETS: &[&str] = &[
@@ -106,7 +107,7 @@ impl Tracker {
         if self.process_assignment_node(node, context, locals) {
             return;
         }
-        for child in named_children(node) {
+        for child in named_children_of(node, context) {
             self.scan(child, context, locals);
         }
     }
@@ -168,11 +169,11 @@ impl Tracker {
     ) {
         let listed = matches!(right.kind_str(), "right_assignment_list" | "array");
         let values = if listed {
-            named_children(right)
+            named_children_of(right, context)
         } else {
             Vec::new()
         };
-        for (index, target) in named_children(targets).into_iter().enumerate() {
+        for (index, target) in named_children_iter(targets, context).enumerate() {
             if !ASSIGNMENT_TARGETS.contains(&target.kind_str()) {
                 continue;
             }

data/src/rules/lint/useless_times.rs

@@ -9,6 +9,7 @@ use super::locals::LocalVariables;
 use super::ranges::whole_lines;
 use super::statements::statements;
 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 locals = LocalVariables::new(context);
@@ -66,7 +67,7 @@ fn block_pass_symbol<'a>(node: Node<'_>, context: &'a RuleContext<'_>) -> Option
     if node.kind_str() != "block_argument" {
         return None;
     }
-    symbol_name(named_children(node).first().copied()?, context)
+    symbol_name(named_children_of(node, context).first().copied()?, context)
 }
 
 fn correction(
@@ -257,7 +258,7 @@ fn reassigns(node: Node<'_>, name: &str, context: &RuleContext<'_>) -> bool {
     {
         return true;
     }
-    named_children(node)
+    named_children_of(node, context)
         .into_iter()
         .any(|child| reassigns(child, name, context))
 }
@@ -268,7 +269,7 @@ fn assigns_to(left: Node<'_>, name: &str, context: &RuleContext<'_>) -> bool {
         "identifier" => context.source.node_text(left) == name,
         // `i, j = 1, 2` and `(i, j), k = [1, 2], 3` nest their targets.
         "left_assignment_list" | "destructured_left_assignment" | "rest_assignment" => {
-            named_children(left)
+            named_children_of(left, context)
                 .into_iter()
                 .any(|target| assigns_to(target, name, context))
         }