sonicop 26.8.111 → 26.8.113

data/src/rules/style/redundant_parentheses.rs

@@ -7,6 +7,7 @@ use crate::rules::lint::locals::LocalVariables;
 
 use super::conditional::{UpstreamParent, upstream_parent};
 use crate::rules::node_ext::NodeExt;
+use crate::rules::send_node::all_children_iter;
 
 /// `ALLOWED_NODE_TYPES`: the parents whose child keeps its parentheses around a logical operator.
 /// `send` covers every shape the grammar spells as a call.
@@ -73,6 +74,31 @@ pub(super) fn check(context: &RuleContext<'_>, offenses: &mut Vec<Offense>) {
         }
         check_group(context, &locals, node, &mut pending);
     }
+    // **`^(var)` is a `pin` holding a `begin` upstream**, so the parentheses are a node the walk
+    // above would find. The grammar writes them as part of the pin itself, which leaves
+    // `allowed_pin_operator?` -- `^(pin (begin !{lvar ivar cvar gvar}))` -- as the only thing to
+    // say about them: a pinned variable is reported, anything else is left alone.
+    for node in context.nodes_of("expression_reference_pattern") {
+        let Some(value) = node.field("value") else {
+            continue;
+        };
+        if !is_variable(context, &locals, value) {
+            continue;
+        }
+        let Some(range) = pinned_parentheses(node, context) else {
+            continue;
+        };
+        offenses.push(
+            context
+                .offense("Don't use parentheses around a variable.", range.clone())
+                .corrected_by(crate::diagnostic::Edit {
+                    start: range.start,
+                    end: range.end,
+                    replacement: context.source.node_text(value).to_owned(),
+                    safe: true,
+                }),
+        );
+    }
     // `on_investigation_end`: each candidate's exact correction is verified by reparsing before the
     // offense is registered, so redundancy never rests on a hand-kept list of the grammar's rules.
     let verified = crate::rules::support::verified_by_reparse(
@@ -168,7 +194,7 @@ fn parent_child_count(context: &RuleContext<'_>, node: Node<'_>) -> usize {
     match parent {
         UpstreamParent::Begin(parent) => match parent.kind_str() {
             "parenthesized_statements" | "interpolation" | "begin" => {
-                super::nodes::children(parent).len()
+                super::nodes::children_in(parent, context).len()
             }
             // A statement list the grammar wraps -- a `then`, an `else`, a definition's body --
             // is a `begin` of the statements it holds, less the clauses that are not statements
@@ -177,7 +203,7 @@ fn parent_child_count(context: &RuleContext<'_>, node: Node<'_>) -> usize {
         },
         UpstreamParent::Node(parent) => match parent.kind_str() {
             "array" | "string_array" | "symbol_array" | "exceptions" => {
-                super::nodes::children(parent).len()
+                super::nodes::children_in(parent, context).len()
             }
             "splat_argument"
             | "hash_splat_argument"
@@ -187,10 +213,10 @@ fn parent_child_count(context: &RuleContext<'_>, node: Node<'_>) -> usize {
             | "begin_block"
             | "end_block" => 1,
             kind if JUMPS.contains(&kind) => {
-                super::nodes::children(parent)
+                super::nodes::children_in(parent, context)
                     .first()
                     .map_or(0, |list| match list.kind_str() {
-                        "argument_list" => super::nodes::children(*list).len(),
+                        "argument_list" => super::nodes::children_in(*list, context).len(),
                         _ => 1,
                     })
             }
@@ -203,14 +229,34 @@ fn parent_child_count(context: &RuleContext<'_>, node: Node<'_>) -> usize {
                 true => 1,
                 false => 2,
             },
+            // **`children.one?` counts what is there, and a missing clause is `nil`.** `if (x)\nend`
+            // reaches upstream as `(if (begin …) nil nil)`, whose `one?` is true because the two
+            // absent branches are falsy -- so the parentheses are redundant. Reading the keyword
+            // and the clauses the grammar writes as children instead made the count 2 and the
+            // offense disappear.
+            kind if CONDITIONALS.contains(&kind) => {
+                ["condition", "consequence", "alternative", "body"]
+                    .iter()
+                    .filter(|field| {
+                        // A `while` always carries a `do`, empty or not, and an empty one is the
+                        // `nil` body upstream holds.
+                        parent
+                            .field(field)
+                            .is_some_and(|clause| clause.named_child_count() > 0)
+                    })
+                    .count()
+            }
             _ => 2,
         },
     }
 }
 
+/// The keywords whose absent clauses upstream spells as `nil` children.
+const CONDITIONALS: &[&str] = &["if", "unless", "while", "until", "elsif"];
+
 /// `parens_allowed?`.
 fn parens_allowed(context: &RuleContext<'_>, node: Node<'_>) -> bool {
-    let children = super::nodes::children(node);
+    let children = super::nodes::children_in(node, context);
     // `empty_parentheses?`: `()` says something no rewrite could keep.
     if children.is_empty() {
         return true;
@@ -251,11 +297,10 @@ fn in_pattern_matching_in_method_argument(
     let Some(first) = children.first() else {
         return false;
     };
-    // `match_pattern_p_type?` above Ruby 2.7, where `in` builds that node rather than the `=>` one.
-    match context.target_ruby_version() <= crate::ruby_version::RubyVersion::new(2, 7) {
-        true => first.kind_str() == "match_pattern",
-        false => first.kind_str() == "test_pattern",
-    }
+    // Upstream names the node differently per version -- 2.7 builds `match_pattern` for `in`, and
+    // 3.0 renamed that to `match_pattern_p` while giving `=>` the freed-up name. **Either way the
+    // question is about `in`**, which the grammar always spells `test_pattern`.
+    first.kind_str() == "test_pattern"
 }
 
 /// `allowed_pin_operator?`: `^(pin (begin !{lvar ivar cvar gvar}))`.
@@ -422,7 +467,7 @@ fn like_method_argument_parentheses(
     let Some(arguments) = argument_list(parent) else {
         return false;
     };
-    let list = super::nodes::children(arguments);
+    let list = super::nodes::children_in(arguments, context);
     if list.len() != 1 || list[0].id() != node.id() {
         return false;
     }
@@ -476,12 +521,12 @@ fn multiline_control_flow_statements(
 
 /// `check`.
 fn check_group<'tree>(
-    context: &RuleContext<'_>,
+    context: &'tree RuleContext<'_>,
     locals: &LocalVariables<'_, '_>,
     node: Node<'tree>,
     pending: &mut Vec<(Node<'tree>, &'static str)>,
 ) {
-    let children = super::nodes::children(node);
+    let children = super::nodes::children_in(node, context);
     let Some(inner) = children.first().copied() else {
         return;
     };
@@ -604,6 +649,23 @@ fn is_block(node: Node<'_>) -> bool {
 
 /// `node.variable?`: an instance, class or global variable, or a bare name the parser resolved
 /// into a local variable read.
+/// The `(` … `)` a pin operator wrote around its value.
+fn pinned_parentheses(
+    node: Node<'_>,
+    context: &RuleContext<'_>,
+) -> Option<std::ops::Range<usize>> {
+    let _cursor = node.walk();
+    let children: Vec<Node<'_>> = all_children_iter(node, context).collect();
+    let open = children
+        .iter()
+        .find(|child| !child.is_named() && context.source.node_text(**child) == "(")?;
+    let close = children
+        .iter()
+        .rev()
+        .find(|child| !child.is_named() && context.source.node_text(**child) == ")")?;
+    Some(open.start_byte()..close.end_byte())
+}
+
 fn is_variable(context: &RuleContext<'_>, locals: &LocalVariables<'_, '_>, node: Node<'_>) -> bool {
     match node.kind_str() {
         "instance_variable" | "class_variable" | "global_variable" => true,
@@ -947,7 +1009,7 @@ fn body_range(context: &RuleContext<'_>, node: Node<'_>, inner: Node<'_>) -> boo
         return false;
     };
     let statements = match parent.kind_str() {
-        "parenthesized_statements" | "interpolation" | "begin" => super::nodes::children(parent),
+        "parenthesized_statements" | "interpolation" | "begin" => super::nodes::children_in(parent, context),
         _ => super::conditional::self_statements(parent),
     };
     let beginless = inner.field("begin").is_none()
@@ -995,7 +1057,7 @@ fn keyword_with_redundant_parentheses(context: &RuleContext<'_>, node: Node<'_>)
                 None => has_own_parentheses(context, node),
             };
         }
-        _ => super::nodes::children(node),
+        _ => super::nodes::children_in(node, context),
     };
     // `only_begin_arg?`: the keyword's single argument is itself a parenthesized group.
     if let [only] = arguments.as_slice()
@@ -1031,6 +1093,9 @@ fn call_has_arguments(node: Node<'_>) -> bool {
         // A setter call takes the assigned value, and an indexing setter its subscripts too.
         "binary" | "assignment" => true,
         "element_reference" => !super::nodes::children(node).is_empty(),
+        // A `defined?` node's child **is** its argument upstream; the grammar writes it as a
+        // `unary` with an operand and no argument list, so it read as taking nothing.
+        "unary" => node.field("operand").is_some(),
         _ => argument_list(node).is_some_and(|list| !super::nodes::children(list).is_empty()),
     }
 }
@@ -1114,7 +1179,19 @@ fn is_prefix_not(context: &RuleContext<'_>, node: Node<'_>) -> bool {
 }
 
 fn is_suspect_unary(context: &RuleContext<'_>, node: Node<'_>) -> bool {
-    is_unary_operation(context, node) && !is_prefix_not(context, node)
+    // `node.send_type? && ...`: `defined? arg` is a `defined?` node upstream, not a `send`, so the
+    // walk down through the operators stops in front of it. Stepping past it handed
+    // `method_call_with_redundant_parentheses?` the bare argument, and `foo && (!defined? arg)`
+    // came out as redundant parentheses around a unary operation.
+    !is_defined(context, node) && is_unary_operation(context, node) && !is_prefix_not(context, node)
+}
+
+/// `defined? x`, which the grammar spells as a `unary` and upstream as a node type of its own.
+fn is_defined(context: &RuleContext<'_>, node: Node<'_>) -> bool {
+    node.kind_str() == "unary"
+        && node
+            .field("operator")
+            .is_some_and(|operator| context.source.node_text(operator) == "defined?")
 }
 
 /// `method_call_with_redundant_parentheses?`.
@@ -1137,7 +1214,7 @@ fn method_call_with_redundant_parentheses(
     if singular_parenthesized_parent(context, node) {
         return true;
     }
-    !call_has_arguments(call) || has_own_parentheses(context, call) || square_brackets(call)
+    !call_has_arguments(call) || has_own_parentheses(context, call) || square_brackets(call, context)
 }
 
 /// `singular_parenthesized_parent?`.
@@ -1154,14 +1231,14 @@ fn singular_parenthesized_parent(context: &RuleContext<'_>, node: Node<'_>) -> b
 }
 
 /// `square_brackets?`: an index written on something the parentheses cannot be part of.
-fn square_brackets(node: Node<'_>) -> bool {
+fn square_brackets(node: Node<'_>, context: &RuleContext<'_>) -> bool {
     if node.kind_str() != "element_reference" {
         return false;
     }
     let Some(object) = node.field("object") else {
         return false;
     };
-    super::conditional::descendants(object)
+    super::conditional::descendants(object, context)
         .into_iter()
         .any(|descendant| match descendant.kind_str() {
             "string" | "array" | "string_array" | "symbol_array" | "hash" => true,

data/src/rules/style/redundant_regexp_argument.rs

@@ -46,7 +46,7 @@ pub(super) fn check(context: &RuleContext<'_>, offenses: &mut Vec<Offense>) {
         }
         let Some(argument) = node
             .field("arguments")
-            .and_then(|arguments| super::nodes::children(arguments).into_iter().next())
+            .and_then(|arguments| super::nodes::children_in(arguments, context).into_iter().next())
         else {
             continue;
         };

data/src/rules/style/redundant_regexp_character_class.rs

@@ -14,6 +14,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::named_children_of;
 
 /// `REQUIRES_ESCAPE_OUTSIDE_CHAR_CLASS_CHARS`: what a character class is the escape for.
 const REQUIRES_ESCAPE: [char; 10] = ['.', '*', '+', '?', '{', '}', '(', ')', '|', '$'];
@@ -114,9 +115,9 @@ impl Pattern {
         let flags = &context.source.node_text(closing)[1..];
         let start = opening.end_byte();
         let end = closing.start_byte();
-        let mut cursor = node.walk();
-        let interpolations: Vec<Range<usize>> = node
-            .named_children(&mut cursor)
+        let _cursor = node.walk();
+        let interpolations: Vec<Range<usize>> = named_children_of(node, context)
+            .into_iter()
             .filter(|child| child.kind_str() == "interpolation")
             .map(|child| child.byte_range())
             .collect();

data/src/rules/style/redundant_regexp_escape.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::named_children_iter;
 
 const MSG: &str = "Redundant escape inside regexp literal";
 
@@ -67,8 +68,8 @@ impl Literal {
         let mut pattern = context.source.slice(start..closing.start_byte()).to_owned();
         // `with_interpolations_blanked`: the code inside `#{}` is no part of the pattern, but its
         // width has to stay so that the offsets still line up.
-        let mut cursor = node.walk();
-        for child in node.named_children(&mut cursor) {
+        let _cursor = node.walk();
+        for child in named_children_iter(node, context) {
             if child.kind_str() != "interpolation" {
                 continue;
             }

data/src/rules/style/redundant_return.rs

@@ -157,8 +157,7 @@ const NOT_A_STATEMENT: &[&str] = &["comment", "empty_statement", "heredoc_body"]
 /// protected body -- so it is skipped even though it is a child here.
 fn check_sequence<'tree>(node: Node<'tree>, returns: &mut Vec<Node<'tree>>) {
     let mut cursor = node.walk();
-    let children: Vec<Node<'tree>> = node
-        .named_children(&mut cursor)
+    let children: Vec<Node<'tree>> = node.named_children(&mut cursor)
         .filter(|child| !NOT_A_STATEMENT.contains(&child.kind_str()))
         .collect();
 

data/src/rules/style/redundant_self.rs

@@ -14,8 +14,8 @@ use tree_sitter::Node;
 
 use crate::diagnostic::{Edit, Offense};
 use crate::rules::RuleContext;
-use crate::rules::send_node;
 use crate::rules::node_ext::NodeExt;
+use crate::rules::send_node;
 
 const MSG: &str = "Redundant `self` detected.";
 
@@ -157,6 +157,11 @@ const CONDITIONALS: &[&str] = &[
 type Scope = Rc<RefCell<Vec<String>>>;
 
 pub(super) fn check(context: &RuleContext<'_>, offenses: &mut Vec<Offense>) {
+    // Without an explicit `self` token no send can be reported. Building the scope table is a
+    // whole-file operation, so avoid it for the common file that has no candidate at all.
+    if context.nodes_of("self").next().is_none() {
+        return;
+    }
     let mut cop = Cop {
         context,
         allowed: HashSet::new(),
@@ -204,10 +209,10 @@ impl<'tree> Cop<'_, 'tree> {
 
     /// `add_scope`: every node under this one answers with the same list.
     fn add_scope(&mut self, node: Node<'tree>, scope: Scope) {
-        let mut stack = send_node::named_children(node);
+        let mut stack = send_node::named_children_of(node, self.context);
         while let Some(current) = stack.pop() {
             self.scopes.insert(current.id(), Scope::clone(&scope));
-            stack.extend(send_node::named_children(current));
+            stack.extend(send_node::named_children_of(current, self.context));
         }
     }
 
@@ -245,16 +250,13 @@ impl<'tree> Cop<'_, 'tree> {
     }
 
     fn on_assignment(&mut self, node: Node<'tree>) {
-        let (Some(left), Some(right)) = (
-            node.field("left"),
-            node.field("right"),
-        ) else {
+        let (Some(left), Some(right)) = (node.field("left"), node.field("right")) else {
             return;
         };
         match left.kind_str() {
             // `on_masgn`: every name the left-hand side binds.
             "left_assignment_list" => {
-                for target in send_node::named_children(left) {
+                for target in send_node::named_children_of(left, self.context) {
                     let name = self.context.source.node_text(target).to_owned();
                     self.add_lhs_to_scopes(right, name);
                 }
@@ -288,13 +290,13 @@ impl<'tree> Cop<'_, 'tree> {
     }
 
     fn on_resbody(&mut self, node: Node<'tree>) {
-        let Some(variable) = send_node::named_children(node)
+        let Some(variable) = send_node::named_children_of(node, self.context)
             .into_iter()
             .find(|child| child.kind_str() == "exception_variable")
         else {
             return;
         };
-        let Some(name) = send_node::named_children(variable)
+        let Some(name) = send_node::named_children_of(variable, self.context)
             .first()
             .filter(|bound| bound.kind_str() == "identifier")
             .map(|bound| self.context.source.node_text(*bound).to_owned())
@@ -307,12 +309,12 @@ impl<'tree> Cop<'_, 'tree> {
     /// `add_match_var_scopes`: `in [Integer => n]` binds `n` for the branch.
     fn on_in_pattern(&mut self, node: Node<'tree>) {
         let mut names = Vec::new();
-        let mut stack = send_node::named_children(node);
+        let mut stack = send_node::named_children_of(node, self.context);
         while let Some(current) = stack.pop() {
             if is_match_var(current) {
                 names.push(self.context.source.node_text(current).to_owned());
             }
-            stack.extend(send_node::named_children(current));
+            stack.extend(send_node::named_children_of(current, self.context));
         }
         self.scope(node.id()).borrow_mut().extend(names);
     }
@@ -324,7 +326,7 @@ impl<'tree> Cop<'_, 'tree> {
             return;
         };
         let mut names = Vec::new();
-        let mut stack = send_node::named_children(node);
+        let mut stack = send_node::named_children_of(node, self.context);
         while let Some(current) = stack.pop() {
             if current.kind_str() == "assignment"
                 && let Some(left) = current.field("left")
@@ -332,14 +334,14 @@ impl<'tree> Cop<'_, 'tree> {
                 match left.kind_str() {
                     "identifier" => names.push(self.context.source.node_text(left).to_owned()),
                     "left_assignment_list" => names.extend(
-                        send_node::named_children(left)
+                        send_node::named_children_of(left, self.context)
                             .into_iter()
                             .map(|target| self.context.source.node_text(target).to_owned()),
                     ),
                     _ => {}
                 }
             }
-            stack.extend(send_node::named_children(current));
+            stack.extend(send_node::named_children_of(current, self.context));
         }
         for name in names {
             self.add_lhs_to_scopes(condition, name);
@@ -483,7 +485,7 @@ impl<'tree> Cop<'_, 'tree> {
         let mut current = node.parent_of(self.context);
         while let Some(visited) = current {
             if matches!(visited.kind_str(), "do_block" | "block" | "lambda") {
-                return send_node::named_children(visited)
+                return send_node::named_children_of(visited, self.context)
                     .iter()
                     .all(|child| child.kind_str() != "block_parameters");
             }
@@ -518,6 +520,16 @@ fn is_match_var(node: Node<'_>) -> bool {
             ) || parent.kind_str() == "array_pattern"
                 || parent.kind_str() == "find_pattern"
                 || parent.kind_str() == "hash_pattern"
+                // `in {x: foo}`: the grammar puts a `keyword_pattern` between the hash pattern
+                // and the name. Its key is a `hash_key_symbol`, so an identifier here is always
+                // the binding -- `in {x:}` binds `x` the same way.
+                || parent.kind_str() == "keyword_pattern"
                 || parent.kind_str() == "alternative_pattern"
+                // `in *bar` is a `match_rest` holding a `match_var` upstream, so the name it
+                // catches is bound for the branch just like any other. A bare `*` binds nothing
+                // and has no identifier under it.
+                || parent.kind_str() == "splat_parameter"
+            // `^foo` is a `pin`, not a binding: the identifier under it stays a read, which is
+            // why `variable_reference_pattern` is deliberately absent from this list.
         })
 }

data/src/rules/style/redundant_sort.rs

@@ -85,7 +85,7 @@ fn redundant_sort<'tree>(context: &RuleContext<'_>, node: Node<'tree>) -> Option
         // `sorted[0]` is a call to `:[]` upstream, whose selector is the bracket.
         "element_reference" => {
             let object = node.field("object")?;
-            let indices = super::nodes::children(node);
+            let indices = super::nodes::children_in(node, context);
             let index = match indices.as_slice() {
                 [_, only] => *only,
                 _ => return None,

data/src/rules/style/redundant_sort_by.rs

@@ -30,7 +30,7 @@ pub(super) fn check(context: &RuleContext<'_>, offenses: &mut Vec<Offense>) {
         }
         let read = context.source.node_text(*statement);
         let message = match block.field("parameters") {
-            Some(parameters) => match super::nodes::children(parameters).as_slice() {
+            Some(parameters) => match super::nodes::children_in(parameters, context).as_slice() {
                 [only]
                     if only.kind_str() == "identifier" && context.source.node_text(*only) == read =>
                 {

data/src/rules/style/redundant_string_escape.rs

@@ -7,6 +7,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_of;
 
 /// One literal as `on_str` sees it: the text to scan, plus what the delimiters make of a backslash.
 struct Literal {
@@ -58,7 +59,7 @@ fn literals(context: &RuleContext<'_>) -> Vec<Literal> {
     for array in context.nodes_of("string_array") {
         let upper = delimiter_text(array, context, 0).starts_with("%W");
         let delimiters = array_delimiters(array, context);
-        for word in super::nodes::children(array) {
+        for word in super::nodes::children_in(array, context) {
             if word.kind_str() != "bare_string" {
                 continue;
             }
@@ -73,7 +74,7 @@ fn literals(context: &RuleContext<'_>) -> Vec<Literal> {
         }
     }
     for (opener, body) in heredocs(context) {
-        let Some(terminator) = super::nodes::children(body)
+        let Some(terminator) = super::nodes::children_in(body, context)
             .into_iter()
             .find(|child| child.kind_str() == "heredoc_end")
         else {
@@ -171,9 +172,9 @@ fn disabling_interpolation(source: &str, start: usize) -> bool {
 
 /// The delimiter written at one end of a literal, which the grammar keeps as an unnamed token.
 fn delimiter_text<'a>(node: Node<'_>, context: &'a RuleContext<'_>, end: usize) -> &'a str {
-    let mut cursor = node.walk();
-    let children: Vec<Node<'_>> = node
-        .children(&mut cursor)
+    let _cursor = node.walk();
+    let children: Vec<Node<'_>> = all_children_of(node, context)
+        .into_iter()
         .filter(|c| !c.is_named())
         .collect();
     let token = match end {

data/src/rules/style/regexp_literal.rs

@@ -5,6 +5,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::named_children_iter;
 
 const MSG_USE_SLASHES: &str = "Use `//` around regular expression.";
 const MSG_USE_PERCENT_R: &str = "Use `%r` around regular expression.";
@@ -123,8 +124,8 @@ impl<'a> Literal<'a> {
 
         let mut literal_text = String::new();
         let mut start = begin.end_byte();
-        let mut cursor = node.walk();
-        for child in node.named_children(&mut cursor) {
+        let _cursor = node.walk();
+        for child in named_children_iter(node, context) {
             if child.kind_str() != "interpolation" {
                 continue;
             }

data/src/rules/style/require_order.rs

@@ -80,7 +80,7 @@ fn method_name<'a>(call: Node<'_>, context: &'a RuleContext<'_>) -> Option<&'a s
 /// `find_previous_older_sibling`: the nearest `require` above that this one sorts before, with the
 /// search stopping at anything that is not a `require` of the same kind.
 fn find_previous_older_sibling<'tree>(
-    context: &RuleContext<'_>,
+    context: &'tree RuleContext<'_>,
     call: Node<'tree>,
     parent: Node<'tree>,
 ) -> Option<Node<'tree>> {
@@ -90,7 +90,7 @@ fn find_previous_older_sibling<'tree>(
         false => call,
     };
     let container = search.parent()?;
-    let statements = super::nodes::children(container);
+    let statements = super::nodes::children_in(container, context);
     let position = statements
         .iter()
         .position(|statement| statement.id() == search.id())?;

data/src/rules/style/rescue_modifier.rs

@@ -3,6 +3,7 @@
 use tree_sitter::Node;
 
 use crate::diagnostic::{Edit, Offense};
+use crate::ruby_version::RubyVersion;
 use crate::rules::RuleContext;
 use crate::rules::node_ext::NodeExt;
 use crate::rules::send_node;
@@ -30,9 +31,13 @@ pub(super) fn check(context: &RuleContext<'_>, offenses: &mut Vec<Offense>) {
         // **多重代入のときだけ**である。`w = 1, 2 rescue nil` は `(rescue (lvasgn w (array 1 2))
         // ..)` で修飾子が外に出るが、`a, b = 1, 2 rescue nil` は `(masgn (mlhs ..) (rescue ..))`
         // で中に入る。左辺が代入の並びかどうかで分かれる。
-        let operation = match operation
-            .field("left")
-            .is_some_and(|left| left.kind_str() == "left_assignment_list")
+        // その振り分けは **2.7 以降のパーサ**の話である。2.6 では多重代入もろとも `rescue` の
+        // 中に入る (`(rescue (masgn ..) ..)`) ので、文法が作る形がそのまま本家の形になる。
+        let splits_multiple_assignment = context.target_ruby_version() >= RubyVersion::new(2, 7);
+        let operation = match splits_multiple_assignment
+            && operation
+                .field("left")
+                .is_some_and(|left| left.kind_str() == "left_assignment_list")
         {
             true => match operation.field("right") {
                 Some(right) => right,
@@ -127,7 +132,7 @@ fn heredoc_end(context: &RuleContext<'_>, operation: Node<'_>) -> Option<usize>
         .map(send_node::Argument::first)
         .find(|argument| argument.kind_str() == "heredoc_beginning")?;
     let body = send_node::heredoc_body(beginning, context)?;
-    super::nodes::children(body)
+    super::nodes::children_in(body, context)
         .into_iter()
         .find(|child| child.kind_str() == "heredoc_end")
         .map(|terminator| terminator.end_byte())

data/src/rules/style/rescue_standard_error.rs

@@ -49,7 +49,7 @@ pub(super) fn check(context: &RuleContext<'_>, offenses: &mut Vec<Offense>) {
 /// `(array (const {nil? cbase} :StandardError))`: the one name, unqualified or written from the
 /// root.
 fn only_standard_error(context: &RuleContext<'_>, list: Node<'_>) -> bool {
-    let exceptions = super::nodes::children(list);
+    let exceptions = super::nodes::children_in(list, context);
     let [only] = exceptions.as_slice() else {
         return false;
     };

data/src/rules/style/return_nil.rs

@@ -13,11 +13,11 @@ pub(super) fn check(context: &RuleContext<'_>, offenses: &mut Vec<Offense>) {
         .setting::<String>("EnforcedStyle")
         .is_some_and(|style| style == "return_nil");
     for node in context.nodes_of("return") {
-        let written = super::nodes::children(node);
+        let written = super::nodes::children_in(node, context);
         let returns_nil = matches!(
             written.as_slice(),
             [list] if list.kind_str() == "argument_list"
-                && matches!(super::nodes::children(*list).as_slice(),
+                && matches!(super::nodes::children_in(*list, context).as_slice(),
                             [only] if only.kind_str() == "nil")
         );
         // `correct_style?`: only one of the two spellings is ever wrong, and a `return 1` is

data/src/rules/style/return_nil_in_predicate_method_definition.rs

@@ -43,9 +43,9 @@ pub(super) fn check(context: &RuleContext<'_>, offenses: &mut Vec<Offense>) {
         };
         // `body.each_descendant(:return)`: every `return` **below** the body. A body that is
         // itself a bare `return nil` is not a descendant of itself, so upstream misses it.
-        let mut stack: Vec<Node<'_>> = super::nodes::children(body);
+        let mut stack: Vec<Node<'_>> = super::nodes::children_in(body, context);
         while let Some(current) = stack.pop() {
-            stack.extend(super::nodes::children(current));
+            stack.extend(super::nodes::children_in(current, context));
             if current.kind_str() == "return" && returns_nil(current) {
                 offenses.push(replacement(context, current, "return false"));
             }

data/src/rules/style/safe_navigation.rs

@@ -533,7 +533,7 @@ fn and_with_rhs_or(context: &RuleContext<'_>, node: Node<'_>) -> bool {
         return true;
     }
     right.kind_str() == "parenthesized_statements"
-        && matches!(super::nodes::children(right).as_slice(), [only] if is_or(context, *only))
+        && matches!(super::nodes::children_in(right, context).as_slice(), [only] if is_or(context, *only))
 }
 
 /// `find_matching_receiver_invocation`.
@@ -686,7 +686,7 @@ fn and_parts<'tree>(context: &RuleContext<'_>, node: Node<'tree>) -> Vec<Part<'t
 fn and_inside_begin(context: &RuleContext<'_>, node: Node<'_>) -> bool {
     send_node::any_descendant(node, &mut |candidate| {
         candidate.kind_str() == "parenthesized_statements"
-            && super::nodes::children(candidate)
+            && super::nodes::children_in(candidate, context)
                 .first()
                 .is_some_and(|first| is_and(context, *first))
     })

data/src/rules/style/safe_navigation_chain_length.rs

@@ -52,7 +52,14 @@ fn safe_navigation_chains<'tree>(node: Node<'tree>, context: &RuleContext<'_>) -
         let Some(parent) = enclosing(current) else {
             break;
         };
-        if !is_safe_navigation(parent, context) {
+        // **`other&.foo = x` is one `csend` of `:foo=` upstream.** The grammar writes it as an
+        // assignment whose target is the safe navigation, so the assignment stands where that
+        // `csend` would.
+        let is_csend_setter = parent.kind_str() == "assignment"
+            && parent
+                .field("left")
+                .is_some_and(|left| is_safe_navigation(left, context));
+        if !is_csend_setter && !is_safe_navigation(parent, context) {
             break;
         }
         chains.push(parent);