sonicop 26.8.111 → 26.8.113

data/src/rules/lint/duplicate_methods.rs

@@ -6,9 +6,14 @@ use crate::diagnostic::Offense;
 use crate::rules::RuleContext;
 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 {
         context,
+        locals: LocalVariables::new(context),
         // Only the line of the earlier definition is ever read back, so the node itself does not
         // have to be kept alive alongside the key.
         definitions: HashMap::new(),
@@ -27,6 +32,7 @@ pub(super) fn check(context: &RuleContext<'_>, offenses: &mut Vec<Offense>) {
 
 struct Tracker<'a, 'tree> {
     context: &'a RuleContext<'tree>,
+    locals: LocalVariables<'a, 'tree>,
     definitions: HashMap<String, usize>,
     /// Keys already redefined once inside a `rescue` or `ensure`. A body with such a clause is
     /// allowed one redefinition -- that is how a conditional fallback definition is written -- but
@@ -53,9 +59,7 @@ impl<'a, 'tree> Tracker<'a, 'tree> {
         if has_if_ancestor(node) {
             return;
         }
-        let (Some(name), Some(receiver)) =
-            (self.name_text(node), node.field("object"))
-        else {
+        let (Some(name), Some(receiver)) = (self.name_text(node), node.field("object")) else {
             return;
         };
         match receiver.kind_str() {
@@ -71,10 +75,7 @@ impl<'a, 'tree> Tracker<'a, 'tree> {
     }
 
     fn on_alias(&mut self, node: Node<'_>, offenses: &mut Vec<Offense>) {
-        let (Some(name), Some(original)) = (
-            node.field("name"),
-            node.field("alias"),
-        ) else {
+        let (Some(name), Some(original)) = (node.field("name"), node.field("alias")) else {
             return;
         };
         let (Some(name), Some(original)) = (
@@ -118,6 +119,20 @@ impl<'a, 'tree> Tracker<'a, 'tree> {
                 }
             }
             accessor @ ("attr" | "attr_reader" | "attr_writer" | "attr_accessor") => {
+                // `attr :foo, true` carries a `true` that is no symbol, and `literal_arguments`
+                // answers a call with any such argument with nothing at all. `on_attr` reads only
+                // the first argument of an `attr`, so the name is recovered from that alone.
+                let arguments = match (accessor, arguments.is_empty()) {
+                    ("attr", true) => attr_first_name(self.context, node)
+                        .map(|name| vec![name])
+                        .unwrap_or_default(),
+                    _ => arguments,
+                };
+                // **`found_attr` names each argument through `sym_name`, which answers `nil` for a
+                // `str`.** `attr_reader 'foo'` defines the method all the same, but upstream never
+                // records it -- so pairing it with `attr_reader :foo` reported a duplicate that
+                // upstream is silent about.
+                let arguments: Vec<String> = attr_symbol_names(node, &arguments);
                 if arguments.is_empty() || !in_macro_scope(node) {
                     return;
                 }
@@ -151,8 +166,10 @@ impl<'a, 'tree> Tracker<'a, 'tree> {
         offenses: &mut Vec<Offense>,
     ) {
         let (readable, writable) = match accessor {
-            // `attr :foo, true` is the historical writer form.
-            "attr" => (true, false),
+            // `writable = args.size == 2 && args.last.true_type?`: `attr :foo, true` is the
+            // historical accessor form, and it defines the writer as well. `literal_arguments`
+            // keeps only the symbols, so the `true` has to be read off the call itself.
+            "attr" => (true, attr_with_writer(node)),
             "attr_reader" => (true, false),
             "attr_writer" => (false, true),
             _ => (true, true),
@@ -173,12 +190,13 @@ impl<'a, 'tree> Tracker<'a, 'tree> {
     }
 
     fn found_instance_method(&mut self, node: Node<'_>, name: &str, offenses: &mut Vec<Offense>) {
-        if let Some(scope) = parent_module_name(self.context, node) {
+        if let Some(scope) = parent_module_name(self.context, node, &self.locals) {
             let method = format!("{}{name}", humanize_scope(&scope));
             self.found_method(node, &method, None, offenses);
         } else if let Some(anon_block) = anonymous_class_block(self.context, node) {
-            let base =
-                qualified_object_scope(parent_module_name(self.context, anon_block).as_deref());
+            let base = qualified_object_scope(
+                parent_module_name(self.context, anon_block, &self.locals).as_deref(),
+            );
             let scope = if singleton_class_ancestor(node).is_some() {
                 format!("#<Class:{base}>")
             } else {
@@ -193,11 +211,12 @@ impl<'a, 'tree> Tracker<'a, 'tree> {
     }
 
     fn check_self_receiver(&mut self, node: Node<'_>, name: &str, offenses: &mut Vec<Offense>) {
-        if let Some(enclosing) = parent_module_name(self.context, node) {
+        if let Some(enclosing) = parent_module_name(self.context, node, &self.locals) {
             self.found_method(node, &format!("{enclosing}.{name}"), None, offenses);
         } else if let Some(anon_block) = anonymous_class_block(self.context, node) {
-            let scope =
-                qualified_object_scope(parent_module_name(self.context, anon_block).as_deref());
+            let scope = qualified_object_scope(
+                parent_module_name(self.context, anon_block, &self.locals).as_deref(),
+            );
             let scope_id = anon_block_scope_id(self.context, anon_block);
             self.found_method(node, &format!("{scope}.{name}"), scope_id, offenses);
         }
@@ -212,13 +231,17 @@ impl<'a, 'tree> Tracker<'a, 'tree> {
         let Some(receiver) = sclass.field("value") else {
             return;
         };
-        if receiver.kind_str() != "call" {
-            return;
-        }
-        let Some(method) = receiver.field("method") else {
-            return;
+        // `singleton_receiver_node.send_type?` -- and a bare `blah` **is** a send upstream. The
+        // grammar spells a receiverless call as an `identifier`, so `class << blah` never reached
+        // the check and every method defined in it went unrecorded.
+        let method = match receiver.kind_str() {
+            "call" => match receiver.field("method") {
+                Some(method) => self.text(method).to_owned(),
+                None => return,
+            },
+            "identifier" => self.text(receiver).to_owned(),
+            _ => return,
         };
-        let method = self.text(method).to_owned();
         self.found_method(node, &format!("{method}.{name}"), None, offenses);
     }
 
@@ -261,7 +284,7 @@ impl<'a, 'tree> Tracker<'a, 'tree> {
     }
 
     fn track_self_alias(&mut self, node: Node<'_>, name: &str) {
-        if let Some(scope) = parent_module_name(self.context, node) {
+        if let Some(scope) = parent_module_name(self.context, node, &self.locals) {
             self.self_aliased
                 .insert(format!("{}{name}", humanize_scope(&scope)));
         }
@@ -283,7 +306,7 @@ impl<'a, 'tree> Tracker<'a, 'tree> {
             if let Some(defined) = defined_module_name(self.context, parent) {
                 let bare = defined.rsplit("::").next().unwrap_or(&defined);
                 if bare == const_name.trim_start_matches("::") {
-                    let enclosing = parent_module_name(self.context, parent);
+                    let enclosing = parent_module_name(self.context, parent, &self.locals);
                     return Some(match enclosing.as_deref() {
                         Some("Object") | None => defined,
                         Some(name) => format!("{name}::{defined}"),
@@ -371,7 +394,11 @@ fn rescue_scope(node: Node<'_>) -> Option<&'static str> {
 
 /// The lexical namespace enclosing `node`, or `None` when a block breaks the chain -- a block body
 /// is ordinary code, so what a `def` inside one attaches to cannot be read off the source.
-fn parent_module_name(context: &RuleContext<'_>, node: Node<'_>) -> Option<String> {
+fn parent_module_name(
+    context: &RuleContext<'_>,
+    node: Node<'_>,
+    locals: &LocalVariables<'_, '_>,
+) -> Option<String> {
     let mut parts: Vec<String> = Vec::new();
     let mut current = node;
     while let Some(parent) = current.parent_of(context) {
@@ -381,12 +408,22 @@ fn parent_module_name(context: &RuleContext<'_>, node: Node<'_>) -> Option<Strin
                     parts.push(name);
                 }
             }
-            "singleton_class" => parts.push(singleton_class_name(context, parent)?),
-            "block" | "do_block" => match block_module_name(context, parent) {
-                BlockScope::Transparent => {}
-                BlockScope::Named(name) => parts.push(name),
-                BlockScope::Opaque => return None,
-            },
+            "singleton_class" => parts.push(singleton_class_name(context, parent, locals)?),
+            // `each_ancestor(:class, :module, :sclass, :casgn, :block)` does not list `numblock`
+            // or `itblock`: a block whose parameter is implicit is a different node type upstream,
+            // and the walk passes straight over it. The grammar spells all three as `block`.
+            "block" | "do_block"
+                if matches!(
+                    BlockArgs::of(parent, context, locals),
+                    BlockArgs::Written(_)
+                ) =>
+            {
+                match block_module_name(context, parent) {
+                    BlockScope::Transparent => {}
+                    BlockScope::Named(name) => parts.push(name),
+                    BlockScope::Opaque => return None,
+                }
+            }
             _ => {}
         }
         current = parent;
@@ -417,11 +454,13 @@ fn defined_module_name(context: &RuleContext<'_>, node: Node<'_>) -> Option<Stri
 }
 
 fn constant_name(context: &RuleContext<'_>, node: Node<'_>) -> String {
-    context
-        .source
-        .node_text(node)
-        .trim_start_matches("::")
-        .to_owned()
+    let text = context.source.node_text(node);
+    // `qualified_name` interpolates `namespace.const_name`, and `(self)` has none -- `self::A`
+    // qualifies as `::A`.
+    if let Some(rest) = text.strip_prefix("self::") {
+        return format!("::{rest}");
+    }
+    text.trim_start_matches("::").to_owned()
 }
 
 /// `Class.new`/`Module.new`, optionally carrying a block. `global` demands the bare global
@@ -438,10 +477,7 @@ fn is_class_or_module_new(context: &RuleContext<'_>, node: Node<'_>, global: boo
     if !crate::rules::send_node::is_plain_send(call, context) {
         return false;
     }
-    let (Some(receiver), Some(method)) = (
-        call.field("receiver"),
-        call.field("method"),
-    ) else {
+    let (Some(receiver), Some(method)) = (call.field("receiver"), call.field("method")) else {
         return false;
     };
     if context.source.node_text(method) != "new" {
@@ -452,10 +488,15 @@ fn is_class_or_module_new(context: &RuleContext<'_>, node: Node<'_>, global: boo
         return false;
     }
     let bare = name.rsplit("::").next().unwrap_or(&name);
-    matches!(receiver.kind_str(), "constant" | "scope_resolution") && matches!(bare, "Class" | "Module")
+    matches!(receiver.kind_str(), "constant" | "scope_resolution")
+        && matches!(bare, "Class" | "Module")
 }
 
-fn singleton_class_name(context: &RuleContext<'_>, node: Node<'_>) -> Option<String> {
+fn singleton_class_name(
+    context: &RuleContext<'_>,
+    node: Node<'_>,
+    locals: &LocalVariables<'_, '_>,
+) -> Option<String> {
     let value = node.field("value")?;
     match value.kind_str() {
         "constant" | "scope_resolution" => {
@@ -463,7 +504,7 @@ fn singleton_class_name(context: &RuleContext<'_>, node: Node<'_>) -> Option<Str
         }
         "self" => Some(format!(
             "#<Class:{}>",
-            parent_module_name(context, node).unwrap_or_default()
+            parent_module_name(context, node, locals).unwrap_or_default()
         )),
         _ => None,
     }
@@ -479,7 +520,10 @@ enum BlockScope {
 }
 
 fn block_module_name(context: &RuleContext<'_>, block: Node<'_>) -> BlockScope {
-    let Some(call) = block.parent_of(context).filter(|parent| parent.kind_str() == "call") else {
+    let Some(call) = block
+        .parent_of(context)
+        .filter(|parent| parent.kind_str() == "call")
+    else {
         return BlockScope::Opaque;
     };
     // `on_send` は `csend` に呼ばれないので、`Class&.new do` のブロックは本家からは名前の付かない
@@ -733,15 +777,12 @@ fn named_receiver<'a>(context: &'a RuleContext<'_>, call: Node<'_>) -> Option<(&
 }
 
 fn is_class_new_block(context: &RuleContext<'_>, block: Node<'_>) -> bool {
-    block
-        .field("receiver")
-        .is_some_and(|receiver| {
-            constant_name(context, receiver)
-                .rsplit("::")
-                .next()
-                .is_some_and(|name| name == "Class")
-        })
-        && is_class_or_module_new(context, block, false)
+    block.field("receiver").is_some_and(|receiver| {
+        constant_name(context, receiver)
+            .rsplit("::")
+            .next()
+            .is_some_and(|name| name == "Class")
+    }) && is_class_or_module_new(context, block, false)
 }
 
 fn anon_block_identity(context: &RuleContext<'_>, block: Node<'_>) -> String {
@@ -781,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());
@@ -807,3 +848,41 @@ fn symbol_name(text: &str) -> Option<&str> {
         .unwrap_or(text);
     (!unquoted.is_empty() && !unquoted.contains(['#', '"', '\''])).then_some(unquoted)
 }
+
+/// `args.size == 2 && args.last.true_type?`: the second argument of the historical `attr` form.
+fn attr_with_writer(node: Node<'_>) -> bool {
+    let Some(list) = node.field("arguments") else {
+        return false;
+    };
+    let written = crate::rules::send_node::named_children(list);
+    matches!(written.as_slice(), [_, last] if last.kind_str() == "true")
+}
+
+/// The name the first argument of an `attr` spells, when a later argument stopped
+/// `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_of(list, context).first()?;
+    if !matches!(first.kind_str(), "simple_symbol" | "string") {
+        return None;
+    }
+    symbol_name(context.source.node_text(first)).map(str::to_owned)
+}
+
+/// The `attr` arguments upstream records: `sym_name` answers only for a `sym`, so an accessor
+/// named with a string contributes nothing.
+fn attr_symbol_names(node: Node<'_>, fallback: &[String]) -> Vec<String> {
+    let Some(list) = node.field("arguments") else {
+        return fallback.to_vec();
+    };
+    let written = crate::rules::send_node::named_children(list);
+    if written.len() != fallback.len() {
+        return fallback.to_vec();
+    }
+    written
+        .iter()
+        .zip(fallback)
+        .filter(|(argument, _)| argument.kind_str() == "simple_symbol")
+        .map(|(_, name)| name.clone())
+        .collect()
+}

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"]) {
@@ -15,7 +16,7 @@ pub(super) fn check(context: &RuleContext<'_>, offenses: &mut Vec<Offense>) {
         let mut seen: Vec<Node<'_>> = Vec::new();
         for (index, &element) in elements.iter().enumerate() {
             // Only a value the cop can compare: anything computed may differ at run time.
-            if !is_comparable(element) {
+            if !is_comparable(element, context) {
                 continue;
             }
             if !seen.iter().any(|other| identical(*other, element, context)) {
@@ -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();
@@ -62,7 +63,10 @@ fn set_init_elements<'tree>(
                 return None;
             };
             let array = only.first();
-            (array.kind_str() == "array").then(|| (name, literal_elements(array)))
+            // `%i[…]` and `%w[…]` are `array` nodes upstream; the grammar names them by their
+            // percent spelling, so `Set.new(%i[foo bar foo])` fell out of the arm entirely.
+            matches!(array.kind_str(), "array" | "symbol_array" | "string_array")
+                .then(|| (name, literal_elements(array)))
         }
         // `(call (array $...) :to_set)`: the class is not written, so the message names `Set`.
         "to_set" => {
@@ -95,7 +99,12 @@ fn set_class_name(node: Node<'_>, context: &RuleContext<'_>) -> Option<String> {
 }
 
 /// `literal? || const_type? || variable?`: what the cop is willing to call the same twice.
-fn is_comparable(node: Node<'_>) -> bool {
+fn is_comparable(node: Node<'_>, context: &RuleContext<'_>) -> bool {
+    // `variable?` is `lvar`/`ivar`/`cvar`/`gvar`. A bare name that was never assigned is a `send`
+    // upstream -- `Set[foo, foo]` calls `foo` twice and may well get two different values.
+    if node.kind_str() == "identifier" && !context.variable_analysis().is_variable_reference(node) {
+        return false;
+    }
     matches!(
         node.kind_str(),
         "integer"
@@ -105,6 +114,9 @@ fn is_comparable(node: Node<'_>) -> bool {
             | "string"
             | "simple_symbol"
             | "delimited_symbol"
+            // The elements of a `%i[…]` / `%w[…]`, which upstream spells as plain `sym` and `str`.
+            | "bare_symbol"
+            | "bare_string"
             | "hash_key_symbol"
             | "character"
             | "true"
@@ -122,6 +134,8 @@ fn is_comparable(node: Node<'_>) -> bool {
             | "instance_variable"
             | "class_variable"
             | "global_variable"
+            // `variable?` covers a local variable, which the grammar spells as a bare identifier.
+            | "identifier"
             | "self"
     )
 }

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"];
@@ -35,6 +36,21 @@ pub(super) fn check(context: &RuleContext<'_>, offenses: &mut Vec<Offense>) {
         let alternative = node.field("alternative");
         let range = match alternative {
             Some(clause) => node.start_byte()..clause.start_byte(),
+            // `node.source_range` ends at the last node the **parser** built, and a comment is not
+            // one. An `elsif` holding nothing but a comment therefore ends at its condition; an
+            // `if` still reaches its own `end`, which the grammar keeps inside the node.
+            None if node.kind_str() == "elsif" => {
+                let end = node
+                    .field("condition")
+                    .map_or_else(|| node.end_byte(), |condition| condition.end_byte());
+                // The parser's range keeps the separator that closes the clause -- `elsif cond;`
+                // ends after the semicolon -- and stops before a comment or a line break.
+                let end = match context.source.text()[end..node.end_byte()].chars().next() {
+                    Some(';') => end + 1,
+                    _ => end,
+                };
+                node.start_byte()..end
+            }
             None => node.byte_range(),
         };
         let mut offense =
@@ -166,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))
@@ -175,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_expression.rs

@@ -1,5 +1,6 @@
 use crate::diagnostic::Offense;
 use crate::rules::RuleContext;
+use crate::rules::node_ext::NodeExt;
 
 use super::statements::statements;
 
@@ -8,7 +9,21 @@ const MSG: &str = "Avoid empty expressions.";
 pub(super) fn check(context: &RuleContext<'_>, offenses: &mut Vec<Offense>) {
     // `on_begin` reaches the `begin` node that `(...)` builds and the one an interpolation holds,
     // but never the `kwbegin` of `begin ... end`, which is a type of its own upstream.
-    for node in context.nodes_of_any(&["parenthesized_statements", "interpolation"]) {
+    for node in context.nodes_of_any(&[
+        "parenthesized_statements",
+        "interpolation",
+        // **`return()` writes its parentheses as an argument list here.** Upstream builds the
+        // same empty `begin` a bare `()` does, so the jump's empty parentheses are an empty
+        // expression too -- the grammar just files them under a different kind.
+        "argument_list",
+    ]) {
+        if node.kind_str() == "argument_list"
+            && node
+                .parent()
+                .is_none_or(|parent| !matches!(parent.kind_str(), "return" | "break" | "next"))
+        {
+            continue;
+        }
         if statements(node).is_empty() {
             offenses.push(context.offense(MSG, node.byte_range()));
         }

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)),