sonicop 26.8.111 → 26.8.113

data/src/rules/style/parallel_assignment.rs

@@ -97,7 +97,7 @@ impl Cop<'_, '_> {
         };
         let lhs_elements = assignments(left);
         let rhs_elements = match RHS_LISTS.contains(&rhs.kind_str()) {
-            true => super::nodes::children(rhs),
+            true => super::nodes::children_in(rhs, self.context),
             false => Vec::new(),
         };
 
@@ -122,7 +122,7 @@ impl Cop<'_, '_> {
         };
         // `contains_heredoc?`: splitting the assignment would drop the following lines into the
         // heredoc's body.
-        if descendants(rhs)
+        if descendants(rhs, self.context)
             .into_iter()
             .any(|inner| inner.kind_str() == "heredoc_beginning")
         {
@@ -177,7 +177,7 @@ impl Cop<'_, '_> {
             "identifier" | "instance_variable" | "global_variable" | "class_variable"
             | "constant" => {
                 let name = self.source(lhs);
-                descendants(rhs)
+                descendants(rhs, self.context)
                     .into_iter()
                     .any(|inner| self.reads_name(inner, name))
             }
@@ -206,7 +206,19 @@ impl Cop<'_, '_> {
         };
         let receiver = self.source(receiver);
         let method = self.source(method);
-        descendants(rhs).into_iter().any(|inner| {
+        // `add_self_to_getters`: a bare name on the right is read as `self.name` before the
+        // dependencies are worked out, so `self.a, self.b = b, a` is the swap it looks like.
+        if receiver == "self"
+            && descendants(rhs, self.context).into_iter().any(|inner| {
+                inner.kind_str() == "identifier"
+                    && self.source(inner) == method
+                    // `(send nil? $_)`: a name the file never assigned is a call, not a variable.
+                    && !self.context.variable_analysis().is_variable_reference(inner)
+            })
+        {
+            return true;
+        }
+        descendants(rhs, self.context).into_iter().any(|inner| {
             matches!(inner.kind_str(), "call" | "method_call")
                 && inner
                     .field("receiver")
@@ -224,7 +236,7 @@ impl Cop<'_, '_> {
         };
         let object = self.source(object);
         let arguments = index_arguments(self, lhs);
-        descendants(rhs).into_iter().any(|inner| {
+        descendants(rhs, self.context).into_iter().any(|inner| {
             inner.kind_str() == "element_reference"
                 && inner
                     .field("object")
@@ -329,7 +341,7 @@ impl Cop<'_, '_> {
 }
 
 fn index_arguments(cop: &Cop<'_, '_>, node: Node<'_>) -> Vec<String> {
-    let mut arguments = super::nodes::children(node);
+    let mut arguments = super::nodes::children_in(node, cop.context);
     if node.field("object").is_some() && !arguments.is_empty() {
         arguments.remove(0);
     }
@@ -342,8 +354,7 @@ fn index_arguments(cop: &Cop<'_, '_>, node: Node<'_>) -> Vec<String> {
 /// `modifier_range`: the keyword and the condition behind it, which becomes the head of the block.
 fn modifier_range(modifier: Node<'_>) -> Range<usize> {
     let mut cursor = modifier.walk();
-    let keyword = modifier
-        .children(&mut cursor)
+    let keyword = modifier.children(&mut cursor)
         .find(|child| !child.is_named())
         .map_or(modifier.start_byte(), |child| child.start_byte());
     keyword..modifier.end_byte()
@@ -410,7 +421,7 @@ fn sole_statement_of_a_method(context: &RuleContext<'_>, node: Node<'_>) -> bool
     }
     rescue.parent_of(context).is_some_and(|body| {
         body.kind_str() == "body_statement"
-            && super::nodes::children(body).len() == 1
+            && super::nodes::children_in(body, context).len() == 1
             && body
                 .parent_of(context)
                 .is_some_and(|owner| matches!(owner.kind_str(), "method" | "singleton_method"))

data/src/rules/style/parens.rs

@@ -191,7 +191,7 @@ fn is_ternary_condition_before_question_mark(context: &RuleContext<'_>, node: No
 
 /// `comment_above_close_paren_swallows_chain?`.
 fn comment_above_close_paren(context: &RuleContext<'_>, node: Node<'_>) -> bool {
-    let Some(last) = super::nodes::children(node).last().copied() else {
+    let Some(last) = super::nodes::children_in(node, context).last().copied() else {
         return false;
     };
     let close = node.end_byte() - 1;

data/src/rules/style/parentheses_around_condition.rs

@@ -40,7 +40,7 @@ pub(super) fn check(context: &RuleContext<'_>, offenses: &mut Vec<Offense>) {
         if condition.kind_str() != "parenthesized_statements" {
             continue;
         }
-        let children = super::nodes::children(condition);
+        let children = super::nodes::children_in(condition, context);
         let Some(first) = children.first().copied() else {
             continue;
         };
@@ -139,7 +139,7 @@ fn parens_required(context: &RuleContext<'_>, node: Node<'_>) -> bool {
 /// `safe_assignment?`: `(begin {equals_asgn? #setter_method?})`, the parenthesized assignment that
 /// says the assignment was meant.
 fn is_safe_assignment(context: &RuleContext<'_>, condition: Node<'_>) -> bool {
-    let children = super::nodes::children(condition);
+    let children = super::nodes::children_in(condition, context);
     let [only] = children.as_slice() else {
         return false;
     };
@@ -187,7 +187,7 @@ fn unwrap(context: &RuleContext<'_>, condition: Node<'_>) -> Vec<Edit> {
 }
 
 fn comment_above_close_paren(context: &RuleContext<'_>, condition: Node<'_>) -> bool {
-    let Some(last) = super::nodes::children(condition).last().copied() else {
+    let Some(last) = super::nodes::children_in(condition, context).last().copied() else {
         return false;
     };
     let close = condition.end_byte() - 1;

data/src/rules/style/partition_instead_of_double_select.rs

@@ -39,7 +39,7 @@ pub(super) fn check(context: &RuleContext<'_>, offenses: &mut Vec<Offense>) {
         if !holds_a_begin(parent) {
             continue;
         }
-        let statements: Vec<Node<'_>> = super::nodes::children(parent);
+        let statements: Vec<Node<'_>> = super::nodes::children_in(parent, context);
         for window in statements.windows(2) {
             let [sibling_container, container] = window else {
                 continue;
@@ -278,7 +278,7 @@ fn block_matches_block_pass(block: Node<'_>, send: Node<'_>, context: &RuleConte
     let Some(argument) = last_argument(send) else {
         return false;
     };
-    let Some(symbol) = super::nodes::children(argument).into_iter().next() else {
+    let Some(symbol) = super::nodes::children_in(argument, context).into_iter().next() else {
         return false;
     };
     send_node::symbol_name(symbol, context) == Some(method)
@@ -287,7 +287,7 @@ fn block_matches_block_pass(block: Node<'_>, send: Node<'_>, context: &RuleConte
 /// `symbol_proc_method?`: `(block _ (args (arg _name)) (send (lvar _name) $_method_name))`.
 fn symbol_proc_method<'a>(node: Node<'_>, context: &'a RuleContext<'_>) -> Option<&'a str> {
     let block = block_of(node)?;
-    let parameters = super::nodes::children(block.field("parameters")?);
+    let parameters = super::nodes::children_in(block.field("parameters")?, context);
     let [only] = parameters.as_slice() else {
         return None;
     };

data/src/rules/style/percent.rs

@@ -10,6 +10,7 @@ use tree_sitter::Node;
 
 use crate::rules::RuleContext;
 use crate::rules::node_ext::NodeExt;
+use crate::rules::send_node::named_children_iter;
 
 /// Node kinds that can be written as a `%`-literal. A node of one of these kinds is only a percent
 /// literal when its opening delimiter actually starts with `%`; `"a"` and `%q(a)` share a kind.
@@ -49,7 +50,7 @@ pub(super) struct PercentLiteral {
 
 impl PercentLiteral {
     pub(super) fn new(node: Node<'_>, context: &RuleContext<'_>) -> Option<Self> {
-        if node.child_count() < 2 || is_modulo_operand(node) {
+        if node.child_count() < 2 || is_modulo_operand(node, context) {
             return None;
         }
         let begin = node.child(0)?;
@@ -67,13 +68,20 @@ impl PercentLiteral {
         if !types_for(node.kind_str()).contains(&percent_type.as_str()) {
             return None;
         }
+        // **A literal closed by a newline leaves the grammar with an empty closing node.** `%\n\n`
+        // is a string whose delimiter is the line break: the break that ends it is counted into the
+        // content and the closing node sits after it with no text of its own. The delimiter is
+        // still there in the source, one character back from where the literal ends.
         let close_text = context.source.node_text(close);
-        let close_len = close_text.chars().next()?.len_utf8();
+        let close = match close_text.chars().next() {
+            Some(character) => close.start_byte()..close.start_byte() + character.len_utf8(),
+            None => node.end_byte().saturating_sub(opening.len_utf8())..node.end_byte(),
+        };
         Some(Self {
             percent_type,
             opening,
             begin: begin.byte_range(),
-            close: close.start_byte()..close.start_byte() + close_len,
+            close,
         })
     }
 }
@@ -91,8 +99,8 @@ pub(super) fn literal_segments<'a>(
     let text = context.source.text();
     let mut segments = Vec::new();
     if matches!(node.kind_str(), "string_array" | "symbol_array") {
-        let mut cursor = node.walk();
-        for element in node.named_children(&mut cursor) {
+        let _cursor = node.walk();
+        for element in named_children_iter(node, context) {
             if !holds_interpolation(element) {
                 segments.push(&text[element.byte_range()]);
             }
@@ -102,8 +110,8 @@ pub(super) fn literal_segments<'a>(
 
     // Everything else is one run of text, broken only where an interpolation replaces it with code.
     let mut start = literal.begin.end;
-    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;
         }
@@ -120,8 +128,9 @@ pub(super) fn literal_segments<'a>(
 /// is modulo and `"%s" %[x]` is a `send` whose argument is an array. tree-sitter chains the two into
 /// one literal anyway, which would otherwise hand every such call a percent literal that upstream
 /// never saw.
-pub(super) fn is_modulo_operand(node: Node<'_>) -> bool {
-    node.parent()
+pub(super) fn is_modulo_operand(node: Node<'_>, context: &RuleContext<'_>) -> bool {
+    context
+        .parent(node)
         .is_some_and(|parent| parent.kind_str() == "chained_string")
         && node.prev_named_sibling().is_some()
 }

data/src/rules/style/percent_q_literals.rs

@@ -3,6 +3,7 @@
 use crate::diagnostic::{Edit, Offense};
 use crate::rules::RuleContext;
 use crate::rules::node_ext::NodeExt;
+use crate::rules::send_node::named_children_of;
 
 const LOWER_CASE_Q_MSG: &str = "Do not use `%Q` unless interpolation is needed. Use `%q`.";
 const UPPER_CASE_Q_MSG: &str = "Use `%Q` instead of `%q`.";
@@ -21,7 +22,7 @@ pub(super) fn check(context: &RuleContext<'_>, offenses: &mut Vec<Offense>) {
         // `process(node, '%Q', '%q')` then `correct_literal_style?`.
         if !matches!(literal.percent_type.as_str(), "%q" | "%Q")
             || literal.percent_type == wanted
-            || !is_str(node)
+            || !is_str(node, context, &literal)
         {
             continue;
         }
@@ -31,7 +32,7 @@ pub(super) fn check(context: &RuleContext<'_>, offenses: &mut Vec<Offense>) {
         let delimiters = [literal.opening, closing_of(context, &literal)];
         let single = super::literal::decode(body, super::literal::Quoting::Single, &delimiters);
         let double = super::literal::decode(body, super::literal::Quoting::Double, &delimiters);
-        if single.value != double.value {
+        if single.value != double.value || (!lower_case && has_active_interpolation(body)) {
             continue;
         }
         let text = context.source.node_text(node);
@@ -60,6 +61,26 @@ pub(super) fn check(context: &RuleContext<'_>, offenses: &mut Vec<Offense>) {
     }
 }
 
+/// Whether changing a single-quoted percent literal to `%Q` would turn text into interpolation.
+/// An even run of backslashes leaves `#` active; an odd run escapes it (and the value comparison
+/// above separately catches the backslash whose meaning changes in that case).
+fn has_active_interpolation(body: &str) -> bool {
+    let bytes = body.as_bytes();
+    for index in 0..bytes.len().saturating_sub(1) {
+        if bytes[index] != b'#' || !matches!(bytes[index + 1], b'{' | b'$' | b'@') {
+            continue;
+        }
+        let mut slash = index;
+        while slash > 0 && bytes[slash - 1] == b'\\' {
+            slash -= 1;
+        }
+        if (index - slash) % 2 == 0 {
+            return true;
+        }
+    }
+    false
+}
+
 fn closing_of(context: &RuleContext<'_>, literal: &super::percent::PercentLiteral) -> char {
     context
         .source
@@ -71,10 +92,22 @@ fn closing_of(context: &RuleContext<'_>, literal: &super::percent::PercentLitera
 
 /// `node.str_type?`: a literal is a `dstr` upstream both when it interpolates and when its text
 /// does not fit on one line.
-fn is_str(node: tree_sitter::Node<'_>) -> bool {
-    let mut cursor = node.walk();
-    !node
-        .named_children(&mut cursor)
+fn is_str(
+    node: tree_sitter::Node<'_>,
+    context: &RuleContext<'_>,
+    literal: &super::percent::PercentLiteral,
+) -> bool {
+    let _cursor = node.walk();
+    if named_children_of(node, context)
+        .into_iter()
         .any(|child| child.kind_str() == "interpolation")
-        && node.start_position().row == node.end_position().row
+    {
+        return false;
+    }
+    // **The parser cuts the contents after every line break**, so a literal written over lines is
+    // a `dstr` of one `str` per line and `on_str` never sees it. A break that closes the contents
+    // leaves a single `str`, which is why `%Q{\n}` still reaches this cop.
+    let body = context.source.slice(literal.begin.end..literal.close.start);
+    !body.strip_suffix('\n').unwrap_or(body).contains('\n')
 }
+

data/src/rules/style/preferred_hash_methods.rs

@@ -14,7 +14,7 @@ pub(super) fn check(context: &RuleContext<'_>, offenses: &mut Vec<Offense>) {
         // `node.arguments.one?`: the predicate takes exactly the key it asks about.
         let one_argument = node
             .field("arguments")
-            .is_some_and(|arguments| super::nodes::children(arguments).len() == 1);
+            .is_some_and(|arguments| super::nodes::children_in(arguments, context).len() == 1);
         if !one_argument {
             continue;
         }

data/src/rules/style/quoted_symbols.rs

@@ -63,6 +63,12 @@ fn symbol_kind(node: Node<'_>, context: &RuleContext<'_>) -> Option<bool> {
         return None;
     }
     if node.kind_str() == "delimited_symbol" {
+        // A literal running over more than one line is a `dsym` too: the parser gives each line a
+        // `str` of its own and hangs them under one, so `on_sym` never sees it. A break that closes
+        // the contents leaves one `str`, and `:"two\n"` stays a `sym`.
+        if crate::rules::support::quoted_spans_lines(context.source.node_text(node)) {
+            return None;
+        }
         // An empty `:""` is a `dsym` upstream as well -- but an empty hash key is a plain `sym`.
         return (node.named_child_count() > 0).then_some(false);
     }

data/src/rules/style/raise_args.rs

@@ -37,15 +37,19 @@ pub(super) fn check(context: &RuleContext<'_>, offenses: &mut Vec<Offense>) {
         let written = arguments(node);
         let range = send_range(node, context);
         let offense = if compact {
-            let Some(edit) = exploded_to_compact(context, node, &written, &range) else {
+            if !reports_compact(&written) {
                 continue;
-            };
-            context
-                .offense(
-                    format!("Provide an exception object as an argument to `{method}`."),
-                    range.clone(),
-                )
-                .corrected_by(edit)
+            }
+            let offense = context.offense(
+                format!("Provide an exception object as an argument to `{method}`."),
+                range.clone(),
+            );
+            // `correction_exploded_to_compact` hands back the original source when there is more
+            // than one message argument, so the offense stands without a rewrite.
+            match exploded_to_compact(context, node, &written, &range) {
+                Some(edit) => offense.corrected_by(edit),
+                None => offense,
+            }
         } else {
             let Some(edit) = compact_to_exploded(context, node, &written, &range, &allowed) else {
                 continue;
@@ -115,27 +119,29 @@ fn compact_to_exploded(
 }
 
 /// `check_compact` plus `correction_exploded_to_compact`.
+/// `check_compact`: more than one argument, unless the exception itself was handed a hash.
+fn reports_compact(written: &[crate::rules::send_node::Argument<'_>]) -> bool {
+    if written.len() <= 1 {
+        return false;
+    }
+    let exception = written[0].first();
+    // A call whose own first argument is a hash is `raise Klass, key: value`, which stays.
+    !(exception.kind_str() == "call"
+        && arguments(exception)
+            .first()
+            .is_some_and(|argument| matches!(argument.first().kind_str(), "pair" | "hash")))
+}
+
 fn exploded_to_compact(
     context: &RuleContext<'_>,
     node: Node<'_>,
     written: &[crate::rules::send_node::Argument<'_>],
     range: &std::ops::Range<usize>,
 ) -> Option<Edit> {
-    if written.len() <= 1 {
+    if !reports_compact(written) || written.len() > 2 {
         return None;
     }
     let exception = written[0].first();
-    // A call whose own first argument is a hash is `raise Klass, key: value`, which stays.
-    if exception.kind_str() == "call"
-        && arguments(exception)
-            .first()
-            .is_some_and(|argument| matches!(argument.first().kind_str(), "pair" | "hash"))
-    {
-        return None;
-    }
-    if written.len() > 2 {
-        return None;
-    }
     let argument = context.source.slice(written[1].range());
     let exception_class = exception.field("receiver").map_or_else(
         || context.source.node_text(exception),

data/src/rules/style/random_with_offset.rs

@@ -117,7 +117,7 @@ fn random_call(context: &RuleContext<'_>, node: Node<'_>) -> Option<Random> {
             format!("{source}.rand")
         }
     };
-    let arguments = super::nodes::children(node.field("arguments")?);
+    let arguments = super::nodes::children_in(node.field("arguments")?, context);
     let [argument] = arguments.as_slice() else {
         return None;
     };

data/src/rules/style/reduce_to_hash.rs

@@ -95,12 +95,12 @@ struct Built<'tree> {
 fn hash_builder<'tree>(
     node: Node<'tree>,
     block: Node<'tree>,
-    context: &RuleContext<'_>,
+    context: &'tree RuleContext<'_>,
     locals: &LocalVariables<'_, '_>,
 ) -> Option<Built<'tree>> {
     let folding = context.source.node_text(node.field("method")?) != "each_with_object";
     // `(hash)`: the seed has to be an empty literal.
-    let arguments = super::nodes::children(node.field("arguments")?);
+    let arguments = super::nodes::children_in(node.field("arguments")?, context);
     match arguments.as_slice() {
         [only] if only.kind_str() == "hash" && only.named_child_count() == 0 => {}
         _ => return None,
@@ -153,7 +153,7 @@ fn hash_builder<'tree>(
 fn subscript_assignment<'tree>(
     node: Node<'tree>,
     accumulator: &str,
-    context: &RuleContext<'_>,
+    context: &'tree RuleContext<'_>,
 ) -> Option<(Node<'tree>, Node<'tree>)> {
     if node.kind_str() != "assignment" {
         return None;
@@ -166,7 +166,7 @@ fn subscript_assignment<'tree>(
     if context.source.node_text(object) != accumulator {
         return None;
     }
-    let indices = super::nodes::children(target);
+    let indices = super::nodes::children_in(target, context);
     let [_, key] = indices.as_slice() else {
         return None;
     };
@@ -178,7 +178,7 @@ fn reads(node: Node<'_>, name: &str, context: &RuleContext<'_>) -> bool {
     if node.kind_str() == "identifier" && context.source.node_text(node) == name {
         return true;
     }
-    super::nodes::children(node)
+    super::nodes::children_in(node, context)
         .into_iter()
         .any(|child| reads(child, name, context))
 }
@@ -200,7 +200,7 @@ fn nested_match(
     {
         return true;
     }
-    super::nodes::children(node)
+    super::nodes::children_in(node, context)
         .into_iter()
         .any(|child| nested_match(child, context, locals))
 }

data/src/rules/style/redundant_argument.rs

@@ -53,7 +53,7 @@ pub(super) fn check(context: &RuleContext<'_>, offenses: &mut Vec<Offense>) {
         let Some(arguments) = node.field("arguments") else {
             continue;
         };
-        let written = super::nodes::children(arguments);
+        let written = super::nodes::children_in(arguments, context);
         let [only] = written.as_slice() else {
             continue;
         };

data/src/rules/style/redundant_assignment.rs

@@ -21,9 +21,9 @@ pub(super) fn check(context: &RuleContext<'_>, offenses: &mut Vec<Offense>) {
 /// `EnsureNode#branch` -- the *ensure* clause -- so the code it guards is never looked at. A body
 /// split by a `rescue` alone is a `rescue` node, every branch of which is followed.
 fn check_container(context: &RuleContext<'_>, container: Node<'_>, offenses: &mut Vec<Offense>) {
-    let children = super::nodes::children(container);
+    let children = super::nodes::children_in(container, context);
     if let Some(ensure) = children.iter().find(|child| child.kind_str() == "ensure") {
-        let statements = super::nodes::children(*ensure);
+        let statements = super::nodes::children_in(*ensure, context);
         check_statements(context, &statements, offenses);
         return;
     }
@@ -44,7 +44,7 @@ fn check_container(context: &RuleContext<'_>, container: Node<'_>, offenses: &mu
                 }
             }
             "else" => {
-                let statements = super::nodes::children(*clause);
+                let statements = super::nodes::children_in(*clause, context);
                 check_statements(context, &statements, offenses);
             }
             _ => {}
@@ -131,7 +131,7 @@ fn comments_between(context: &RuleContext<'_>, assignment: Node<'_>, reference:
 fn check_branch(context: &RuleContext<'_>, node: Node<'_>, offenses: &mut Vec<Offense>) {
     match node.kind_str() {
         "case" | "case_match" => {
-            for child in super::nodes::children(node) {
+            for child in super::nodes::children_in(node, context) {
                 match child.kind_str() {
                     "when" | "in_clause" => {
                         if let Some(body) = child.field("body") {
@@ -139,7 +139,7 @@ fn check_branch(context: &RuleContext<'_>, node: Node<'_>, offenses: &mut Vec<Of
                         }
                     }
                     "else" => {
-                        let statements = super::nodes::children(child);
+                        let statements = super::nodes::children_in(child, context);
                         check_statements(context, &statements, offenses);
                     }
                     _ => {}

data/src/rules/style/redundant_begin.rs

@@ -19,7 +19,9 @@ const IMPLICIT_BEGIN_VERSION: RubyVersion = RubyVersion::new(2, 5);
 
 /// The clauses that make the parser put a `rescue` or an `ensure` node between the `kwbegin` and
 /// its statements, which is what leaves it a single child.
-const CLAUSES: &[&str] = &["rescue", "ensure", "else"];
+/// `contain_rescue_or_ensure?` asks for a `rescue` or an `ensure` and **not** for an `else`: a
+/// `begin ... else ... end` written without a `rescue` is the redundant `begin` this cop reports.
+const CLAUSES: &[&str] = &["rescue", "ensure"];
 
 pub(super) fn check(context: &RuleContext<'_>, offenses: &mut Vec<Offense>) {
     // `add_offense` refuses a range it has already reported, and every handler here reports the
@@ -193,7 +195,7 @@ fn replace_begin_with_statement(
     edits: &mut Vec<Edit>,
     anchor: &mut Option<Range<usize>>,
 ) {
-    let Some(first) = super::nodes::children(node).first().copied() else {
+    let Some(first) = super::nodes::children_in(node, context).first().copied() else {
         return;
     };
     let source = context.source.node_text(first);
@@ -236,7 +238,7 @@ fn correct_modifier_form(
     anchor: &mut Option<Range<usize>>,
 ) {
     let (Some(first), Some(keyword), Some(condition)) = (
-        super::nodes::children(node).first().copied(),
+        super::nodes::children_in(node, context).first().copied(),
         modifier_keyword(parent),
         parent.field("condition"),
     ) else {

data/src/rules/style/redundant_capital_w.rs

@@ -3,6 +3,7 @@
 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 = "Do not use `%W` unless interpolation is needed. If not, use `%w`.";
 
@@ -16,8 +17,8 @@ pub(super) fn check(context: &RuleContext<'_>, offenses: &mut Vec<Offense>) {
         }
         // `requires_interpolation?`: an element that interpolates, or one whose text could not be
         // written between single quotes.
-        let mut cursor = node.walk();
-        let interpolates = node.named_children(&mut cursor).any(|element| {
+        let _cursor = node.walk();
+        let interpolates = named_children_iter(node, context).any(|element| {
             holds_interpolation(element)
                 || super::literal::double_quotes_required(context.source.node_text(element))
         });

data/src/rules/style/redundant_condition.rs

@@ -5,6 +5,8 @@ use tree_sitter::Node;
 use crate::diagnostic::{Edit, Offense};
 use crate::rules::RuleContext;
 use crate::rules::node_ext::NodeExt;
+use crate::rules::send_node::all_children_of;
+use crate::rules::send_node::all_children_iter;
 
 const MSG: &str = "Use double pipes `||` instead.";
 const REDUNDANT_CONDITION: &str = "This condition is not needed.";
@@ -63,8 +65,12 @@ pub(super) fn check(context: &RuleContext<'_>, offenses: &mut Vec<Offense>) {
             "unless" => (normalized_else.clone(), normalized_if.clone()),
             _ => (normalized_if.clone(), normalized_else.clone()),
         };
+        // `if_branch_is_true_type_and_else_is_not?` returns early unless the conditional was
+        // written as an `if` or a ternary: `unless x then true else false end` is outside it.
+        let is_if = node.kind_str() != "unless";
         if !is_offense(
             context,
+            is_if,
             ternary,
             condition,
             &raw_if,
@@ -111,6 +117,7 @@ pub(super) fn check(context: &RuleContext<'_>, offenses: &mut Vec<Offense>) {
 #[allow(clippy::too_many_arguments)]
 fn is_offense(
     context: &RuleContext<'_>,
+    is_if: bool,
     ternary: bool,
     condition: Node<'_>,
     raw_if: &Option<Branch<'_>>,
@@ -137,6 +144,7 @@ fn is_offense(
     }
     if !synonymous(
         context,
+        is_if,
         condition,
         raw_if,
         normalized_if,
@@ -179,6 +187,7 @@ fn is_plain_node(branch: &Branch<'_>) -> bool {
 
 fn synonymous(
     context: &RuleContext<'_>,
+    is_if: bool,
     condition: Node<'_>,
     raw_if: &Option<Branch<'_>>,
     normalized_if: &Option<Branch<'_>>,
@@ -192,7 +201,7 @@ fn synonymous(
     {
         return true;
     }
-    if if_branch_is_true(context, condition, normalized_if, normalized_else, allowed) {
+    if is_if && if_branch_is_true(context, condition, normalized_if, normalized_else, allowed) {
         return true;
     }
     if assignment_pair(context, normalized_if, normalized_else).is_some()
@@ -446,8 +455,8 @@ fn branch<'tree>(node: Node<'tree>, want_consequence: bool) -> Option<Branch<'tr
 
 /// `range_between(node.loc.question.begin_pos, node.loc.colon.end_pos)`.
 fn question_to_colon(context: &RuleContext<'_>, node: Node<'_>) -> Option<Range<usize>> {
-    let mut cursor = node.walk();
-    let children: Vec<Node<'_>> = node.children(&mut cursor).collect();
+    let _cursor = node.walk();
+    let children: Vec<Node<'_>> = all_children_iter(node, context).collect();
     let question = children
         .iter()
         .find(|child| context.source.node_text(**child) == "?")?;
@@ -591,16 +600,16 @@ fn stands_in_a_send(context: &RuleContext<'_>, node: Node<'_>) -> bool {
 
 /// The operator token a binary expression is written with, which the grammar keeps unnamed.
 fn binary_operator<'a>(context: &'a RuleContext<'_>, node: Node<'_>) -> Option<&'a str> {
-    let mut cursor = node.walk();
-    let operator = node
-        .children(&mut cursor)
+    let _cursor = node.walk();
+    let operator = all_children_of(node, context)
+        .into_iter()
         .find(|child| !child.is_named() && !child.is_extra())?;
     Some(context.source.node_text(operator))
 }
 
 fn writes_through_safe_navigation(context: &RuleContext<'_>, call: Node<'_>) -> bool {
-    let mut cursor = call.walk();
-    call.children(&mut cursor)
+    let _cursor = call.walk();
+    all_children_iter(call, context)
         .any(|child| !child.is_named() && context.source.node_text(child) == "&.")
 }