sonicop 26.8.111 → 26.8.113

data/src/rules/lint/void.rs

@@ -4,7 +4,7 @@ use tree_sitter::Node;
 
 use crate::diagnostic::{Edit, Offense};
 use crate::rules::RuleContext;
-use crate::rules::send_node::{arguments, named_children};
+use crate::rules::send_node::arguments;
 use crate::rules::support;
 
 use super::blocks::{BLOCK_KINDS, BlockArgs};
@@ -12,6 +12,7 @@ use super::literals::{is_literal, literal_type};
 use super::locals::LocalVariables;
 use super::statements::{Branch, begin_containers, body_children, has_clause, statements};
 use crate::rules::node_ext::NodeExt;
+use crate::rules::send_node::named_children_of;
 
 const SELF_MSG: &str = "`self` used in void context.";
 
@@ -270,15 +271,26 @@ impl Void<'_, '_> {
                     .then(|| OperatorCall {
                         method,
                         selector: operator.byte_range(),
-                        receiver: node
-                            .field("left")
-                            .map(|left| left.byte_range()),
+                        receiver: node.field("left").map(|left| left.byte_range()),
                         argument_count: 1,
                         dot: None,
                     })
             }
             "unary" => {
                 let operator = node.field("operator")?;
+                // **A sign in front of a number is part of the number upstream.** `-3` parses to
+                // `(int -3)`, not to a `-@` send, so it is a literal here and no operator at all --
+                // the grammar keeps the two apart and would otherwise report both.
+                if matches!(self.text(operator), "-" | "+")
+                    && node.field("operand").is_some_and(|operand| {
+                        matches!(
+                            operand.kind_str(),
+                            "integer" | "float" | "rational" | "complex"
+                        )
+                    })
+                {
+                    return None;
+                }
                 let method = match self.text(operator) {
                     "-" => "-@",
                     "+" => "+@",
@@ -291,9 +303,7 @@ impl Void<'_, '_> {
                 Some(OperatorCall {
                     method,
                     selector: operator.byte_range(),
-                    receiver: node
-                        .field("operand")
-                        .map(|operand| operand.byte_range()),
+                    receiver: node.field("operand").map(|operand| operand.byte_range()),
                     argument_count: 0,
                     dot: None,
                 })
@@ -309,13 +319,9 @@ impl Void<'_, '_> {
                 Some(OperatorCall {
                     method: name,
                     selector: method.byte_range(),
-                    receiver: node
-                        .field("receiver")
-                        .map(|receiver| receiver.byte_range()),
+                    receiver: node.field("receiver").map(|receiver| receiver.byte_range()),
                     argument_count: arguments(node).len(),
-                    dot: node
-                        .field("operator")
-                        .map(|operator| operator.byte_range()),
+                    dot: node.field("operator").map(|operator| operator.byte_range()),
                 })
             }
             _ => None,
@@ -336,7 +342,7 @@ impl Void<'_, '_> {
             return;
         }
         if matches!(expression.kind_str(), "case" | "case_match") {
-            for child in named_children(expression) {
+            for child in named_children_of(expression, self.context) {
                 match child.kind_str() {
                     "when" | "in_clause" => {
                         if let Branch::One(body) = Branch::of(child.field("body")) {
@@ -387,7 +393,11 @@ impl Void<'_, '_> {
             node.kind_str(),
             "instance_variable" | "global_variable" | "class_variable"
         ) || (node.kind_str() == "identifier"
-            && (self.locals.is_lvar(node) || self.is_block_parameter(node)));
+            && (self.locals.is_lvar(node)
+                || self.is_block_parameter(node)
+                // `special_keyword?`: upstream parses these as `const` and reports them with the
+                // variable message. The grammar spells them as plain identifiers.
+                || matches!(self.text(node), "__FILE__" | "__LINE__" | "__ENCODING__")));
         if !constant && !variable {
             return;
         }
@@ -406,8 +416,9 @@ impl Void<'_, '_> {
         while let Some(ancestor) = current {
             if BLOCK_KINDS.contains(&ancestor.kind_str()) {
                 return match BlockArgs::of(ancestor, self.context, &self.locals) {
-                    BlockArgs::Numbered(highest) => (1..=highest)
-                        .any(|index| self.text(node) == format!("_{index}")),
+                    BlockArgs::Numbered(highest) => {
+                        (1..=highest).any(|index| self.text(node) == format!("_{index}"))
+                    }
                     BlockArgs::It => self.text(node) == "it",
                     BlockArgs::Written(_) => false,
                 };
@@ -501,7 +512,8 @@ impl Void<'_, '_> {
         if parent.is_some_and(|parent| {
             matches!(
                 parent.kind_str(),
-                "if" | "elsif" | "unless"
+                "if" | "elsif"
+                    | "unless"
                     | "if_modifier"
                     | "unless_modifier"
                     | "conditional"
@@ -549,10 +561,10 @@ impl Void<'_, '_> {
     /// `entirely_literal?`.
     fn entirely_literal(&self, node: Node<'_>) -> bool {
         match node.kind_str() {
-            "array" | "string_array" | "symbol_array" => named_children(node)
+            "array" | "string_array" | "symbol_array" => named_children_of(node, self.context)
                 .into_iter()
                 .all(|child| self.entirely_literal(child)),
-            "hash" => named_children(node)
+            "hash" => named_children_of(node, self.context)
                 .into_iter()
                 .filter(|child| child.kind_str() == "pair")
                 .all(|pair| {

data/src/rules/metrics/abc_size.rs

@@ -1,12 +1,16 @@
 //! `Metrics/AbcSize`, a port of `Utils::AbcSizeCalculator`.
 //!
-//! `CountRepeatedAttributes` is not read: the bundled configuration leaves it at `true`, which is
-//! what turns `Utils::RepeatedAttributeDiscount` off upstream, so the counting here is the counting
-//! every default run does. Setting it to `false` would ask for a discount this cop does not apply.
+//! `CountRepeatedAttributes` is `true` in the bundled configuration, which turns
+//! `Utils::RepeatedAttributeDiscount` off; [`Attributes`] is what a run setting it to `false` gets.
+
+use std::collections::HashMap;
+
+use tree_sitter::Node;
 
 use super::complexity::{Allowed, CsendDiscount, Emit, Kind, Order, Walk, measured};
 use crate::diagnostic::Offense;
 use crate::rules::RuleContext;
+use crate::rules::node_ext::NodeExt;
 
 pub(super) fn check(context: &RuleContext<'_>, offenses: &mut Vec<Offense>) {
     let max = context
@@ -21,8 +25,12 @@ pub(super) fn check(context: &RuleContext<'_>, offenses: &mut Vec<Offense>) {
     let fragments = context.fragments();
     let locals = context.metric_locals();
     let walk = Walk::new(context, locals, fragments, Order::Post);
+    // `discount_repeated_attributes: !cop_config['CountRepeatedAttributes']`.
+    let discounting = !context
+        .setting::<bool>("CountRepeatedAttributes")
+        .unwrap_or(true);
     for method in methods {
-        let vector = Vector::of(&walk, method.body);
+        let vector = Vector::of(&walk, method.body, context, locals, discounting);
         let size = vector.size();
         if size <= max {
             continue;
@@ -49,20 +57,47 @@ struct Vector {
 }
 
 impl Vector {
-    fn of(walk: &Walk<'_>, body: tree_sitter::Node<'_>) -> Self {
+    fn of(
+        walk: &Walk<'_>,
+        body: tree_sitter::Node<'_>,
+        context: &RuleContext<'_>,
+        locals: &super::locals::Locals,
+        discounting: bool,
+    ) -> Self {
         let mut vector = Self::default();
         let mut discount = CsendDiscount::default();
-        walk.run(body, &mut |emit| vector.count(emit, &mut discount));
+        let mut attributes = discounting.then(Attributes::default);
+        walk.run(body, &mut |emit| {
+            vector.count(emit, &mut discount, context, locals, attributes.as_mut());
+        });
         vector
     }
 
     /// `AbcSizeCalculator#calculate_node`, whose two arms are exclusive: a call is never also
     /// counted as a condition, though it may add one.
-    fn count<'a>(&mut self, emit: Emit<'a>, discount: &mut CsendDiscount<'a>) {
+    fn count<'a>(
+        &mut self,
+        emit: Emit<'a>,
+        discount: &mut CsendDiscount<'a>,
+        context: &RuleContext<'_>,
+        locals: &super::locals::Locals,
+        attributes: Option<&mut Attributes>,
+    ) {
+        // `RepeatedAttributeDiscount#calculate_node` invalidates before the count, so an
+        // assignment to a receiver does not discount the reads that follow it.
+        let repeated = match attributes {
+            Some(known) => {
+                known.invalidate(emit, context, locals);
+                matches!(emit.kind, Kind::Send | Kind::Csend)
+                    && known.repeats(emit.node, context, locals)
+            }
+            None => false,
+        };
         if self.assignment(emit, discount) {
             self.assignment += 1;
         }
         match emit.kind {
+            Kind::Send | Kind::Csend if repeated => {}
             Kind::Send | Kind::Csend | Kind::Yield => self.branch_node(emit, discount),
             // A block on a method that is known not to iterate is not a decision point.
             kind if is_condition(kind) && emit.iterating != Some(false) => {
@@ -275,3 +310,158 @@ fn scaled(value: u128, twos: i32, tens: i32) -> Option<u128> {
     let value = value.checked_mul(2u128.checked_pow(u32::try_from(twos).ok()?)?)?;
     value.checked_mul(10u128.checked_pow(u32::try_from(tens).ok()?)?)
 }
+
+/// `Utils::RepeatedAttributeDiscount`: the attribute reads already seen, so a second read of the
+/// same one is not counted as another branch.
+///
+/// Upstream keys the tree by the receiver node itself and makes the `nil` and `self` receivers
+/// share one entry, which is what lets `bar`, `self.bar` and `bar` count once between them. The
+/// keys here spell the same identity as a string.
+#[derive(Default)]
+struct Attributes {
+    tree: HashMap<String, Attributes>,
+}
+
+impl Attributes {
+    /// `discount_repeated_attribute?`: walks the receiver chain, recording what it has not seen.
+    /// True only when every step of the chain was already there.
+    fn repeats(
+        &mut self,
+        node: Node<'_>,
+        context: &RuleContext<'_>,
+        locals: &super::locals::Locals,
+    ) -> bool {
+        match key_path(node, context, locals) {
+            Some(path) => self.record(&path),
+            None => false,
+        }
+    }
+
+    fn record(&mut self, path: &[String]) -> bool {
+        let Some((head, rest)) = path.split_first() else {
+            return true;
+        };
+        let known = self.tree.contains_key(head);
+        let deeper = self.tree.entry(head.clone()).or_default().record(rest);
+        known & deeper
+    }
+
+    /// `update_repeated_attribute`: writing to a receiver invalidates what was read through it.
+    fn invalidate(
+        &mut self,
+        emit: Emit<'_>,
+        context: &RuleContext<'_>,
+        locals: &super::locals::Locals,
+    ) {
+        let Some((path, method)) = setter_to_getter(emit, context, locals) else {
+            return;
+        };
+        let Some(branch) = self.navigate(&path) else {
+            return;
+        };
+        match method {
+            Some(method) => drop(branch.tree.remove(&method)),
+            None => branch.tree.clear(),
+        }
+    }
+
+    fn navigate(&mut self, path: &[String]) -> Option<&mut Self> {
+        let mut current = self;
+        for key in path {
+            current = current.tree.get_mut(key)?;
+        }
+        Some(current)
+    }
+}
+
+/// `setter_to_getter`, as the receiver chain to invalidate and the one attribute under it -- or
+/// the whole branch, when a variable itself was written.
+fn setter_to_getter(
+    emit: Emit<'_>,
+    context: &RuleContext<'_>,
+    locals: &super::locals::Locals,
+) -> Option<(Vec<String>, Option<String>)> {
+    match emit.kind {
+        // `(lvasgn :my_var _)` and its three siblings: everything read through the name goes.
+        Kind::Lvasgn | Kind::Asgn => {
+            let target = emit.node.field("left")?;
+            Some((vec![root_key(target, context, locals)?], None))
+        }
+        // `foo.bar = 1` and `foo.bar ||= 1` both name one attribute of one receiver.
+        Kind::Send | Kind::Csend if emit.setter => {
+            let receiver = emit.node.field("receiver");
+            let method = context.source.node_text(emit.node.field("method")?);
+            let path = match receiver {
+                Some(receiver) => key_path(receiver, context, locals)?,
+                None => vec![ROOT.to_owned()],
+            };
+            Some((path, Some(method.trim_end_matches('=').to_owned())))
+        }
+        Kind::OpAsgn | Kind::OrAsgn | Kind::AndAsgn => {
+            let target = emit.node.field("left")?;
+            match target.kind_str() {
+                "call" => {
+                    let method = context.source.node_text(target.field("method")?);
+                    let path = match target.field("receiver") {
+                        Some(receiver) => key_path(receiver, context, locals)?,
+                        None => vec![ROOT.to_owned()],
+                    };
+                    Some((path, Some(method.to_owned())))
+                }
+                _ => Some((vec![root_key(target, context, locals)?], None)),
+            }
+        }
+        _ => None,
+    }
+}
+
+/// The entry `nil` and `self` share upstream, by sharing one hash between the two keys.
+const ROOT: &str = "self";
+
+/// `find_attributes`, flattened: the chain of names a read walks through, or `None` when the node
+/// is not a series of argument-less calls over a root the tree can key on.
+fn key_path(
+    node: Node<'_>,
+    context: &RuleContext<'_>,
+    locals: &super::locals::Locals,
+) -> Option<Vec<String>> {
+    if let Some(root) = root_key(node, context, locals) {
+        return Some(vec![root]);
+    }
+    match node.kind_str() {
+        // `attribute_call?` is `(call _receiver _method)` -- two children, so no arguments.
+        "call" if node.field("arguments").is_none() && node.field("block").is_none() => {
+            let method = context.source.node_text(node.field("method")?);
+            let mut path = match node.field("receiver") {
+                Some(receiver) => key_path(receiver, context, locals)?,
+                None => vec![ROOT.to_owned()],
+            };
+            path.push(method.to_owned());
+            Some(path)
+        }
+        // A bare name that is not a local is `(send nil :name)`.
+        "identifier" => Some(vec![
+            ROOT.to_owned(),
+            context.source.node_text(node).to_owned(),
+        ]),
+        _ => None,
+    }
+}
+
+/// `root_node?`: the receivers the tree keys on directly rather than walking through.
+fn root_key(
+    node: Node<'_>,
+    context: &RuleContext<'_>,
+    locals: &super::locals::Locals,
+) -> Option<String> {
+    let text = || context.source.node_text(node);
+    match node.kind_str() {
+        "self" => Some(ROOT.to_owned()),
+        "identifier" if locals.is_lvar(node) => Some(format!("lvar:{}", text())),
+        "instance_variable" => Some(format!("ivar:{}", text())),
+        "class_variable" => Some(format!("cvar:{}", text())),
+        "global_variable" => Some(format!("gvar:{}", text())),
+        "constant" | "scope_resolution" => Some(format!("const:{}", text())),
+        _ => None,
+    }
+}

data/src/rules/metrics/block_length.rs

@@ -7,10 +7,17 @@ use crate::rules::node_ext::NodeExt;
 
 pub(super) fn check(context: &RuleContext<'_>, offenses: &mut Vec<Offense>) {
     let max: usize = context.setting("Max").unwrap_or(25);
-    let allowed: Vec<String> = context.setting("AllowedMethods").unwrap_or_default();
+    let allowed = crate::rules::support::allowed_methods(context);
+    // `matches_allowed_pattern?(node.method_name)`: the patterns are matched against the method
+    // name alone, never against the receiver.
+    let patterns = crate::rules::naming::support::forbidden_patterns_named(context, "AllowedPatterns");
     let heredocs = HeredocEnds::new(context);
     for node in context.nodes_of_any(&["block", "do_block"]) {
-        if block_method_allowed(node, context, &allowed) || class_constructor(node, context) {
+        if block_method_allowed(node, context, &allowed)
+            || block_method_name(node, context)
+                .is_some_and(|name| patterns.iter().any(|pattern| pattern.is_match(name)))
+            || class_constructor(node, context)
+        {
             continue;
         }
         report_length(
@@ -40,13 +47,15 @@ fn block_method_name<'a>(node: Node<'_>, context: &'a RuleContext<'_>) -> Option
     )
 }
 
-fn block_receiver<'a>(node: Node<'_>, context: &'a RuleContext<'_>) -> Option<&'a str> {
-    let call = node.parent_of(context).filter(|parent| parent.kind_str() == "call")?;
-    Some(
-        context
-            .source
-            .node_text(call.field("receiver")?),
-    )
+/// `node.receiver&.source&.gsub(/\s+/, '')`: the receiver as written, with every run of
+/// whitespace removed -- a chain broken over lines (`Foo::\n  Bar.baz`) names the same receiver
+/// as the one written on a single line.
+fn block_receiver(node: Node<'_>, context: &RuleContext<'_>) -> Option<String> {
+    let call = node
+        .parent_of(context)
+        .filter(|parent| parent.kind_str() == "call")?;
+    let written = context.source.node_text(call.field("receiver")?);
+    Some(written.split_whitespace().collect())
 }
 
 /// `AllowedMethods` entries are either a bare method name or `Receiver.method`; the second form
@@ -58,7 +67,7 @@ fn block_method_allowed(node: Node<'_>, context: &RuleContext<'_>, allowed: &[St
     let receiver = block_receiver(node, context);
     allowed.iter().any(|entry| match entry.split_once('.') {
         Some((entry_receiver, entry_method)) => {
-            entry_method == method && Some(entry_receiver) == receiver
+            entry_method == method && receiver.as_deref() == Some(entry_receiver)
         }
         None => entry == method,
     })

data/src/rules/metrics/block_nesting.rs

@@ -127,8 +127,7 @@ fn clause_range(node: Node<'_>) -> Range<usize> {
 /// The `resbody` of `x rescue y`, which starts at the keyword and ends with the handler.
 fn modifier_clause(node: Node<'_>, handler: Node<'_>) -> Range<usize> {
     let mut cursor = node.walk();
-    let keyword = node
-        .children(&mut cursor)
+    let keyword = node.children(&mut cursor)
         .find(|child| !child.is_named() && child.kind_str() == "rescue")
         .map_or(node.start_byte(), |child| child.start_byte());
     keyword..handler.end_byte()

data/src/rules/metrics/class_length.rs

@@ -8,7 +8,12 @@ use crate::rules::node_ext::NodeExt;
 pub(super) fn check(context: &RuleContext<'_>, offenses: &mut Vec<Offense>) {
     let max: usize = context.setting("Max").unwrap_or(100);
     let heredocs = HeredocEnds::new(context);
-    for node in context.nodes_of_any(&["class", "singleton_class", "assignment"]) {
+    for node in context.nodes_of_any(&[
+        "class",
+        "singleton_class",
+        "assignment",
+        "operator_assignment",
+    ]) {
         let (measured, target) = match node.kind_str() {
             // A `class << self` inside a class body is part of that class's length rather than a
             // class of its own. Only `class` and `module` are classlike to `CodeLengthCalculator`,
@@ -17,8 +22,10 @@ pub(super) fn check(context: &RuleContext<'_>, offenses: &mut Vec<Offense>) {
             "class" => (node, LengthTarget::Classlike),
             // `CONST = Class.new { ... }` and `CONST = Struct.new(...) { ... }` are class
             // definitions written as expressions, which `Node#class_definition?` recognises and
-            // `on_casgn` measures here rather than as blocks.
-            "assignment" => match class_definition_block(context, node) {
+            // `on_casgn` measures here rather than as blocks. `CONST ||= Struct.new { ... }`
+            // reaches upstream the same way: the `casgn` has no expression of its own, so
+            // `find_expression_within_parent` reads the assignment wrapping it.
+            "assignment" | "operator_assignment" => match class_definition_block(context, node) {
                 Some(block) => (block, LengthTarget::Block),
                 None => continue,
             },
@@ -46,7 +53,12 @@ fn class_definition_block<'tree>(
     assignment: Node<'tree>,
 ) -> Option<Node<'tree>> {
     let target = assignment.field("left")?;
-    if !matches!(target.kind_str(), "constant" | "scope_resolution") {
+    // `Foo, Bar = Struct.new { ... }`: the `casgn` sits inside an `masgn` upstream, which
+    // `find_expression_within_parent` reads through.
+    if !matches!(
+        target.kind_str(),
+        "constant" | "scope_resolution" | "left_assignment_list"
+    ) {
         return None;
     }
     let call = assignment

data/src/rules/metrics/collection_literal_length.rs

@@ -6,6 +6,7 @@ use crate::diagnostic::Offense;
 use crate::rules::RuleContext;
 use crate::rules::node_ext::NodeExt;
 use crate::rules::send_node::{named_children, top_level_constant};
+use crate::rules::send_node::named_children_of;
 
 const MSG: &str = "Avoid hard coding large quantities of data in code. \
                    Prefer reading the data from an external source.";
@@ -46,7 +47,7 @@ pub(super) fn check(context: &RuleContext<'_>, offenses: &mut Vec<Offense>) {
         if !top_level_constant(object, "Set", context) || is_assignment_target(node) {
             continue;
         }
-        let children = named_children(node);
+        let children = named_children_of(node, context);
         let indices = children.get(1..).unwrap_or_default();
         if fold_pairs(indices).len() >= threshold {
             offenses.push(context.offense(MSG, node.byte_range()));

data/src/rules/metrics/complexity.rs

@@ -108,6 +108,9 @@ pub(super) enum Order {
 
 pub(super) struct Walk<'a> {
     source: &'a SourceFile,
+    /// The file's node index. The walk asks for a parent on every identifier it meets, and
+    /// `Node::parent` walks down from the root each time.
+    index: &'a super::super::AstIndex<'a>,
     locals: &'a Locals,
     fragments: &'a Fragments,
     order: Order,
@@ -122,6 +125,7 @@ impl<'a> Walk<'a> {
     ) -> Self {
         Self {
             source: context.source,
+            index: context.ast_index(),
             locals,
             fragments,
             order,
@@ -137,8 +141,18 @@ impl<'a> Walk<'a> {
     }
 
     fn children<F: FnMut(Emit<'a>)>(&self, node: Node<'a>, sink: &mut F) {
-        for child in named_children(node) {
-            self.visit(child, sink);
+        let mut cursor = node.walk();
+        if !cursor.goto_first_child() {
+            return;
+        }
+        loop {
+            let child = cursor.node();
+            if child.is_named() {
+                self.visit(child, sink);
+            }
+            if !cursor.goto_next_sibling() {
+                break;
+            }
         }
     }
 
@@ -694,9 +708,10 @@ impl<'a> Walk<'a> {
 
     fn visit_block_argument<F: FnMut(Emit<'a>)>(&self, node: Node<'a>, sink: &mut F) {
         let mut emit = Emit::of(Kind::BlockPass, node);
-        emit.iterating = node
-            .parent()
-            .and_then(|arguments| arguments.parent())
+        emit.iterating = self
+            .index
+            .parent(node)
+            .and_then(|arguments| self.index.parent(arguments))
             .filter(|call| call.kind_str() == "call")
             .and_then(|call| self.iterating_call(call));
         self.around(emit, sink, |walk, sink| walk.children(node, sink));
@@ -819,9 +834,32 @@ impl<'a> Walk<'a> {
 
     /// Whether the identifier stands where the parser would have built `(send nil :name)`.
     fn receiverless_call(&self, node: Node<'_>) -> bool {
-        is_receiverless_call(node)
+        is_receiverless_call(node, self.index)
             && !self.locals.is_lvar(node)
             && !is_keyword_literal(self.text(node))
+            && !self.is_implicit_block_parameter(node)
+    }
+
+    /// `it` inside a block that declares no parameters is that block's parameter -- an `itblock`
+    /// upstream, where the name is a variable rather than a call.
+    fn is_implicit_block_parameter(&self, node: Node<'_>) -> bool {
+        if self.text(node) != "it" {
+            return false;
+        }
+        let mut current = self.index.parent(node);
+        while let Some(parent) = current {
+            if matches!(parent.kind_str(), "block" | "do_block") {
+                return parent.field("parameters").is_none();
+            }
+            if matches!(
+                parent.kind_str(),
+                "method" | "singleton_method" | "class" | "module" | "lambda"
+            ) {
+                return false;
+            }
+            current = self.index.parent(parent);
+        }
+        false
     }
 
     /// Whether a block takes its parameters implicitly through `_1`, which makes it a `numblock`
@@ -986,7 +1024,7 @@ pub(super) struct Allowed {
 
 impl Allowed {
     pub(super) fn new(context: &RuleContext<'_>) -> Self {
-        let methods: Vec<String> = context.setting("AllowedMethods").unwrap_or_default();
+        let methods = crate::rules::support::allowed_methods(context);
         let patterns: Vec<String> = context.setting("AllowedPatterns").unwrap_or_default();
         Self {
             methods,
@@ -1058,14 +1096,14 @@ fn collect_targets<'a>(node: Node<'a>, targets: &mut Vec<Node<'a>>) {
 
 /// Whether the identifier stands where the parser would have built `(send nil :name)` rather than
 /// a name being declared, written or called on something else.
-fn is_receiverless_call(node: Node<'_>) -> bool {
-    let Some(parent) = node.parent() else {
+fn is_receiverless_call(node: Node<'_>, index: &super::super::AstIndex<'_>) -> bool {
+    let Some(parent) = index.parent(node) else {
         return true;
     };
     match parent.kind_str() {
-        "call" => field_name(node, parent) != Some("method"),
-        "method" | "singleton_method" => field_name(node, parent) != Some("name"),
-        "assignment" | "operator_assignment" => field_name(node, parent) != Some("left"),
+        "call" => field_name(node, parent, index) != Some("method"),
+        "method" | "singleton_method" => field_name(node, parent, index) != Some("name"),
+        "assignment" | "operator_assignment" => field_name(node, parent, index) != Some("left"),
         "left_assignment_list"
         | "rest_assignment"
         | "destructured_left_assignment"
@@ -1081,8 +1119,8 @@ fn is_receiverless_call(node: Node<'_>) -> bool {
         | "keyword_parameter"
         | "splat_parameter"
         | "hash_splat_parameter"
-        | "block_parameter" => field_name(node, parent) != Some("name"),
-        "for" => field_name(node, parent) != Some("pattern"),
+        | "block_parameter" => field_name(node, parent, index) != Some("name"),
+        "for" => field_name(node, parent, index) != Some("pattern"),
         _ => true,
     }
 }