sonicop 26.8.111 → 26.8.113

data/src/rules/style/sample.rs

@@ -79,7 +79,7 @@ pub(super) fn check(context: &RuleContext<'_>, offenses: &mut Vec<Offense>) {
 /// `(call $_ ${:first :last :[] :at :slice} $...)`: the receiver, the selector's name and the
 /// arguments of a call that takes one element out of a collection.
 fn indexing<'tree>(
-    context: &RuleContext<'_>,
+    context: &'tree RuleContext<'_>,
     node: Node<'tree>,
 ) -> Option<(Node<'tree>, &'static str, Vec<Argument<'tree>>)> {
     if node.kind_str() == "element_reference" {
@@ -101,7 +101,7 @@ fn indexing<'tree>(
     };
     let written = node
         .field("arguments")
-        .map(|list| super::nodes::children(list))
+        .map(|list| super::nodes::children_in(list, context))
         .unwrap_or_default();
     Some((receiver, method, group(&written)))
 }
@@ -128,7 +128,7 @@ fn shuffle_call(
     }
     let written = node
         .field("arguments")
-        .map(|list| super::nodes::children(list))
+        .map(|list| super::nodes::children_in(list, context))
         .unwrap_or_default();
     let first = group(&written)
         .first()

data/src/rules/style/select_by.rs

@@ -107,6 +107,10 @@ fn receiver_allowed(receiver: Option<Node<'_>>, context: &RuleContext<'_>) -> bo
     };
     match receiver.kind_str() {
         "hash" => true,
+        // `(call _ {:to_h :to_hash} ...)` matches a receiverless call too -- `to_h.reject { … }`
+        // is `(send (send nil :to_h) :reject)`. The grammar writes a bare name as an `identifier`,
+        // which fell through to "not a hash".
+        "identifier" => matches!(context.source.node_text(receiver), "to_h" | "to_hash"),
         // `env_const?`: `(const {nil? cbase} :ENV)`.
         "constant" => context.source.node_text(receiver) == "ENV",
         "scope_resolution" => {
@@ -150,7 +154,7 @@ fn is_hash_constant(node: Node<'_>, context: &RuleContext<'_>) -> bool {
 /// an `itblock` reading `it`.
 fn block_argument(context: &RuleContext<'_>, block: Node<'_>) -> Option<String> {
     if let Some(parameters) = block.field("parameters") {
-        let declared = super::nodes::children(parameters);
+        let declared = super::nodes::children_in(parameters, context);
         let [only] = declared.as_slice() else {
             return None;
         };
@@ -170,7 +174,7 @@ fn block_argument(context: &RuleContext<'_>, block: Node<'_>) -> Option<String>
 /// How many numbered parameters the body reads, and whether it reads `it`. A nested block's names
 /// belong to that block, not to this one.
 fn scan_implicit(context: &RuleContext<'_>, node: Node<'_>, numbered: &mut usize, it: &mut bool) {
-    for child in super::nodes::children(node) {
+    for child in super::nodes::children_in(node, context) {
         if matches!(child.kind_str(), "block" | "do_block" | "lambda") {
             continue;
         }

data/src/rules/style/select_by_range.rs

@@ -140,7 +140,7 @@ fn find_range(statement: Node<'_>, context: &RuleContext<'_>) -> Option<String>
     }
     let receiver = inner.field("receiver")?;
     let receiver = match receiver.kind_str() {
-        "parenthesized_statements" => super::nodes::children(receiver).first().copied()?,
+        "parenthesized_statements" => super::nodes::children_in(receiver, context).first().copied()?,
         _ => receiver,
     };
     Some(context.source.node_text(receiver).to_owned())

data/src/rules/style/semicolon.rs

@@ -2,9 +2,10 @@ use std::collections::HashSet;
 
 use crate::diagnostic::{Edit, Offense};
 use crate::rules::RuleContext;
+use crate::rules::node_ext::NodeExt;
 use crate::rules::support::Interpolations;
 use crate::source::is_protected;
-use crate::rules::node_ext::NodeExt;
+use crate::rules::send_node::named_children_iter;
 
 /// Node kinds whose named children are a sequence of statements.
 ///
@@ -39,7 +40,6 @@ const NON_STATEMENT_KINDS: &[&str] = &["comment", "empty_statement", "rescue", "
 /// walks a token stream rather than the text, so none of these is a semicolon to it.
 const SEMICOLON_BEARING_TOKENS: &[&str] = &["global_variable", "character", "delimited_symbol"];
 
-
 pub(super) fn check(context: &RuleContext<'_>, offenses: &mut Vec<Offense>) {
     let text = context.source.text();
     if !text.contains(';') {
@@ -113,6 +113,23 @@ pub(super) fn check(context: &RuleContext<'_>, offenses: &mut Vec<Offense>) {
         // `corrector.wrap(node, '(', ')') if node`: an endless range whose `;` goes away would
         // reach on to the next line and swallow it (`42..;\n42...;` becomes one range). Upstream
         // puts parentheses around the range first.
+        // `token_before_semicolon&.type == :tLABEL`: `m key:;` has to keep reading as an argument
+        // list once the semicolon goes, so the hash gains parentheses and the space in front of it
+        // is removed. Without it `m key:` is a label standing on its own.
+        if let Some((space, arguments)) = value_omission_before(context, offset) {
+            offenses.push(offense.corrected_by_all([
+                Edit {
+                    start: space.start,
+                    end: space.end,
+                    replacement: String::new(),
+                    safe: true,
+                },
+                insert(arguments.start, "("),
+                insert(arguments.end, ")"),
+                removal,
+            ]));
+            continue;
+        }
         if let Some(range) = endless_range_before(context, offset) {
             offenses.push(offense.corrected_by_all([
                 insert(range.start, "("),
@@ -207,6 +224,12 @@ fn line_terminator_or_opener(
     if after_last == "}" {
         return Some(last);
     }
+    // `exist_semicolon_before_right_string_interpolation_brace?`: the `}` closing an interpolation
+    // is a `tSTRING_DEND`, and the string it sits in goes on past it -- so the line does not end
+    // there, but the semicolon still terminates the last expression of the interpolation.
+    if closes_an_interpolation(context, last) {
+        return Some(last);
+    }
     let before_first = text[code.start..first].trim_end();
     if before_first.ends_with('{') {
         return Some(first);
@@ -214,6 +237,17 @@ fn line_terminator_or_opener(
     None
 }
 
+/// Whether the first thing after the semicolon is the brace that closes an interpolation.
+fn closes_an_interpolation(context: &RuleContext<'_>, semicolon: usize) -> bool {
+    let text = context.source.text();
+    let rest = &text[semicolon + 1..];
+    let brace = semicolon + 1 + (rest.len() - rest.trim_start().len());
+    text[brace..].starts_with('}')
+        && context
+            .nodes_of("interpolation")
+            .any(|node| node.end_byte() == brace + 1)
+}
+
 /// The byte range of `line_number` with comments and surrounding whitespace removed.
 fn code_range(context: &RuleContext<'_>, line_number: usize) -> Option<std::ops::Range<usize>> {
     let text = context.source.text();
@@ -235,8 +269,8 @@ fn code_range(context: &RuleContext<'_>, line_number: usize) -> Option<std::ops:
 fn expression_separator_lines(context: &RuleContext<'_>) -> HashSet<usize> {
     let mut lines = HashSet::new();
     for node in context.nodes_of_any(STATEMENT_SEQUENCE_KINDS) {
-        let mut cursor = node.walk();
-        let children: Vec<_> = node.named_children(&mut cursor).collect();
+        let _cursor = node.walk();
+        let children: Vec<_> = named_children_iter(node, context).collect();
         // `begin ... end` holds its statements directly upstream rather than wrapping them in the
         // `begin` node the cop looks for, so `begin a; b end` is not an offense. Add a `rescue` and
         // the protected body becomes such a node after all.
@@ -295,3 +329,42 @@ fn heredoc_opened_before(
         .iter()
         .any(|(line, end)| *line == line_number && *end <= offset)
 }
+
+/// The space to drop and the span to bracket when the semicolon follows a value-omitted label.
+///
+/// `value_omission_pair_nodes` upstream; the pair's grandparent is the call whose selector the
+/// space belongs to.
+fn value_omission_before(
+    context: &RuleContext<'_>,
+    offset: usize,
+) -> Option<(std::ops::Range<usize>, std::ops::Range<usize>)> {
+    let before = context.source.text()[..offset].trim_end().len();
+    for pair in context.nodes_of("pair") {
+        if pair.field("value").is_some() || pair.end_byte() != before {
+            continue;
+        }
+        let list = pair.parent()?;
+        if list.kind_str() != "argument_list" {
+            continue;
+        }
+        let call = list.parent()?;
+        if call.kind_str() != "call" {
+            continue;
+        }
+        let selector = call.field("method")?;
+        // A call already written with brackets needs neither edit.
+        if list
+            .child(0)
+            .is_some_and(|first| context.source.node_text(first) == "(")
+        {
+            continue;
+        }
+        let _cursor = list.walk();
+        let first = named_children_iter(list, context).next()?;
+        return Some((
+            selector.end_byte()..first.start_byte(),
+            first.start_byte()..list.end_byte(),
+        ));
+    }
+    None
+}

data/src/rules/style/signal_exception.rs

@@ -3,18 +3,20 @@ use tree_sitter::Node;
 use crate::diagnostic::{Edit, Offense};
 use crate::rules::RuleContext;
 use crate::rules::lint::locals::LocalVariables;
-use crate::rules::send_node::{is_plain_send, top_level_constant};
 use crate::rules::node_ext::NodeExt;
+use crate::rules::send_node::{is_plain_send, top_level_constant};
+
+const FAIL_MSG: &str = "Use `fail` instead of `raise` to signal exceptions.";
+const RAISE_MSG: &str = "Use `raise` instead of `fail` to rethrow exceptions.";
 
 pub(super) fn check(context: &RuleContext<'_>, offenses: &mut Vec<Offense>) {
     let style = context
         .setting::<String>("EnforcedStyle")
         .unwrap_or_else(|| "only_raise".to_owned());
-    // `:semantic` decides per rescue clause which of the two words belongs where; it is not the
-    // default and is left to the pass that ports `on_rescue`.
     let (looked_for, preferred) = match style.as_str() {
         "only_raise" => ("fail", "raise"),
         "only_fail" => ("raise", "fail"),
+        "semantic" => return check_semantic(context, offenses),
         _ => return,
     };
     // `custom_fail_defined?`: a file that defines its own `fail` is not talking about `Kernel#fail`.
@@ -45,6 +47,61 @@ pub(super) fn check(context: &RuleContext<'_>, offenses: &mut Vec<Offense>) {
     }
 }
 
+/// `:semantic`: `raise` belongs inside a rescue clause and `fail` everywhere else.
+///
+/// Upstream reaches the same split from two directions -- `on_rescue` walks the body for `raise`
+/// and each `resbody` for `fail`, while `on_send` catches every remaining `raise` -- with
+/// `ignore_node` keeping the two from reporting the same call twice. Asking each call where it
+/// sits gives the same set without the bookkeeping: a call under a `rescue` clause's body may say
+/// `raise`, and one anywhere else may say `fail`.
+fn check_semantic(context: &RuleContext<'_>, offenses: &mut Vec<Offense>) {
+    let locals = LocalVariables::new(context);
+    for node in context.nodes_of_any(&["call", "identifier"]) {
+        if !is_plain_send(node, context) {
+            continue;
+        }
+        let rescuing = inside_rescue_body(node);
+        let looked_for = match rescuing {
+            true => "fail",
+            false => "raise",
+        };
+        let Some(selector) = signal_selector(node, looked_for, context, &locals) else {
+            continue;
+        };
+        let (message, preferred) = match rescuing {
+            true => (RAISE_MSG, "raise"),
+            false => (FAIL_MSG, "fail"),
+        };
+        offenses.push(
+            context
+                .offense(message, selector.byte_range())
+                .corrected_by(Edit {
+                    start: selector.start_byte(),
+                    end: selector.end_byte(),
+                    replacement: preferred.to_owned(),
+                    safe: true,
+                }),
+        );
+    }
+}
+
+/// Whether the call sits in the body of a `rescue` clause -- not in the exception list or the
+/// `=> e` binding, which are part of the same node but not part of the clause's body.
+fn inside_rescue_body(node: Node<'_>) -> bool {
+    let mut current = node;
+    while let Some(parent) = current.parent() {
+        if parent.kind_str() == "rescue"
+            && parent.field("body").is_some_and(|body| {
+                body.start_byte() <= node.start_byte() && node.end_byte() <= body.end_byte()
+            })
+        {
+            return true;
+        }
+        current = parent;
+    }
+    false
+}
+
 /// `command_or_kernel_call?`: the `raise` / `fail` token of a receiverless call or of one made
 /// through `Kernel`.
 fn signal_selector<'tree>(

data/src/rules/style/single_argument_dig.rs

@@ -107,8 +107,16 @@ fn is_dig(context: &RuleContext<'_>, node: Node<'_>) -> bool {
     let Some(arguments) = node.field("arguments") else {
         return false;
     };
-    let arguments = super::nodes::children(arguments);
-    !arguments.is_empty()
+    let arguments = super::nodes::children_in(arguments, context);
+    // `(call _ :dig !{hash block_pass}+)`: at least one argument that is neither a hash nor a
+    // block pass. The grammar spells a brace-less hash as its own pairs and splats, and an
+    // anonymous `**` as a lone `hash_splat_argument` -- all of them one `hash` upstream.
+    arguments.iter().any(|argument| {
+        !matches!(
+            argument.kind_str(),
+            "hash" | "pair" | "hash_splat_argument" | "block_argument"
+        )
+    })
         && arguments
             .iter()
             .all(|argument| !matches!(argument.kind_str(), "hash" | "pair" | "block_argument"))

data/src/rules/style/single_line_block_params.rs

@@ -6,6 +6,7 @@ use crate::diagnostic::{Edit, Offense};
 use crate::rules::RuleContext;
 use crate::rules::lint::locals::LocalVariables;
 use crate::rules::node_ext::NodeExt;
+use crate::rules::send_node::all_children_of;
 
 /// One entry of `Methods`, which upstream writes as a list of single-key hashes.
 type Methods = Vec<HashMap<String, Vec<String>>>;
@@ -43,11 +44,20 @@ pub(super) fn check(context: &RuleContext<'_>, offenses: &mut Vec<Offense>) {
         let Some(list) = block.field("parameters") else {
             continue;
         };
-        // `eligible_arguments?`: every parameter has to be a plain one.
-        let written = super::nodes::children(list);
+        // `eligible_arguments?`: every parameter has to be a plain one. A block-local written
+        // after a `;` is a `shadowarg` upstream, which fails `arg_type?` -- the grammar spells it
+        // as another identifier in the same list and marks it only by the separator.
+        let written = super::nodes::children_in(list, context);
         if written.is_empty() || written.iter().any(|arg| arg.kind_str() != "identifier") {
             continue;
         }
+        let _cursor = list.walk();
+        if all_children_of(list, context)
+            .into_iter()
+            .any(|child| !child.is_named() && child.kind_str() == ";")
+        {
+            continue;
+        }
         let names: Vec<&str> = written
             .iter()
             .map(|arg| context.source.node_text(*arg))
@@ -116,12 +126,12 @@ fn rename_reads(
     locals: &LocalVariables<'_, '_>,
     edits: &mut Vec<Edit>,
 ) {
-    let mut stack: Vec<Node<'_>> = super::nodes::children(node)
+    let mut stack: Vec<Node<'_>> = super::nodes::children_in(node, context)
         .into_iter()
         .filter(|child| child.kind_str() != "block_parameters")
         .collect();
     while let Some(current) = stack.pop() {
-        stack.extend(super::nodes::children(current));
+        stack.extend(super::nodes::children_in(current, context));
         if current.kind_str() != "identifier" || !locals.is_lvar(current) {
             continue;
         }

data/src/rules/style/single_line_do_end_block.rs

@@ -6,6 +6,8 @@ use crate::diagnostic::{Edit, Offense};
 use crate::rules::RuleContext;
 use crate::rules::node_ext::NodeExt;
 use crate::rules::send_node::heredoc_body;
+use crate::rules::send_node::named_children_of;
+use crate::rules::send_node::all_children_of;
 
 const MSG: &str = "Prefer multiline `do`...`end` block.";
 
@@ -82,14 +84,14 @@ pub(super) fn check(context: &RuleContext<'_>, offenses: &mut Vec<Offense>) {
 /// any and after the `do` when it does not.
 fn do_line(context: &RuleContext<'_>, block: Node<'_>) -> Option<usize> {
     if let Some(parameters) = block.field("parameters")
-        && !super::nodes::children(parameters).is_empty()
+        && !super::nodes::children_in(parameters, context).is_empty()
     {
         return Some(parameters.end_byte());
     }
     let _ = context;
-    let mut cursor = block.walk();
-    block
-        .children(&mut cursor)
+    let _cursor = block.walk();
+    all_children_of(block, context)
+        .into_iter()
         .find(|child| child.kind_str() == "do")
         .map(|token| token.end_byte())
 }
@@ -97,8 +99,7 @@ fn do_line(context: &RuleContext<'_>, block: Node<'_>) -> Option<usize> {
 /// `node.loc.end`.
 fn end_keyword<'tree>(block: Node<'tree>) -> Option<Node<'tree>> {
     let mut cursor = block.walk();
-    block
-        .children(&mut cursor)
+    block.children(&mut cursor)
         .find(|child| child.kind_str() == "end")
 }
 
@@ -110,9 +111,9 @@ fn trailing_heredoc(context: &RuleContext<'_>, block: Node<'_>) -> Option<usize>
         if node.kind_str() == "heredoc_beginning"
             && let Some(body) = heredoc_body(node, context)
         {
-            let mut cursor = body.walk();
-            if let Some(terminator) = body
-                .named_children(&mut cursor)
+            let _cursor = body.walk();
+            if let Some(terminator) = named_children_of(body, context)
+                .into_iter()
                 .find(|child| child.kind_str() == "heredoc_end")
             {
                 last = Some(last.map_or(terminator.end_byte(), |end: usize| {
@@ -120,7 +121,7 @@ fn trailing_heredoc(context: &RuleContext<'_>, block: Node<'_>) -> Option<usize>
                 }));
             }
         }
-        crate::rules::push_named_children(node, &mut stack);
+        crate::rules::push_named_children_in(node, context, &mut stack);
     }
     last
 }
@@ -200,7 +201,7 @@ fn comment_within(context: &RuleContext<'_>, node: Node<'_>) -> bool {
 /// `safe_to_split?`.
 fn safe_to_split(context: &RuleContext<'_>, node: Node<'_>) -> bool {
     let mut stack: Vec<Node<'_>> = Vec::new();
-    crate::rules::push_named_children(node, &mut stack);
+    crate::rules::push_named_children_in(node, context, &mut stack);
     while let Some(child) = stack.pop() {
         if UNSAFE_TO_SPLIT.contains(&child.kind_str()) {
             return false;
@@ -220,7 +221,7 @@ fn safe_to_split(context: &RuleContext<'_>, node: Node<'_>) -> bool {
         {
             return false;
         }
-        crate::rules::push_named_children(child, &mut stack);
+        crate::rules::push_named_children_in(child, context, &mut stack);
     }
     true
 }

data/src/rules/style/single_line_methods.rs

@@ -164,7 +164,7 @@ fn endless_correction(context: &RuleContext<'_>, node: Node<'_>, body: &Body) ->
         .map_or("", |name| context.source.node_text(name));
     let arguments = node.field("parameters").map_or_else(
         || "()".to_owned(),
-        |list| match super::nodes::children(list).is_empty() {
+        |list| match super::nodes::children_in(list, context).is_empty() {
             true => "()".to_owned(),
             false => context.source.node_text(list).to_owned(),
         },
@@ -198,7 +198,7 @@ fn method_body_source(context: &RuleContext<'_>, node: Node<'_>, body: &Body) ->
     let (receiver, name, arguments) = match expression.kind_str() {
         "call" => {
             let list = expression.field("arguments")?;
-            let arguments = super::nodes::children(list);
+            let arguments = super::nodes::children_in(list, context);
             if arguments.is_empty() {
                 return None;
             }

data/src/rules/style/slicing_with_range.rs

@@ -62,7 +62,7 @@ struct Slice<'tree> {
 }
 
 impl<'tree> Slice<'tree> {
-    fn read(node: Node<'tree>, context: &RuleContext<'_>) -> Option<Self> {
+    fn read(node: Node<'tree>, context: &'tree RuleContext<'_>) -> Option<Self> {
         match node.kind_str() {
             "element_reference" => {
                 // `ary[0..-1] = x` is a call to `:[]=`, which the cop does not restrict itself to.
@@ -70,7 +70,7 @@ impl<'tree> Slice<'tree> {
                 if is_assignment_target(node) {
                     return None;
                 }
-                let children = super::nodes::children(node);
+                let children = super::nodes::children_in(node, context);
                 let [_, argument] = children.as_slice() else {
                     return None;
                 };

data/src/rules/style/sole_nested_conditional.rs

@@ -118,7 +118,7 @@ fn use_variable_assignment_in_condition(
         return false;
     };
     let inner_source = context.source.node_text(inner);
-    super::conditional::descendants(condition)
+    super::conditional::descendants(condition, context)
         .into_iter()
         .filter(|descendant| descendant.kind_str() == "assignment")
         .filter_map(|assignment| assignment.field("left"))
@@ -399,7 +399,7 @@ fn add_parentheses(context: &RuleContext<'_>, node: Node<'_>) -> bool {
 /// `assignment_in_and?`.
 fn assignment_in_and(context: &RuleContext<'_>, node: Node<'_>) -> bool {
     is_and(context, node)
-        && super::conditional::descendants(node)
+        && super::conditional::descendants(node, context)
             .into_iter()
             .skip(1)
             .any(|descendant| matches!(descendant.kind_str(), "assignment" | "operator_assignment"))
@@ -413,7 +413,7 @@ fn call_shape(context: &RuleContext<'_>, node: Node<'_>) -> Option<(bool, bool,
             let arguments = node.field("arguments");
             let parenthesized =
                 arguments.is_some_and(|list| context.source.node_text(list).starts_with('('));
-            let any = arguments.is_some_and(|list| !super::nodes::children(list).is_empty());
+            let any = arguments.is_some_and(|list| !super::nodes::children_in(list, context).is_empty());
             Some((any, parenthesized, false))
         }
         // `a[0]` is `(send a :[] 0)`: an argument, and no parentheses around it.
@@ -469,7 +469,7 @@ fn parenthesized_method_arguments(context: &RuleContext<'_>, node: Node<'_>) ->
         return context.source.node_text(node).to_owned();
     };
     let call = context.source.slice(node.start_byte()..selector.end_byte());
-    let first = super::nodes::children(arguments)
+    let first = super::nodes::children_in(arguments, context)
         .first()
         .map_or(arguments.start_byte(), Node::start_byte);
     let rest = context.source.slice(first..node.end_byte());

data/src/rules/style/special_global_vars.rs

@@ -204,9 +204,9 @@ fn is_lone_begin(context: &RuleContext<'_>, node: Node<'_>) -> bool {
         // `"#$!"` interpolates without a `begin`: upstream hangs the global off the `dstr` itself.
         "interpolation" => {
             context.source.node_text(node).starts_with("#{")
-                && super::nodes::children(node).len() == 1
+                && super::nodes::children_in(node, context).len() == 1
         }
-        "parenthesized_statements" => super::nodes::children(node).len() == 1,
+        "parenthesized_statements" => super::nodes::children_in(node, context).len() == 1,
         _ => false,
     }
 }

data/src/rules/style/stabby_lambda_parentheses.rs

@@ -17,7 +17,7 @@ pub(super) fn check(context: &RuleContext<'_>, offenses: &mut Vec<Offense>) {
         let Some(parameters) = node.field("parameters") else {
             continue;
         };
-        if super::nodes::children(parameters).is_empty() {
+        if super::nodes::children_in(parameters, context).is_empty() {
             continue;
         }
         let text = context.source.node_text(parameters);

data/src/rules/style/statement_modifier.rs

@@ -7,12 +7,13 @@ use tree_sitter::Node;
 
 use super::conditional::descendants;
 use super::nodes;
+use crate::rules::RuleContext;
 use crate::rules::node_ext::NodeExt;
 
 /// `condition.each_node.any?(&:lvasgn_type?)`: a condition that binds a local cannot move behind
 /// the body that reads it.
-pub(super) fn non_eligible_condition(condition: Node<'_>) -> bool {
-    descendants(condition).into_iter().any(|node| {
+pub(super) fn non_eligible_condition(condition: Node<'_>, context: &RuleContext<'_>) -> bool {
+    descendants(condition, context).into_iter().any(|node| {
         matches!(node.kind_str(), "assignment" | "operator_assignment")
             && node.field("left").is_some_and(binds_local)
     })

data/src/rules/style/static_class.rs

@@ -111,6 +111,12 @@ fn convertible(node: Node<'_>, context: &RuleContext<'_>) -> bool {
         "call" => node
             .field("method")
             .is_some_and(|selector| context.source.node_text(selector) == "extend"),
+        // A receiverless call with no arguments is a bare name to the grammar and a `send`
+        // upstream, which `extend_call?` answers to just the same.
+        "identifier" => {
+            context.source.node_text(node) == "extend"
+                && !context.variable_analysis().is_variable_reference(node)
+        }
         _ => false,
     }
 }
@@ -135,7 +141,7 @@ fn is_public(node: Node<'_>, context: &RuleContext<'_>) -> bool {
     let Some(parent) = node.parent() else {
         return true;
     };
-    let siblings = super::nodes::children(parent);
+    let siblings = super::nodes::children_in(parent, context);
     let Some(position) = siblings.iter().position(|child| child.id() == node.id()) else {
         return true;
     };

data/src/rules/style/string_concatenation.rs

@@ -10,6 +10,8 @@ use crate::rules::send_node::is_plain_send;
 
 use super::literal::{self, Quoting};
 use crate::rules::node_ext::NodeExt;
+use crate::rules::send_node::all_children_of;
+use crate::rules::send_node::all_children_iter;
 
 const MSG: &str = "Prefer string interpolation to string concatenation.";
 
@@ -240,7 +242,7 @@ fn adjust_str(context: &RuleContext<'_>, node: Node<'_>, encoding: LiteralEncodi
         },
         // `'a' 'b'`, `(...)` and `#{...}` are all a list of children upstream.
         "chained_string" | "parenthesized_statements" | "interpolation" => {
-            super::nodes::children(node)
+            super::nodes::children_in(node, context)
                 .into_iter()
                 .map(|child| adjust_str(context, child, encoding))
                 .collect()
@@ -322,11 +324,11 @@ struct Interpolated<'tree> {
 /// The children upstream's `dstr` holds, or `None` when the literal has no interpolation and is a
 /// plain `str`.
 fn interpolated<'tree>(
-    context: &RuleContext<'_>,
+    context: &'tree RuleContext<'_>,
     node: Node<'tree>,
 ) -> Option<Interpolated<'tree>> {
-    let mut cursor = node.walk();
-    let children: Vec<Node<'tree>> = node.children(&mut cursor).collect();
+    let _cursor = node.walk();
+    let children: Vec<Node<'tree>> = all_children_iter(node, context).collect();
     if !children.iter().any(|child| child.kind_str() == "interpolation") {
         return None;
     }
@@ -424,6 +426,9 @@ impl Heredocs {
             "string" => interpolated(context, node).is_none() && written_on_one_line(context, node),
             "character" => true,
             "heredoc_beginning" => self.plain.get(&node.id()).copied().unwrap_or(false),
+            // The parser resolves `__FILE__` to the path it stands for, which is a `str`. The
+            // grammar leaves it an identifier.
+            "identifier" => context.source.node_text(node) == "__FILE__",
             _ => false,
         }
     }
@@ -472,9 +477,9 @@ fn body_is_str(context: &RuleContext<'_>, body: Node<'_>) -> bool {
     if has_interpolation_descendant(body) {
         return false;
     }
-    let mut cursor = body.walk();
-    let end = body
-        .children(&mut cursor)
+    let _cursor = body.walk();
+    let end = all_children_of(body, context)
+        .into_iter()
         .find(|child| child.kind_str() == "heredoc_end")
         .map_or(body.end_byte(), |terminator| terminator.start_byte());
     let text = &context.source.text()[body.start_byte()..end];

data/src/rules/style/string_hash_keys.rs

@@ -5,6 +5,7 @@ use crate::rules::RuleContext;
 use crate::rules::node_ext::NodeExt;
 use crate::rules::ruby_literal;
 use crate::rules::send_node;
+use crate::rules::send_node::named_children_iter;
 
 const MSG: &str = "Prefer symbols instead of strings as hash keys.";
 
@@ -62,8 +63,8 @@ pub(super) fn check(context: &RuleContext<'_>, offenses: &mut Vec<Offense>) {
 /// for the replacement resolves such an escape to a character, which loses the distinction.
 fn is_valid_encoding(key: Node<'_>, context: &RuleContext<'_>) -> bool {
     let mut bytes: Vec<u8> = Vec::new();
-    let mut cursor = key.walk();
-    for child in key.named_children(&mut cursor) {
+    let _cursor = key.walk();
+    for child in named_children_iter(key, context) {
         let text = context.source.node_text(child);
         match raw_byte(text).filter(|_| child.kind_str() == "escape_sequence") {
             Some(byte) => bytes.push(byte),