sonicop 26.8.111 → 26.8.113

data/src/rules/lint/unreachable_pattern_branch.rs

@@ -4,23 +4,26 @@ use crate::diagnostic::Offense;
 use crate::ruby_version::RubyVersion;
 use crate::rules::RuleContext;
 use crate::rules::node_ext::NodeExt;
+use crate::rules::send_node::named_children_iter;
 
 pub(super) fn check(context: &RuleContext<'_>, offenses: &mut Vec<Offense>) {
     if context.target_ruby_version() < RubyVersion::new(2, 7) {
         return;
     }
     for case in context.nodes_of("case_match") {
-        let mut cursor = case.walk();
+        let _cursor = case.walk();
         let mut catch_all_found = false;
         let mut else_clause = None;
-        for branch in case.named_children(&mut cursor) {
+        for branch in named_children_iter(case, context) {
             match branch.kind_str() {
                 "else" => else_clause = Some(branch),
                 "in_clause" => {
                     if catch_all_found {
                         offenses.push(context.offense(
                             "Unreachable `in` pattern branch detected.",
-                            branch.byte_range(),
+                            // A trailing comment is no part of the branch upstream, which ends
+                            // at the last statement the branch holds.
+                            crate::rules::support::expression_range(branch),
                         ));
                         continue;
                     }
@@ -57,8 +60,7 @@ fn is_catch_all(pattern: Node<'_>) -> bool {
         "parenthesized_pattern" => pattern.named_child(0).is_some_and(is_catch_all),
         "alternative_pattern" => {
             let mut cursor = pattern.walk();
-            pattern
-                .named_children(&mut cursor)
+            pattern.named_children(&mut cursor)
                 .any(|alternative| is_catch_all(alternative))
         }
         _ => false,

data/src/rules/lint/unused_block_argument.rs

@@ -68,7 +68,7 @@ fn message(
         .filter(|variable| block_argument(variable, scope))
         .collect();
     let none_referenced = !arguments.iter().any(|argument| argument.referenced);
-    let augmentation = if is_lambda(scope.node, context.source) {
+    let augmentation = if is_lambda(scope.node, context.source, context.ast_index()) {
         let mut message = underscore_message(name);
         if none_referenced {
             message.push_str(
@@ -77,7 +77,7 @@ fn message(
             );
         }
         message
-    } else if none_referenced && block_method(scope.node, context.source) != Some("define_method") {
+    } else if none_referenced && block_method(scope.node, context.source, context.ast_index()) != Some("define_method") {
         if arguments.len() > 1 {
             "You can omit all the arguments if you don't care about them.".to_owned()
         } else {

data/src/rules/lint/unused_method_argument.rs

@@ -86,8 +86,7 @@ fn method_body(node: Node<'_>) -> Option<MethodBody<'_>> {
         });
     }
     let mut cursor = body.walk();
-    let statements: Vec<Node<'_>> = body
-        .named_children(&mut cursor)
+    let statements: Vec<Node<'_>> = body.named_children(&mut cursor)
         .filter(|child| !NOT_A_STATEMENT.contains(&child.kind_str()))
         .collect();
     match statements.len() {

data/src/rules/lint/useless_assignment.rs

@@ -11,6 +11,7 @@ use crate::diagnostic::{Edit, Offense};
 use crate::rules::RuleContext;
 use crate::rules::node_ext::NodeExt;
 use crate::rules::support::spurious_assignment_list;
+use crate::rules::send_node::named_children_of;
 
 pub(super) fn check(context: &RuleContext<'_>, offenses: &mut Vec<Offense>) {
     let analysis = context.variable_analysis();
@@ -143,7 +144,7 @@ fn variable_like_invocation(
     match node.kind_str() {
         // A bare name standing where a value is read is a `send` upstream unless it resolved to a
         // local, and a read of a local is an `lvar` that contributes nothing of its own here.
-        "identifier" if is_variable_read(node) && !analysis.is_variable_reference(node) => {
+        "identifier" if is_variable_read(node, context.ast_index()) && !analysis.is_variable_reference(node) => {
             Some(context.source.node_text(node).to_owned())
         }
         "call" => {
@@ -354,7 +355,7 @@ fn reads_name(node: Node<'_>, name: &str, context: &RuleContext<'_>) -> bool {
                 .is_some_and(|method| method.id() == node.id());
         return !target && !method;
     }
-    named_children(node)
+    named_children_of(node, context)
         .into_iter()
         .any(|child| reads_name(child, name, context))
 }

data/src/rules/lint/useless_constant_scoping.rs

@@ -3,9 +3,10 @@ use tree_sitter::Node;
 use crate::diagnostic::Offense;
 use crate::rules::RuleContext;
 use crate::rules::node_ext::NodeExt;
-use crate::rules::send_node::{arguments, named_children, string_text, symbol_name};
+use crate::rules::send_node::{arguments, string_text, symbol_name};
 
 use super::access_modifier::{bare_access_modifier, send_name};
+use crate::rules::send_node::named_children_of;
 
 pub(super) fn check(context: &RuleContext<'_>, offenses: &mut Vec<Offense>) {
     for node in context.nodes_of("assignment") {
@@ -15,7 +16,7 @@ pub(super) fn check(context: &RuleContext<'_>, offenses: &mut Vec<Offense>) {
         let Some(parent) = node.parent_of(context) else {
             continue;
         };
-        let siblings = named_children(parent);
+        let siblings = named_children_of(parent, context);
         let Some(position) = siblings
             .iter()
             .position(|sibling| sibling.id() == node.id())

data/src/rules/lint/useless_else_without_rescue.rs

@@ -2,6 +2,7 @@ use crate::diagnostic::Offense;
 use crate::ruby_version::RubyVersion;
 use crate::rules::RuleContext;
 use crate::rules::node_ext::NodeExt;
+use crate::rules::send_node::named_children_of;
 
 const MSG: &str = "`else` without `rescue` is useless.";
 
@@ -24,9 +25,9 @@ pub(super) fn check(context: &RuleContext<'_>, offenses: &mut Vec<Offense>) {
         if !matches!(body.kind_str(), "begin" | "body_statement" | "block_body") {
             continue;
         }
-        let mut cursor = body.walk();
-        if body
-            .named_children(&mut cursor)
+        let _cursor = body.walk();
+        if named_children_of(body, context)
+            .into_iter()
             .any(|child| child.kind_str() == "rescue")
         {
             continue;

data/src/rules/lint/useless_rescue.rs

@@ -3,9 +3,10 @@ use tree_sitter::Node;
 use crate::diagnostic::Offense;
 use crate::rules::RuleContext;
 use crate::rules::node_ext::NodeExt;
-use crate::rules::send_node::{arguments, named_children};
+use crate::rules::send_node::arguments;
 
 use super::statements::statements;
+use crate::rules::send_node::named_children_of;
 
 pub(super) fn check(context: &RuleContext<'_>, offenses: &mut Vec<Offense>) {
     for node in context.nodes_of("rescue") {
@@ -23,7 +24,7 @@ fn is_last_branch(node: Node<'_>, context: &RuleContext<'_>) -> bool {
         return true;
     };
     let mut seen = false;
-    for sibling in named_children(parent) {
+    for sibling in named_children_of(parent, context) {
         if sibling.id() == node.id() {
             seen = true;
             continue;
@@ -92,7 +93,7 @@ fn uses_exception_variable_in_ensure(
     let Some(parent) = node.parent_of(context) else {
         return false;
     };
-    let Some(ensure_clause) = named_children(parent)
+    let Some(ensure_clause) = named_children_of(parent, context)
         .into_iter()
         .find(|child| child.kind_str() == "ensure")
     else {
@@ -100,7 +101,7 @@ fn uses_exception_variable_in_ensure(
     };
     let analysis = context.variable_analysis();
     let mut found = false;
-    crate::rules::walk_named(ensure_clause, &mut |inner| {
+    crate::rules::walk_named(ensure_clause, context, &mut |inner| {
         if found || inner.kind_str() != "identifier" || context.source.node_text(inner) != variable
         {
             return;

data/src/rules/lint/useless_ruby2_keywords.rs

@@ -4,6 +4,7 @@ use crate::diagnostic::Offense;
 use crate::rules::RuleContext;
 use crate::rules::node_ext::NodeExt;
 use crate::rules::send_node::{arguments, named_children, symbol_name};
+use crate::rules::send_node::named_children_of;
 
 pub(super) fn check(context: &RuleContext<'_>, offenses: &mut Vec<Offense>) {
     for node in context.nodes_of("call") {
@@ -60,7 +61,7 @@ fn find_method_definition<'tree>(
 ) -> Option<Option<Node<'tree>>> {
     let mut current = node.parent_of(context);
     while let Some(ancestor) = current {
-        for child in named_children(ancestor) {
+        for child in named_children_of(ancestor, context) {
             if let Some(parameters) = definition_parameters(child, name, context) {
                 return Some(parameters);
             }

data/src/rules/lint/useless_setter_call.rs

@@ -4,12 +4,13 @@ use tree_sitter::Node;
 
 use crate::diagnostic::{Edit, Offense};
 use crate::rules::RuleContext;
-use crate::rules::send_node::named_children;
 
 use super::literals::is_literal;
 use super::locals::LocalVariables;
 use super::statements::body_children;
 use crate::rules::node_ext::NodeExt;
+use crate::rules::send_node::named_children_of;
+use crate::rules::send_node::named_children_iter;
 
 /// `ASSIGNMENT_TYPES`: the variable kinds the tracker follows. A constant is deliberately missing.
 const ASSIGNMENT_TARGETS: &[&str] = &[
@@ -106,7 +107,7 @@ impl Tracker {
         if self.process_assignment_node(node, context, locals) {
             return;
         }
-        for child in named_children(node) {
+        for child in named_children_of(node, context) {
             self.scan(child, context, locals);
         }
     }
@@ -168,11 +169,11 @@ impl Tracker {
     ) {
         let listed = matches!(right.kind_str(), "right_assignment_list" | "array");
         let values = if listed {
-            named_children(right)
+            named_children_of(right, context)
         } else {
             Vec::new()
         };
-        for (index, target) in named_children(targets).into_iter().enumerate() {
+        for (index, target) in named_children_iter(targets, context).enumerate() {
             if !ASSIGNMENT_TARGETS.contains(&target.kind_str()) {
                 continue;
             }

data/src/rules/lint/useless_times.rs

@@ -9,6 +9,7 @@ use super::locals::LocalVariables;
 use super::ranges::whole_lines;
 use super::statements::statements;
 use crate::rules::node_ext::NodeExt;
+use crate::rules::send_node::named_children_of;
 
 pub(super) fn check(context: &RuleContext<'_>, offenses: &mut Vec<Offense>) {
     let locals = LocalVariables::new(context);
@@ -66,7 +67,7 @@ fn block_pass_symbol<'a>(node: Node<'_>, context: &'a RuleContext<'_>) -> Option
     if node.kind_str() != "block_argument" {
         return None;
     }
-    symbol_name(named_children(node).first().copied()?, context)
+    symbol_name(named_children_of(node, context).first().copied()?, context)
 }
 
 fn correction(
@@ -257,7 +258,7 @@ fn reassigns(node: Node<'_>, name: &str, context: &RuleContext<'_>) -> bool {
     {
         return true;
     }
-    named_children(node)
+    named_children_of(node, context)
         .into_iter()
         .any(|child| reassigns(child, name, context))
 }
@@ -268,7 +269,7 @@ fn assigns_to(left: Node<'_>, name: &str, context: &RuleContext<'_>) -> bool {
         "identifier" => context.source.node_text(left) == name,
         // `i, j = 1, 2` and `(i, j), k = [1, 2], 3` nest their targets.
         "left_assignment_list" | "destructured_left_assignment" | "rest_assignment" => {
-            named_children(left)
+            named_children_of(left, context)
                 .into_iter()
                 .any(|target| assigns_to(target, name, context))
         }