sonicop 26.8.112 → 26.8.113

data/src/rules/layout/multiline_expression.rs

@@ -23,6 +23,7 @@ use super::support::{begins_its_line, character_column, line_indentation};
 use crate::rules::RuleContext;
 use crate::rules::lint::locals::LocalVariables;
 use crate::rules::node_ext::NodeExt;
+use crate::rules::send_node::named_children_iter;
 
 /// Which of the nodes upstream's parser builds for one piece of source this stands for.
 #[derive(Clone, Copy, Eq, PartialEq)]
@@ -44,6 +45,10 @@ enum Role {
 pub(super) struct UpNode<'tree> {
     node: Node<'tree>,
     role: Role,
+    /// The file's node index, carried so that climbing to a parent is a lookup rather than a walk
+    /// down from the root of the tree. Every step of every chain this cop family follows asks for
+    /// one, and `Node::parent` was the largest cost of the three cops together.
+    index: &'tree crate::rules::AstIndex<'tree>,
 }
 
 /// The node types the ported code asks about by name.
@@ -114,11 +119,11 @@ fn block_of<'tree>(node: Node<'tree>) -> Option<Node<'tree>> {
 
 /// Whether the call was fused into the setter `send` its assignment builds, which leaves it
 /// without a node of its own upstream.
-fn is_fused_setter_target(node: Node<'_>) -> bool {
+fn is_fused_setter_target(node: Node<'_>, index: &crate::rules::AstIndex<'_>) -> bool {
     if !matches!(node.kind_str(), "call" | "element_reference") {
         return false;
     }
-    node.parent().is_some_and(|parent| {
+    index.parent(node).is_some_and(|parent| {
         parent.kind_str() == "assignment"
             && parent
                 .field("left")
@@ -129,19 +134,20 @@ fn is_fused_setter_target(node: Node<'_>) -> bool {
 impl<'tree> UpNode<'tree> {
     /// The node a reference from elsewhere -- a receiver, an argument -- resolves to. A call
     /// written with a block is the `block` node there.
-    pub(super) fn of(node: Node<'tree>) -> Self {
+    pub(super) fn of(node: Node<'tree>, index: &'tree crate::rules::AstIndex<'tree>) -> Self {
         let role = if block_of(node).is_some() {
             Role::Block
         } else {
             Role::Plain
         };
-        Self { node, role }
+        Self { node, role, index }
     }
 
-    pub(super) fn plain(node: Node<'tree>) -> Self {
+    pub(super) fn plain(node: Node<'tree>, index: &'tree crate::rules::AstIndex<'tree>) -> Self {
         Self {
             node,
             role: Role::Plain,
+            index,
         }
     }
 
@@ -226,13 +232,19 @@ impl<'tree> UpNode<'tree> {
             return None;
         }
         match node.kind_str() {
-            "call" | "method_call" => node.field("receiver").map(Self::of),
-            "element_reference" => node.field("object").map(Self::of),
-            "binary" => node.field("left").map(Self::of),
-            "unary" => node.field("operand").map(Self::of),
+            "call" | "method_call" => node
+                .field("receiver")
+                .map(|receiver| Self::of(receiver, self.index)),
+            "element_reference" => node
+                .field("object")
+                .map(|object| Self::of(object, self.index)),
+            "binary" => node.field("left").map(|left| Self::of(left, self.index)),
+            "unary" => node
+                .field("operand")
+                .map(|operand| Self::of(operand, self.index)),
             "assignment" => {
                 let left = node.field("left")?;
-                Self::plain(left).receiver(context)
+                Self::plain(left, self.index).receiver(context)
             }
             _ => None,
         }
@@ -342,29 +354,29 @@ impl<'tree> UpNode<'tree> {
         }
         match self.node.kind_str() {
             "call" | "method_call" => match self.node.field("arguments") {
-                Some(list) => fold_arguments(list, &children_of(list)),
+                Some(list) => fold_arguments(list, &children_of(list), self.index),
                 None => Vec::new(),
             },
             "element_reference" => {
                 let indices: Vec<Node<'tree>> =
                     children_of(self.node).into_iter().skip(1).collect();
-                fold_arguments(self.node, &indices)
+                fold_arguments(self.node, &indices, self.index)
             }
             "binary" if plain_kind(context, self.node) == UpKind::Send => self
                 .node
                 .field("right")
-                .map_or_else(Vec::new, |right| vec![Self::of(right)]),
+                .map_or_else(Vec::new, |right| vec![Self::of(right, self.index)]),
             "assignment" => {
                 let Some(left) = self.node.field("left") else {
                     return Vec::new();
                 };
                 let mut arguments = if left.kind_str() == "element_reference" {
-                    Self::plain(left).arguments(context)
+                    Self::plain(left, self.index).arguments(context)
                 } else {
                     Vec::new()
                 };
                 if let Some(right) = self.node.field("right") {
-                    arguments.push(Self::of(right));
+                    arguments.push(Self::of(right, self.index));
                 }
                 arguments
             }
@@ -385,13 +397,14 @@ impl<'tree> UpNode<'tree> {
         (self.role == Role::Plain && block_of(self.node).is_some()).then_some(Self {
             node: self.node,
             role: Role::Block,
+            index: self.index,
         })
     }
 
     /// `BlockNode#send_node`.
     pub(super) fn send_node(self) -> Self {
         match self.role {
-            Role::Block => Self::plain(self.node),
+            Role::Block => Self::plain(self.node, self.index),
             _ => self,
         }
     }
@@ -431,7 +444,7 @@ impl<'tree> UpNode<'tree> {
 
     /// Whether the call was fused into the setter send its assignment builds.
     pub(super) fn is_fused_setter_target(self) -> bool {
-        self.role == Role::Plain && is_fused_setter_target(self.node)
+        self.role == Role::Plain && is_fused_setter_target(self.node, self.index)
     }
 
     /// One of the node's own fields, for the few places the ported code reads a part the model
@@ -449,6 +462,7 @@ impl<'tree> UpNode<'tree> {
                 return Some(Self {
                     node,
                     role: Role::Block,
+                    index: self.index,
                 });
             }
             let mut cursor = node.walk();
@@ -461,12 +475,12 @@ impl<'tree> UpNode<'tree> {
 
     pub(super) fn parent(self) -> Option<Self> {
         match self.role {
-            Role::Block | Role::Array => raw_parent(self.node),
+            Role::Block | Role::Array => raw_parent(self.node, self.index),
             Role::Hash => {
                 if self.node.kind_str() == "argument_list" {
-                    raw_parent(self.node)
+                    raw_parent(self.node, self.index)
                 } else {
-                    Some(Self::plain(self.node))
+                    Some(Self::plain(self.node, self.index))
                 }
             }
             Role::Plain => {
@@ -474,15 +488,17 @@ impl<'tree> UpNode<'tree> {
                     return Some(Self {
                         node: self.node,
                         role: Role::Block,
+                        index: self.index,
                     });
                 }
                 if is_lone_assigned_splat(self.node) {
                     return Some(Self {
                         node: self.node,
                         role: Role::Array,
+                        index: self.index,
                     });
                 }
-                raw_parent(self.node)
+                raw_parent(self.node, self.index)
             }
         }
     }
@@ -523,7 +539,11 @@ fn children_of<'tree>(node: Node<'tree>) -> Vec<Node<'tree>> {
 }
 
 /// Groups a run of `key: value` pairs into the one `hash` argument upstream's parser folds it into.
-fn fold_arguments<'tree>(container: Node<'tree>, children: &[Node<'tree>]) -> Vec<UpNode<'tree>> {
+fn fold_arguments<'tree>(
+    container: Node<'tree>,
+    children: &[Node<'tree>],
+    own_index: &'tree crate::rules::AstIndex<'tree>,
+) -> Vec<UpNode<'tree>> {
     let mut arguments = Vec::new();
     let mut index = 0;
     while index < children.len() {
@@ -534,10 +554,11 @@ fn fold_arguments<'tree>(container: Node<'tree>, children: &[Node<'tree>]) -> Ve
             arguments.push(UpNode {
                 node: container,
                 role: Role::Hash,
+                index: own_index,
             });
             continue;
         }
-        arguments.push(UpNode::of(children[index]));
+        arguments.push(UpNode::of(children[index], own_index));
         index += 1;
     }
     arguments
@@ -563,32 +584,37 @@ fn hash_run_range(container: Node<'_>) -> Range<usize> {
 
 /// Climbs to the node upstream would call this one's parent, stepping over the containers the
 /// parser has no node for.
-fn raw_parent<'tree>(node: Node<'tree>) -> Option<UpNode<'tree>> {
+fn raw_parent<'tree>(
+    node: Node<'tree>,
+    index: &'tree crate::rules::AstIndex<'tree>,
+) -> Option<UpNode<'tree>> {
     let mut current = node;
     loop {
-        let parent = current.parent()?;
+        let parent = index.parent_in_tree(current)?;
         if parent.kind_str() == "block" || parent.kind_str() == "do_block" {
             // The body of a literal block hangs off the `block` node upstream, whose own parent is
             // the parent of the call the block was written on.
             return Some(UpNode {
-                node: parent.parent()?,
+                node: index.parent_in_tree(parent)?,
                 role: Role::Block,
+                index,
             });
         }
         if is_hash_element(current) && HASH_CONTAINERS.contains(&parent.kind_str()) {
             return Some(UpNode {
                 node: parent,
                 role: Role::Hash,
+                index,
             });
         }
         if TRANSPARENT.contains(&parent.kind_str())
-            || is_fused_setter_target(parent)
+            || is_fused_setter_target(parent, index)
             || is_defined_parentheses(parent)
         {
             current = parent;
             continue;
         }
-        return Some(UpNode::plain(parent));
+        return Some(UpNode::plain(parent, index));
     }
 }
 
@@ -974,7 +1000,10 @@ impl<'tree> Mixin<'_, 'tree> {
     pub(super) fn assignment_rhs(&self, node: UpNode<'tree>) -> Option<UpNode<'tree>> {
         match node.kind(self.context) {
             UpKind::Send | UpKind::Csend => node.last_argument(self.context),
-            _ => node.node.field("right").map(UpNode::of),
+            _ => node
+                .node
+                .field("right")
+                .map(|right| UpNode::of(right, node.index)),
         }
     }
 
@@ -1046,8 +1075,8 @@ fn is_numbered_block(context: &RuleContext<'_>, call: Node<'_>) -> bool {
         if matches!(node.kind_str(), "block" | "do_block") {
             continue;
         }
-        let mut cursor = node.walk();
-        stack.extend(node.named_children(&mut cursor));
+        let _cursor = node.walk();
+        stack.extend(named_children_iter(node, context));
     }
     false
 }

data/src/rules/layout/multiline_hash_brace_layout.rs

@@ -4,6 +4,7 @@ use super::multiline_brace::{Literal, Messages, check_brace_layout, delimiters};
 use crate::diagnostic::Offense;
 use crate::rules::RuleContext;
 use crate::rules::node_ext::NodeExt;
+use crate::rules::send_node::named_children_of;
 
 const MESSAGES: Messages = Messages {
     same_line: "Closing hash brace must be on the same line as the last hash element when opening \
@@ -21,10 +22,10 @@ pub(super) fn check(context: &RuleContext<'_>, offenses: &mut Vec<Offense>) {
         let Some((open, close)) = delimiters(node, &["{"]) else {
             continue;
         };
-        let mut cursor = node.walk();
+        let _cursor = node.walk();
         // Each pair is a child of its own here: only a *brace-less* run folds into one `hash`.
-        let elements = node
-            .named_children(&mut cursor)
+        let elements = named_children_of(node, context)
+            .into_iter()
             .filter(|child| !matches!(child.kind_str(), "comment" | "heredoc_body"))
             .map(|child| vec![child])
             .collect();

data/src/rules/layout/multiline_method_call_indentation.rs

@@ -38,7 +38,7 @@ pub(super) fn check(context: &RuleContext<'_>, offenses: &mut Vec<Offense>) {
     };
 
     for ts in context.nodes_of_any(&["call", "method_call", "assignment"]) {
-        let node = UpNode::plain(ts);
+        let node = UpNode::plain(ts, context.ast_index());
         if !matches!(node.kind(context), UpKind::Send | UpKind::Csend) {
             continue;
         }

data/src/rules/layout/multiline_operation_indentation.rs

@@ -15,13 +15,13 @@ pub(super) fn check(context: &RuleContext<'_>, offenses: &mut Vec<Offense>) {
         .is_none_or(|style| style == "aligned");
 
     for ts in context.nodes_of_any(&["binary", "assignment"]) {
-        let node = UpNode::plain(ts);
+        let node = UpNode::plain(ts, context.ast_index());
         let checked = match node.kind(context) {
             // `on_and` / `on_or`.
             UpKind::And | UpKind::Or => {
                 let (Some(lhs), Some(rhs)) = (
-                    ts.field("left").map(UpNode::of),
-                    ts.field("right").map(UpNode::of),
+                    ts.field("left").map(|left| UpNode::of(left, context.ast_index())),
+                    ts.field("right").map(|right| UpNode::of(right, context.ast_index())),
                 ) else {
                     continue;
                 };

data/src/rules/layout/redundant_line_break.rs

@@ -5,11 +5,12 @@ use tree_sitter::Node;
 use crate::diagnostic::{Edit, Offense};
 use crate::rules::RuleContext;
 use crate::rules::node_ext::NodeExt;
-use crate::rules::send_node::{is_plain_send, named_children, send_range};
+use crate::rules::send_node::{is_plain_send, send_range};
 use crate::rules::single_line::{
     descendants, is_suitable_as_single_line, last_byte, max_line_length, to_single_line,
 };
 use crate::rules::support::{Verification, verified_by_reparse};
+use crate::rules::send_node::named_children_of;
 
 const MSG: &str = "Redundant line break detected.";
 
@@ -293,7 +294,7 @@ fn is_top(node: Node<'_>, context: &RuleContext<'_>) -> bool {
 /// an `or` is ever inspected.
 fn spine_has_send(node: Node<'_>, context: &RuleContext<'_>) -> bool {
     if is_logical(node, context) {
-        return named_children(node)
+        return named_children_of(node, context)
             .into_iter()
             .any(|child| spine_has_send(child, context));
     }

data/src/rules/layout/single_line_block_chain.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::all_children_iter;
 
 const MSG: &str = "Put method call on a separate line if chained to a single line block.";
 
@@ -73,10 +74,10 @@ fn block_of<'tree>(receiver: Node<'tree>) -> Option<Node<'tree>> {
 fn dot_of<'tree>(
     node: Node<'tree>,
     receiver: Node<'_>,
-    context: &RuleContext<'_>,
+    context: &'tree RuleContext<'_>,
 ) -> Option<Node<'tree>> {
-    let mut cursor = node.walk();
-    node.children(&mut cursor)
+    let _cursor = node.walk();
+    all_children_iter(node, context)
         .filter(|child| !child.is_named() && child.start_byte() >= receiver.end_byte())
         .find(|child| DOTS.contains(&context.source.node_text(*child)))
 }

data/src/rules/layout/space_around_block_parameters.rs

@@ -194,8 +194,7 @@ fn delimiters<'tree>(parameters: Node<'tree>) -> (Option<Node<'tree>>, Option<No
 
 fn block_arguments<'tree>(parameters: Node<'tree>) -> Vec<Node<'tree>> {
     let mut cursor = parameters.walk();
-    parameters
-        .named_children(&mut cursor)
+    parameters.named_children(&mut cursor)
         .filter(|child| !matches!(child.kind_str(), "comment" | "heredoc_body"))
         .collect()
 }

data/src/rules/layout/space_around_equals_in_parameter_default.rs

@@ -65,8 +65,7 @@ fn optional_parameters(name: Node<'_>, value: Node<'_>) -> Vec<(usize, usize)> {
             .filter(|left| left.kind_str() == "left_assignment_list")
             .and_then(|left| {
                 let mut cursor = left.walk();
-                let parts: Vec<Node<'_>> = left
-                    .named_children(&mut cursor)
+                let parts: Vec<Node<'_>> = left.named_children(&mut cursor)
                     .filter(|part| !matches!(part.kind_str(), "comment" | "heredoc_body"))
                     .collect();
                 match (parts.len() == 2, value.field("right")) {

data/src/rules/layout/space_around_operators.rs

@@ -407,8 +407,7 @@ fn pairs_on_same_line(pair: Node<'_>) -> bool {
         return false;
     };
     let mut cursor = parent.walk();
-    let lines: Vec<usize> = parent
-        .named_children(&mut cursor)
+    let lines: Vec<usize> = parent.named_children(&mut cursor)
         .filter(|child| child.kind_str() == "pair")
         .map(|child| child.start_position().row)
         .collect();

data/src/rules/layout/space_before_brackets.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::named_children;
+use crate::rules::send_node::named_children_of;
+use crate::rules::send_node::all_children_iter;
 
 const MSG: &str = "Remove the space before the opening brackets.";
 
@@ -56,7 +57,7 @@ fn index_gap(node: Node<'_>, context: &RuleContext<'_>) -> Option<(usize, usize)
                 return None;
             }
             let arguments = node.field("arguments")?;
-            let children = named_children(arguments);
+            let children = named_children_of(arguments, context);
             let [argument] = children.as_slice() else {
                 return None;
             };
@@ -72,8 +73,8 @@ fn index_gap(node: Node<'_>, context: &RuleContext<'_>) -> Option<(usize, usize)
 }
 
 /// `node.loc.selector`, which for an index read begins at the `[`.
-fn opening_bracket<'tree>(node: Node<'tree>, context: &RuleContext<'_>) -> Option<Node<'tree>> {
-    let mut cursor = node.walk();
-    node.children(&mut cursor)
+fn opening_bracket<'tree>(node: Node<'tree>, context: &'tree RuleContext<'_>) -> Option<Node<'tree>> {
+    let _cursor = node.walk();
+    all_children_iter(node, context)
         .find(|child| !child.is_named() && context.source.node_text(*child) == "[")
 }

data/src/rules/layout/space_before_comma.rs

@@ -4,6 +4,7 @@ use super::support::whitespace_before;
 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 text = context.source.text();
@@ -17,8 +18,8 @@ pub(super) fn check(context: &RuleContext<'_>, offenses: &mut Vec<Offense>) {
     let block_braces: Vec<usize> = context
         .nodes_of("block")
         .filter_map(|node| {
-            let mut cursor = node.walk();
-            node.children(&mut cursor)
+            let _cursor = node.walk();
+            all_children_iter(node, context)
                 .find(|child| child.kind_str() == "{")
                 .map(|child| child.start_byte())
         })

data/src/rules/layout/space_inside_range_literal.rs

@@ -5,6 +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_of;
+use crate::rules::send_node::all_children_of;
 
 const MSG: &str = "Space inside range literal.";
 
@@ -14,9 +16,9 @@ pub(super) fn check(context: &RuleContext<'_>, offenses: &mut Vec<Offense>) {
         if is_flip_flop(context, node) {
             continue;
         }
-        let mut cursor = node.walk();
-        let Some(operator) = node
-            .children(&mut cursor)
+        let _cursor = node.walk();
+        let Some(operator) = all_children_of(node, context)
+            .into_iter()
             .find(|child| matches!(child.kind_str(), ".." | "..."))
         else {
             continue;
@@ -83,9 +85,9 @@ fn is_flip_flop(context: &RuleContext<'_>, node: Node<'_>) -> bool {
     while let Some(parent) = current.parent_of(context) {
         match parent.kind_str() {
             "parenthesized_statements" => {
-                let mut cursor = parent.walk();
-                if parent
-                    .named_children(&mut cursor)
+                let _cursor = parent.walk();
+                if named_children_of(parent, context)
+                    .into_iter()
                     .filter(|child| !matches!(child.kind_str(), "comment" | "heredoc_body"))
                     .count()
                     != 1

data/src/rules/layout/support.rs

@@ -8,6 +8,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::all_children_of;
+use crate::rules::send_node::named_children_of;
 pub(super) use crate::rules::support::final_pos;
 
 /// The run of spaces and tabs ending at `offset`.
@@ -518,13 +520,13 @@ pub(super) fn holds_block_comment(context: &RuleContext<'_>, expr: &Range<usize>
 /// This is `each_argument_node`, which walks each argument's subtree but stops at anything that is
 /// a method call upstream -- so a literal nested inside another call belongs to that call instead.
 pub(super) fn argument_literals<'tree>(
-    context: &RuleContext<'_>,
+    context: &'tree RuleContext<'_>,
     call: Node<'tree>,
     kinds: &[&str],
 ) -> Vec<(Node<'tree>, Node<'tree>)> {
-    let mut cursor = call.walk();
-    let Some(list) = call
-        .children(&mut cursor)
+    let _cursor = call.walk();
+    let Some(list) = all_children_of(call, context)
+        .into_iter()
         .find(|child| child.kind_str() == "argument_list")
     else {
         return Vec::new();
@@ -893,9 +895,9 @@ pub(super) fn heredoc_terminators(context: &RuleContext<'_>) -> Vec<(usize, Rang
         .enumerate()
         .filter_map(|(index, body)| {
             let opener = *openers.get(index)?;
-            let mut cursor = body.walk();
-            let terminator = body
-                .named_children(&mut cursor)
+            let _cursor = body.walk();
+            let terminator = named_children_of(body, context)
+                .into_iter()
                 .find(|child| child.kind_str() == "heredoc_end")?;
             Some((opener, terminator.byte_range()))
         })

data/src/rules/layout/tokens.rs

@@ -182,8 +182,7 @@ impl Builder<'_, '_> {
                     self.push(node);
                     return;
                 }
-                let mut cursor = node.walk();
-                for child in node.children(&mut cursor) {
+                for child in children_of(self.context, node) {
                     self.walk(child);
                 }
             }
@@ -208,8 +207,7 @@ impl Builder<'_, '_> {
             return;
         }
         let mut offset = from;
-        let mut cursor = node.walk();
-        for child in node.children(&mut cursor) {
+        for child in children_of(self.context, node) {
             if child.end_byte() <= from {
                 continue;
             }
@@ -229,8 +227,7 @@ impl Builder<'_, '_> {
 
     /// The two delimiters of an empty percent literal, emitted as neighbours.
     fn emit_delimiters(&mut self, node: Node<'_>, from: usize) {
-        let mut cursor = node.walk();
-        for child in node.children(&mut cursor) {
+        for child in children_of(self.context, node) {
             if child.end_byte() <= from {
                 continue;
             }
@@ -387,3 +384,15 @@ fn opens_a_command_argument(node: Node<'_>) -> bool {
         .and_then(|list| list.parent())
         .is_some_and(|parent| parent.kind_str() == "call")
 }
+
+/// A node's children, from the file's index. Collected rather than iterated because the walk
+/// takes `&mut self`, and a list of nodes is far cheaper than the cursor walk it replaces.
+fn children_of<'node>(context: &'node RuleContext<'_>, node: Node<'node>) -> Vec<Node<'node>> {
+    match context.children(node) {
+        Some(children) => children.collect(),
+        None => {
+            let mut cursor = node.walk();
+            node.children(&mut cursor).collect()
+        }
+    }
+}

data/src/rules/lint/access_modifier.rs

@@ -10,6 +10,8 @@ use tree_sitter::Node;
 
 use crate::rules::RuleContext;
 use crate::rules::node_ext::NodeExt;
+use crate::rules::send_node::named_children_iter;
+use crate::rules::send_node::named_children_of;
 
 /// The names `bare_access_modifier_declaration?` matches, interned so a visibility can be carried
 /// around as a `&'static str` rather than borrowed from the source it was read out of.
@@ -33,7 +35,7 @@ pub(in crate::rules) fn send_name<'a>(
     context: &'a RuleContext<'_>,
 ) -> Option<&'a str> {
     match node.kind_str() {
-        "identifier" if is_send_identifier(node) => Some(context.source.node_text(node)),
+        "identifier" if is_send_identifier(node, context) => Some(context.source.node_text(node)),
         "call" if node.field("block").is_none() => {
             let method = node.field("method")?;
             crate::rules::send_node::is_plain_send(node, context)
@@ -76,11 +78,11 @@ pub(super) fn bare_access_modifier(
 /// What this cannot tell is a read of a local variable, which is an `lvar` upstream and a plain
 /// identifier here as well. Only a file that assigned `private` (or one of its siblings) to a
 /// local could be misread, and the name would have to be one of five.
-fn is_send_identifier(node: Node<'_>) -> bool {
-    let Some(parent) = node.parent() else {
+fn is_send_identifier(node: Node<'_>, context: &RuleContext<'_>) -> bool {
+    let Some(parent) = context.parent(node) else {
         return true;
     };
-    let field = field_name(node, parent);
+    let field = field_name(node, parent, context.ast_index());
     match parent.kind_str() {
         "call" => field != Some("method"),
         "method" | "singleton_method" => field != Some("name"),
@@ -106,7 +108,14 @@ fn is_send_identifier(node: Node<'_>) -> bool {
     }
 }
 
-fn field_name<'tree>(node: Node<'tree>, parent: Node<'tree>) -> Option<&'static str> {
+fn field_name<'tree>(
+    node: Node<'tree>,
+    parent: Node<'tree>,
+    index: &super::super::AstIndex<'_>,
+) -> Option<&'static str> {
+    if index.knows(node) {
+        return index.field_name_of(node);
+    }
     let mut cursor = parent.walk();
     if !cursor.goto_first_child() {
         return None;
@@ -193,9 +202,9 @@ fn branch_repeats_condition(
     context: &RuleContext<'_>,
 ) -> bool {
     let text = context.source.node_text(condition);
-    let mut cursor = conditional.walk();
-    let branches: Vec<Node<'_>> = conditional
-        .named_children(&mut cursor)
+    let _cursor = conditional.walk();
+    let branches: Vec<Node<'_>> = named_children_of(conditional, context)
+        .into_iter()
         .filter(|child| child.id() != condition.id())
         .collect();
     branches.into_iter().any(|branch| {
@@ -203,8 +212,8 @@ fn branch_repeats_condition(
         // statement is that statement, and one holding several is a `begin` no condition matches.
         let branch = match branch.kind_str() {
             "then" | "else" => {
-                let mut cursor = branch.walk();
-                let mut children = branch.named_children(&mut cursor);
+                let _cursor = branch.walk();
+                let mut children = named_children_iter(branch, context);
                 match (children.next(), children.next()) {
                     (Some(only), None) => only,
                     _ => return false,