sonicop 26.8.111 → 26.8.113

data/src/rules/style/empty_block_parameter.rs

@@ -17,7 +17,7 @@ pub(super) fn check(context: &RuleContext<'_>, offenses: &mut Vec<Offense>) {
             continue;
         };
         // `empty_and_without_delimiters?`: bars were written around nothing.
-        if !super::nodes::children(parameters).is_empty() {
+        if !super::nodes::children_in(parameters, context).is_empty() {
             continue;
         }
         let Some(begin) = block.child(0) else {

data/src/rules/style/empty_case_condition.rs

@@ -15,7 +15,7 @@ pub(super) fn check(context: &RuleContext<'_>, offenses: &mut Vec<Offense>) {
         if is_unsupported_parent(context, node) {
             continue;
         }
-        let branches = super::nodes::children(node);
+        let branches = super::nodes::children_in(node, context);
         let whens: Vec<Node<'_>> = branches
             .iter()
             .copied()
@@ -29,7 +29,7 @@ pub(super) fn check(context: &RuleContext<'_>, offenses: &mut Vec<Offense>) {
             .iter()
             .filter_map(|when| when.field("body"))
             .chain(branches.iter().copied().filter(|it| it.kind_str() == "else"));
-        if bodies.into_iter().any(holds_return) {
+        if bodies.into_iter().any(|body| holds_return(body, context)) {
             continue;
         }
         let (Some(case_keyword), Some(when_keyword)) = (node.child(0), first_when.child(0)) else {
@@ -109,9 +109,9 @@ fn is_unsupported_parent(context: &RuleContext<'_>, node: Node<'_>) -> bool {
     }
 }
 
-fn holds_return(body: Node<'_>) -> bool {
+fn holds_return(body: Node<'_>, context: &RuleContext<'_>) -> bool {
     let mut found = false;
-    walk_named(body, &mut |node| {
+    walk_named(body, context, &mut |node| {
         found = found || node.kind_str() == "return";
     });
     found
@@ -148,7 +148,7 @@ fn correct_when_conditions(
     // the `case`, because the node it reaches for is not there.
     let nested = has_upstream_parent(case_node);
     for when in whens {
-        let conditions: Vec<Node<'_>> = super::nodes::children(*when)
+        let conditions: Vec<Node<'_>> = super::nodes::children_in(*when, context)
             .into_iter()
             .filter(|child| child.kind_str() == "pattern")
             .collect();
@@ -191,7 +191,7 @@ fn then_keyword<'tree>(when: Node<'tree>) -> Option<Node<'tree>> {
 /// once the conditions are joined with one.
 fn parenthesize(context: &RuleContext<'_>, condition: Node<'_>) -> String {
     let source = context.source.node_text(condition);
-    let inner = super::nodes::children(condition);
+    let inner = super::nodes::children_in(condition, context);
     let binds_looser = match inner.as_slice() {
         [only] => match only.kind_str() {
             "if" | "unless" | "if_modifier" | "unless_modifier" | "conditional" | "range" => true,

data/src/rules/style/empty_class_definition.rs

@@ -101,7 +101,7 @@ fn check_class(
     if node.field("body").is_some() {
         return;
     }
-    let parts = super::nodes::children(superclass);
+    let parts = super::nodes::children_in(superclass, context);
     let [parent] = parts.as_slice() else {
         return;
     };

data/src/rules/style/empty_else.rs

@@ -39,7 +39,7 @@ pub(super) fn check(context: &RuleContext<'_>, offenses: &mut Vec<Offense>) {
         let Some(keyword) = clause.child(0) else {
             continue;
         };
-        let body = super::nodes::children(clause);
+        let body = super::nodes::children_in(clause, context);
         let reportable = match body.as_slice() {
             [] => empty_style,
             [only] => nil_style && only.kind_str() == "nil",

data/src/rules/style/empty_heredoc.rs

@@ -15,10 +15,16 @@ pub(super) fn check(context: &RuleContext<'_>, offenses: &mut Vec<Offense>) {
         if context.source.node_text(node).contains('`') {
             continue;
         }
+        // **An empty delimiter leaves upstream with nothing to point at.** `<<''` parses to a
+        // `dstr` with no children and no expression range, so `add_offense` raises a `TypeError`
+        // the runner swallows and the cop reports nothing. Silence is what upstream does here.
+        if has_empty_delimiter(node, context) {
+            continue;
+        }
         let Some(body) = heredoc_body(node, context) else {
             continue;
         };
-        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 {
@@ -49,6 +55,13 @@ pub(super) fn check(context: &RuleContext<'_>, offenses: &mut Vec<Offense>) {
     }
 }
 
+/// Whether the opener names its terminator with an empty quoted string, as `<<''` does.
+fn has_empty_delimiter(node: Node<'_>, context: &RuleContext<'_>) -> bool {
+    let text = context.source.node_text(node);
+    let delimiter = text.trim_start_matches('<').trim_start_matches(['~', '-']);
+    matches!(delimiter, "''" | "\"\"")
+}
+
 /// `node.loc.heredoc_body.source.empty?`.
 ///
 /// The grammar's body starts where the opener was written rather than on the line below, and it runs

data/src/rules/style/empty_lambda_parameter.rs

@@ -10,7 +10,7 @@ pub(super) fn check(context: &RuleContext<'_>, offenses: &mut Vec<Offense>) {
             continue;
         };
         // `empty_and_without_delimiters?`: parentheses were written around nothing.
-        if !super::nodes::children(parameters).is_empty() {
+        if !super::nodes::children_in(parameters, context).is_empty() {
             continue;
         }
         // `send_node.source_range.end_pos`: the end of the `->` the parameters follow.

data/src/rules/style/empty_literal.rs

@@ -73,7 +73,7 @@ impl Literal {
         match node.kind_str() {
             // `Array[]` and `Hash[]`, which upstream reads as a call to `:[]` with no arguments.
             "element_reference" => {
-                if super::nodes::children(node).len() != 1 {
+                if super::nodes::children_in(node, context).len() != 1 {
                     return None;
                 }
                 let object = node.field("object")?;
@@ -110,6 +110,13 @@ impl Literal {
                         if literal != Self::String && node.field("block").is_some() {
                             return None;
                         }
+                        // **`hash_with_block(node.parent)` reaches past the call's own block.**
+                        // A `Hash.new` written as the body of another `Hash.new`'s block has that
+                        // block for a parent upstream, so the check meant for the outer call
+                        // silences the inner one too.
+                        if literal == Self::Hash && inside_hash_new_block(node, context) {
+                            return None;
+                        }
                         Some(literal)
                     }
                     // `Array([])` and `Hash([])`, the conversion functions.
@@ -135,6 +142,31 @@ impl Literal {
 }
 
 /// `(const {nil? cbase} :Array)` and its `Hash` and `String` counterparts.
+/// Whether the call stands as the body of a `Hash.new { ... }` block, which is what
+/// `hash_with_block(node.parent)` answers to for a nested call.
+fn inside_hash_new_block(node: Node<'_>, context: &RuleContext<'_>) -> bool {
+    let Some(body) = node.parent_of(context) else {
+        return false;
+    };
+    let Some(block) = body
+        .parent_of(context)
+        .filter(|parent| matches!(parent.kind_str(), "block" | "do_block"))
+        .or_else(|| matches!(body.kind_str(), "block" | "do_block").then_some(body))
+    else {
+        return false;
+    };
+    block
+        .parent_of(context)
+        .filter(|call| call.kind_str() == "call")
+        .is_some_and(|call| {
+            call.field("method")
+                .is_some_and(|method| context.source.node_text(method) == "new")
+                && call
+                    .field("receiver")
+                    .is_some_and(|receiver| context.source.node_text(receiver) == "Hash")
+        })
+}
+
 fn named_constant(node: Node<'_>, context: &RuleContext<'_>) -> Option<Literal> {
     for (name, literal) in [
         ("Array", Literal::Array),
@@ -150,7 +182,7 @@ fn named_constant(node: Node<'_>, context: &RuleContext<'_>) -> Option<Literal>
 
 fn is_empty_array(node: Node<'_>, context: &RuleContext<'_>) -> bool {
     node.kind_str() == "array"
-        && super::nodes::children(node).is_empty()
+        && super::nodes::children_in(node, context).is_empty()
         && context.source.node_text(node).starts_with('[')
 }
 

data/src/rules/style/empty_method.rs

@@ -89,7 +89,7 @@ fn parameters(context: &RuleContext<'_>, node: Node<'_>) -> String {
     let Some(list) = node.field("parameters") else {
         return String::new();
     };
-    let sources: Vec<&str> = super::nodes::children(list)
+    let sources: Vec<&str> = super::nodes::children_in(list, context)
         .into_iter()
         .map(|parameter| context.source.node_text(parameter))
         .collect();

data/src/rules/style/empty_string_inside_interpolation.rs

@@ -14,7 +14,7 @@ pub(super) fn check(context: &RuleContext<'_>, offenses: &mut Vec<Offense>) {
         .setting::<String>("EnforcedStyle")
         .is_some_and(|style| style == "ternary");
     for node in context.nodes_of("interpolation") {
-        for child in super::nodes::children(node) {
+        for child in super::nodes::children_in(node, context) {
             if ternary_style {
                 ternary_correction(context, node, child, offenses);
             } else {

data/src/rules/style/endless.rs

@@ -37,10 +37,18 @@ pub(super) fn receiver(context: &RuleContext<'_>, node: Node<'_>) -> String {
     format!("{}{operator}", context.source.node_text(object))
 }
 
-/// `arguments`: the parameter list as it was written, parentheses and all.
+/// `arguments`: `node.arguments.any? ? node.arguments.source : ''`.
+///
+/// Upstream asks the list what it holds, not whether it was written, so an empty `()` is dropped:
+/// `def foo() = x` rewrites to `def foo`, not `def foo()`.
 pub(super) fn arguments<'a>(context: &'a RuleContext<'_>, node: Node<'_>) -> &'a str {
-    node.field("parameters")
-        .map_or("", |parameters| context.source.node_text(parameters))
+    let Some(parameters) = node.field("parameters") else {
+        return "";
+    };
+    match super::nodes::children_in(parameters, context).is_empty() {
+        true => "",
+        false => context.source.node_text(parameters),
+    }
 }
 
 /// `configured_indentation_width`.

data/src/rules/style/env_home.rs

@@ -24,7 +24,7 @@ pub(super) fn check(context: &RuleContext<'_>, offenses: &mut Vec<Offense>) {
         if is_assignment_target(node, context) {
             continue;
         }
-        let parts = super::nodes::children(node);
+        let parts = super::nodes::children_in(node, context);
         let [object, index] = parts.as_slice() else {
             continue;
         };

data/src/rules/style/eval_with_location.rs

@@ -354,6 +354,12 @@ fn arguments<'tree>(call: Node<'tree>) -> Vec<Arg<'tree>> {
     let mut out = Vec::new();
     for argument in send_node::arguments(call) {
         let (node, range) = (argument.first(), argument.range());
+        // **A heredoc's body is written inside the argument list here.** Upstream keeps it under
+        // the opening marker, so the body is no argument of its own -- reading it as the last one
+        // made `__LINE__ + 1` invisible and quoted the whole body back at the user.
+        if node.kind_str() == "heredoc_body" {
+            continue;
+        }
         let folded = (argument.parts().len() == 1 && node.kind_str() == "assignment")
             .then(|| node.field("left"))
             .flatten()

data/src/rules/style/even_odd.rs

@@ -21,7 +21,7 @@ pub(super) fn check(context: &RuleContext<'_>, offenses: &mut Vec<Offense>) {
         };
         // `{(send $_ :% (int 2)) (begin (send $_ :% (int 2)))}`.
         let modulo = match left.kind_str() {
-            "parenthesized_statements" => match super::nodes::children(left).as_slice() {
+            "parenthesized_statements" => match super::nodes::children_in(left, context).as_slice() {
                 [only] => *only,
                 _ => continue,
             },

data/src/rules/style/exact_regexp_match.rs

@@ -83,7 +83,7 @@ fn match_call<'tree>(
 /// sequences, so what is left is checking that the run between them holds nothing a regexp engine
 /// would read as syntax, and that no flag was written after the closing delimiter.
 fn exact_match_text<'a>(node: Node<'_>, context: &'a RuleContext<'_>) -> Option<&'a str> {
-    let parts = super::nodes::children(node);
+    let parts = super::nodes::children_in(node, context);
     let [start, literal, end] = parts.as_slice() else {
         return None;
     };

data/src/rules/style/expand_path_arguments.rs

@@ -77,7 +77,7 @@ fn report_file(
     if context.source.node_text(default_dir) != "__FILE__"
         || path.kind_str() != "string"
         || path.start_position().row != path.end_position().row
-        || super::nodes::children(path)
+        || super::nodes::children_in(path, context)
             .iter()
             .any(|child| child.kind_str() == "interpolation")
     {
@@ -158,7 +158,7 @@ fn file_expand_path<'tree>(
 /// `Pathname(x).parent.expand_path` and `Pathname.new(x).parent.expand_path`: the `.parent` call,
 /// the argument, and which of the two spellings it was.
 fn pathname_parent<'tree>(
-    context: &RuleContext<'_>,
+    context: &'tree RuleContext<'_>,
     node: Node<'tree>,
 ) -> Option<(Node<'tree>, Node<'tree>, bool)> {
     if node.field("arguments").is_some() {
@@ -178,7 +178,7 @@ fn pathname_parent<'tree>(
         return None;
     }
     let arguments = call.field("arguments")?;
-    let [argument] = super::nodes::children(arguments)[..] else {
+    let [argument] = super::nodes::children_in(arguments, context)[..] else {
         return None;
     };
     let method = call.field("method")?;

data/src/rules/style/explicit_block_argument.rs

@@ -23,7 +23,7 @@ pub(super) fn check(context: &RuleContext<'_>, offenses: &mut Vec<Offense>) {
             .map(super::nodes::children)
             .unwrap_or_default();
         // The grammar hangs a `yield`'s arguments off it without a field name.
-        let yield_arguments = super::nodes::children(node)
+        let yield_arguments = super::nodes::children_in(node, context)
             .into_iter()
             .find(|child| child.kind_str() == "argument_list")
             .map(super::nodes::children)
@@ -92,7 +92,7 @@ fn yielding_block<'tree>(node: Node<'tree>, context: &RuleContext<'_>) -> Option
     if !matches!(body.kind_str(), "block_body" | "body_statement") {
         return None;
     }
-    match super::nodes::children(body).as_slice() {
+    match super::nodes::children_in(body, context).as_slice() {
         [only] if only.id() == node.id() => {}
         _ => return None,
     }
@@ -193,7 +193,7 @@ fn zsuper_arguments(
     if call.field("method")?.kind_str() != "super" {
         return None;
     }
-    let parameters = super::nodes::children(definition.field("parameters")?);
+    let parameters = super::nodes::children_in(definition.field("parameters")?, context);
     let written: Vec<String> = parameters
         .into_iter()
         .map(|parameter| match parameter.kind_str() {

data/src/rules/style/file_open.rs

@@ -19,6 +19,11 @@ pub(super) fn check(context: &RuleContext<'_>, offenses: &mut Vec<Offense>) {
         {
             continue;
         }
+        // `on_send` is never called for a `csend`, and this cop does not alias `on_csend`, so
+        // `File&.open` is not its business. The grammar spells both as `call`.
+        if !crate::rules::send_node::is_plain_send(node, context) {
+            continue;
+        }
         // `node.block_argument?`: `File.open(path, &:read)` hands the descriptor to something that
         // closes it.
         if arguments(node)

data/src/rules/style/file_open_call.rs

@@ -53,7 +53,7 @@ pub(super) fn parse<'a>(
             if node.kind_str() != "block_argument" {
                 return None;
             }
-            let symbol = super::nodes::children(node);
+            let symbol = super::nodes::children_in(node, context);
             let [symbol] = symbol.as_slice() else {
                 return None;
             };
@@ -77,14 +77,14 @@ pub(super) fn block_calls<'tree>(
     arity: usize,
 ) -> Option<Vec<Range<usize>>> {
     let block = node.field("block")?;
-    let parameters = super::nodes::children(block.field("parameters")?);
+    let parameters = super::nodes::children_in(block.field("parameters")?, context);
     let [parameter] = parameters.as_slice() else {
         return None;
     };
     if parameter.kind_str() != "identifier" {
         return None;
     }
-    let body = super::nodes::children(block.field("body")?);
+    let body = super::nodes::children_in(block.field("body")?, context);
     let [statement] = body.as_slice() else {
         return None;
     };

data/src/rules/style/file_write.rs

@@ -109,7 +109,7 @@ fn removed_heredocs(
         let Some(body) = crate::rules::send_node::heredoc_body(opener, context) else {
             continue;
         };
-        let parts = super::nodes::children(body);
+        let parts = super::nodes::children_in(body, context);
         let Some(terminator) = parts.iter().find(|part| part.kind_str() == "heredoc_end") else {
             continue;
         };

data/src/rules/style/for.rs

@@ -33,7 +33,7 @@ pub(super) fn check(context: &RuleContext<'_>, offenses: &mut Vec<Offense>) {
 fn for_to_each(context: &RuleContext<'_>, node: Node<'_>) -> Option<Offense> {
     let variable = node.field("pattern")?;
     let value = node.field("value")?;
-    let collection = *super::nodes::children(value).first()?;
+    let collection = *super::nodes::children_in(value, context).first()?;
     let body = node.field("body")?;
     // `for_node.do?`: the head ends at the `do` when there is one, and at the collection otherwise.
     let end = match body.child(0).filter(|first| first.kind_str() == "do") {

data/src/rules/style/format_sequences.rs

@@ -24,6 +24,9 @@ pub(super) struct Sequence {
     pub flags: String,
     pub width: String,
     pub precision: String,
+    /// Whether a `.` was written at all. `%.d` is a precision of **zero**, which prints no digits,
+    /// and an empty `precision` cannot tell that apart from a sequence with no precision.
+    pub has_precision: bool,
     pub name: Option<String>,
     /// The type character, absent from a template sequence.
     pub kind: Option<char>,
@@ -65,6 +68,7 @@ fn match_at(text: &str, bytes: &[u8], start: usize) -> Option<Sequence> {
             flags: String::new(),
             width: String::new(),
             precision: String::new(),
+            has_precision: false,
             name: None,
             kind: Some('%'),
             style: SequenceStyle::Percent,
@@ -204,12 +208,14 @@ fn build(
         Some(_) if source.contains('{') => SequenceStyle::Template,
         _ => SequenceStyle::Unannotated,
     };
+    let has_precision = source.contains('.');
     Sequence {
         begin,
         end,
         flags,
         width,
         precision,
+        has_precision,
         name,
         kind,
         style,

data/src/rules/style/format_string.rs

@@ -6,8 +6,8 @@ use tree_sitter::Node;
 
 use crate::diagnostic::{Edit, Offense};
 use crate::rules::RuleContext;
-use crate::rules::send_node::{Argument, arguments, is_plain_send};
 use crate::rules::node_ext::NodeExt;
+use crate::rules::send_node::{Argument, arguments, is_plain_send};
 
 /// Literal kinds a leading sign belongs to rather than turning into a `:-@` call.
 const NUMBER_KINDS: &[&str] = &["integer", "float", "rational", "complex"];
@@ -68,6 +68,8 @@ struct Formatter<'tree> {
     receiver: Option<Range<usize>>,
     /// `node.first_argument`, which is all either correction reads.
     argument: Option<Operand<'tree>>,
+    /// `node.arguments` of a `format` / `sprintf` call, which only the `percent` correction reads.
+    written: Vec<Argument<'tree>>,
 }
 
 impl<'tree> Formatter<'tree> {
@@ -99,6 +101,7 @@ impl<'tree> Formatter<'tree> {
             span: node.byte_range(),
             receiver: Some(left.byte_range()),
             argument: Some(Operand::Node(right)),
+            written: Vec::new(),
         })
     }
 
@@ -125,6 +128,7 @@ impl<'tree> Formatter<'tree> {
             span: node.byte_range(),
             receiver: Some(first.byte_range()),
             argument: Some(Operand::Text(second.start_byte() + 1..second.end_byte())),
+            written: Vec::new(),
         })
     }
 
@@ -148,6 +152,7 @@ impl<'tree> Formatter<'tree> {
                 span: node.byte_range(),
                 receiver: Some(receiver.byte_range()),
                 argument: first.map(Operand::Node),
+                written: Vec::new(),
             });
         }
         // `(send nil? ${:sprintf :format} _ _ ...)`: no receiver and at least two arguments.
@@ -157,7 +162,8 @@ impl<'tree> Formatter<'tree> {
         {
             return None;
         }
-        if arguments(node).len() < 2 {
+        let written = arguments(node);
+        if written.len() < 2 {
             return None;
         }
         Some(Self {
@@ -166,15 +172,14 @@ impl<'tree> Formatter<'tree> {
             span: node.byte_range(),
             receiver: None,
             argument: None,
+            written,
         })
     }
 }
 
 fn correction(context: &RuleContext<'_>, found: &Formatter<'_>, style: &str) -> Option<Edit> {
-    // `autocorrect_to_percent` is only reachable with `EnforcedStyle: percent`, which no corpus
-    // configures; the offense is reported without a correction rather than guessed at.
     if style == "percent" {
-        return None;
+        return to_percent(context, found);
     }
     if found.detected != "percent" {
         return Some(Edit {
@@ -193,7 +198,7 @@ fn correction(context: &RuleContext<'_>, found: &Formatter<'_>, style: &str) ->
     let receiver = found.receiver.clone()?;
     let args = match argument {
         Operand::Node(node) if matches!(node.kind_str(), "array" | "hash") => {
-            super::nodes::children(*node)
+            super::nodes::children_in(*node, context)
                 .iter()
                 .map(|child| context.source.node_text(*child))
                 .collect::<Vec<_>>()
@@ -213,6 +218,67 @@ fn correction(context: &RuleContext<'_>, found: &Formatter<'_>, style: &str) ->
     })
 }
 
+/// `autocorrect_to_percent`: `format(fmt, a, b)` becomes `fmt % [a, b]`, and a single parameter
+/// stands on its own.
+fn to_percent(context: &RuleContext<'_>, found: &Formatter<'_>) -> Option<Edit> {
+    let (format, parameters) = found.written.split_first()?;
+    let args = match parameters {
+        // A brace-less hash is one `hash` argument upstream, and `format_single_parameter` writes
+        // a hash back in braces: `fmt % { a: 1, b: 2 }`.
+        [only] if only.parts().len() > 1 || only.first().kind_str() == "pair" => {
+            format!("{{ {} }}", context.source.slice(only.range()))
+        }
+        [only] => format_single_parameter(context, only.first()),
+        _ => format!(
+            "[{}]",
+            parameters
+                .iter()
+                .map(|argument| context.source.slice(argument.range()).to_owned())
+                .collect::<Vec<_>>()
+                .join(", ")
+        ),
+    };
+    Some(Edit {
+        start: found.span.start,
+        end: found.span.end,
+        replacement: format!("{} % {args}", context.source.slice(format.range())),
+        safe: true,
+    })
+}
+
+/// `format_single_parameter`.
+fn format_single_parameter(context: &RuleContext<'_>, node: Node<'_>) -> String {
+    // `format(fmt, *args)` prints what `fmt % args` does, so the splat comes off.
+    if node.kind_str() == "splat_argument" {
+        return match super::nodes::children_in(node, context).first() {
+            Some(inner) => format_single_parameter(context, *inner),
+            None => context.source.node_text(node).to_owned(),
+        };
+    }
+    let source = context.source.node_text(node);
+    if node.kind_str() == "hash" {
+        return format!("{{ {source} }}");
+    }
+    match requires_parentheses(context, node) {
+        true => format!("({source})"),
+        false => source.to_owned(),
+    }
+}
+
+/// `requires_parentheses?`: anything binding looser than `%` keeps its meaning only in brackets.
+fn requires_parentheses(context: &RuleContext<'_>, node: Node<'_>) -> bool {
+    match node.kind_str() {
+        "assignment" | "operator_assignment" | "if" | "unless" | "conditional" | "range" => true,
+        // `and` / `or` are `binary` here; so are the operator calls, which need brackets only when
+        // written without them -- and an operator call never is.
+        "binary" => node.field("operator").is_some_and(|operator| {
+            let text = context.source.node_text(operator);
+            matches!(text, "&&" | "||" | "and" | "or") || super::nodes::is_operator_method(text)
+        }),
+        _ => false,
+    }
+}
+
 /// `children.map(&:source).join(', ')` for the array or hash the grammar left as text.
 fn elements_of(source: &str) -> String {
     let inner = source
@@ -278,11 +344,9 @@ fn is_variable_argument(
                     .is_some_and(|operand| NUMBER_KINDS.contains(&operand.kind_str()));
             !signed_number && matches!(operator, "-" | "+" | "!" | "~" | "not")
         }
-        "binary" => node
-            .field("operator")
-            .is_some_and(|operator| {
-                super::nodes::is_operator_method(context.source.node_text(operator))
-            }),
+        "binary" => node.field("operator").is_some_and(|operator| {
+            super::nodes::is_operator_method(context.source.node_text(operator))
+        }),
         _ => false,
     }
 }