sonicop 26.8.111 → 26.8.113

data/src/rules/style/negated_if.rs

@@ -58,14 +58,14 @@ pub(super) fn check(context: &RuleContext<'_>, offenses: &mut Vec<Offense>) {
 /// `single_negative?`: the condition, once its parentheses are peeled off, is one `!` applied to
 /// something that is not itself a negation. `not x` is the same `send` upstream, so it counts too.
 fn single_negative<'tree>(
-    context: &RuleContext<'_>,
+    context: &'tree RuleContext<'_>,
     condition: Node<'tree>,
 ) -> Option<send_node::Negation<'tree>> {
     let mut current = condition;
     // `condition = condition.children.last while condition.begin_type?`, with `(begin)` -- an
     // empty condition -- excluded before the loop even starts.
     while current.kind_str() == "parenthesized_statements" {
-        current = *super::nodes::children(current).last()?;
+        current = *super::nodes::children_in(current, context).last()?;
     }
     let found = send_node::negation(current, context)?;
     // `!(send _ :!)`: `!!x` negates a negation and is left alone. **The inner one may be written

data/src/rules/style/negated_if_else_condition.rs

@@ -29,7 +29,7 @@ pub(super) fn check(context: &RuleContext<'_>, offenses: &mut Vec<Offense>) {
         // `else_branch &&`: an `else` that holds nothing is no branch at all upstream, where an
         // empty body is `nil` rather than a node. The grammar still writes the `else` keyword as a
         // node, so asking whether the field is present answers a different question.
-        if alternative.kind_str() == "else" && super::nodes::children(alternative).is_empty() {
+        if alternative.kind_str() == "else" && super::nodes::children_in(alternative, context).is_empty() {
             continue;
         }
         let Some(condition) = node.field("condition").map(unwrap_parentheses) else {
@@ -118,7 +118,7 @@ fn swap_branches(
     // line goes away instead.
     if node
         .field("consequence")
-        .is_none_or(|branch| super::nodes::children(branch).is_empty())
+        .is_none_or(|branch| super::nodes::children_in(branch, context).is_empty())
     {
         let keyword = alternative.start_byte()..alternative.start_byte() + ELSE_LENGTH;
         return vec![replace(support::whole_lines(keyword, context), String::new())];
@@ -140,9 +140,11 @@ fn swap_branches(
 /// `unwrap_begin_nodes`.
 fn unwrap_parentheses<'tree>(node: Node<'tree>) -> Node<'tree> {
     let mut current = node;
+    // `unwrap_begin_nodes` peels a `begin` as well as a `kwbegin`, which the grammar writes as
+    // `begin … end`. Leaving that one on hid `begin / x !~ y / end ? a : b` from the cop.
     while matches!(
         current.kind_str(),
-        "parenthesized_statements" | "begin_block"
+        "parenthesized_statements" | "begin_block" | "begin"
     ) {
         match super::nodes::children(current).as_slice() {
             [only] => current = *only,

data/src/rules/style/negated_while.rs

@@ -52,7 +52,7 @@ pub(super) fn single_negative<'tree>(
 ) -> Option<send_node::Negation<'tree>> {
     // `empty_condition?` is `(begin)`: `while ()` has nothing to negate.
     if condition.kind_str() == "parenthesized_statements"
-        && super::nodes::children(condition).is_empty()
+        && super::nodes::children_in(condition, context).is_empty()
     {
         return None;
     }

data/src/rules/style/negative_array_index.rs

@@ -136,10 +136,21 @@ fn range_offense(
 /// The receiver and the single index of a subscript, in both spellings of `[]`.
 fn subscript<'tree>(
     node: Node<'tree>,
-    context: &RuleContext<'_>,
+    context: &'tree RuleContext<'_>,
 ) -> Option<(Node<'tree>, Node<'tree>)> {
     match node.kind_str() {
         "element_reference" => {
+            // `RESTRICT_ON_SEND = %i[[]]`: `arr[i] = value` dispatches `[]=`, which this cop never
+            // sees. The grammar writes the assignment around the same `element_reference`, so the
+            // read and the write look alike until the parent is checked.
+            if node.parent_of(context).is_some_and(|parent| {
+                matches!(parent.kind_str(), "assignment" | "operator_assignment")
+                    && parent
+                        .field("left")
+                        .is_some_and(|left| left.id() == node.id())
+            }) {
+                return None;
+            }
             let object = node.field("object")?;
             let children = super::nodes::children(node);
             Some((object, *children.get(1)?))
@@ -150,7 +161,7 @@ fn subscript<'tree>(
                 return None;
             }
             let receiver = node.field("receiver")?;
-            let arguments = super::nodes::children(node.field("arguments")?);
+            let arguments = super::nodes::children_in(node.field("arguments")?, context);
             Some((receiver, *arguments.first()?))
         }
     }
@@ -179,7 +190,13 @@ fn length_subtraction<'tree>(
     }
     let left = node.field("left")?;
     match left.kind_str() {
-        "identifier" if LENGTH_METHODS.contains(&context.source.node_text(left)) => {
+        // `(send $_ {:length :size :count})` matches a call, and a local variable named `length`
+        // is an `lvar` -- `length = do_something; self[length - 1]` subtracts from a number nobody
+        // asked the receiver for, so there is no `[-1]` to rewrite it to.
+        "identifier"
+            if LENGTH_METHODS.contains(&context.source.node_text(left))
+                && !context.variable_analysis().is_variable_reference(left) =>
+        {
             Some((None, count))
         }
         "call" => {
@@ -187,6 +204,11 @@ fn length_subtraction<'tree>(
             if !LENGTH_METHODS.contains(&context.source.node_text(selector)) {
                 return None;
             }
+            // `(send $_ {:length :size :count})` names no arguments, so it matches only the call
+            // that asks for the length: `arr.size(1)` counts something else entirely.
+            if left.field("arguments").is_some() || left.field("block").is_some() {
+                return None;
+            }
             Some((left.field("receiver"), count))
         }
         _ => None,

data/src/rules/style/nested_modifier.rs

@@ -117,7 +117,7 @@ fn parenthesize_arguments(context: &RuleContext<'_>, node: Node<'_>) -> Option<S
     if selector.kind_str() == "operator" {
         return None;
     }
-    let arguments = super::nodes::children(node.field("arguments")?);
+    let arguments = super::nodes::children_in(node.field("arguments")?, context);
     if arguments.is_empty() {
         return None;
     }

data/src/rules/style/nested_parenthesized_calls.rs

@@ -44,7 +44,7 @@ pub(super) fn check(context: &RuleContext<'_>, offenses: &mut Vec<Offense>) {
         {
             continue;
         }
-        let outer_arguments = super::nodes::children(arguments);
+        let outer_arguments = super::nodes::children_in(arguments, context);
         // `each_child_node(:call)` walks the receiver too, since it is a child of the send.
         let children = node
             .field("receiver")
@@ -57,7 +57,7 @@ pub(super) fn check(context: &RuleContext<'_>, offenses: &mut Vec<Offense>) {
             let Some(nested_arguments) = nested.field("arguments") else {
                 continue;
             };
-            let inner = super::nodes::children(nested_arguments);
+            let inner = super::nodes::children_in(nested_arguments, context);
             if inner.is_empty()
                 || nested_arguments
                     .child(0)

data/src/rules/style/nested_ternary_operator.rs

@@ -15,9 +15,9 @@ pub(super) fn check(context: &RuleContext<'_>, offenses: &mut Vec<Offense>) {
     let mut reported: HashSet<(usize, usize)> = HashSet::new();
 
     for node in context.nodes_of("conditional") {
-        let nested: Vec<Node<'_>> = super::nodes::children(node)
+        let nested: Vec<Node<'_>> = super::nodes::children_in(node, context)
             .into_iter()
-            .flat_map(super::conditional::descendants)
+            .flat_map(|node| super::conditional::descendants(node, context))
             .filter(|descendant| descendant.kind_str() == "conditional")
             .collect();
         for descendant in nested {

data/src/rules/style/next.rs

@@ -128,9 +128,13 @@ impl Cop<'_, '_> {
         let Some(condition) = last.field("condition") else {
             return;
         };
+        // The reported range stops at the condition, but the correction reaches the `then` beyond
+        // it and the `end` that closes the branch. Anchoring on the whole conditional is what keeps
+        // those edits inside the offense they belong to.
         let offense = self
             .context
-            .offense(MSG, last.start_byte()..condition.end_byte());
+            .offense(MSG, last.start_byte()..condition.end_byte())
+            .corrections_anchored_at(last.byte_range());
         offenses.push(offense.corrected_by_all(self.autocorrect(last, condition, reindented)));
     }
 
@@ -164,16 +168,12 @@ impl Cop<'_, '_> {
             .field("consequence")
             .map(body_of)
             .or_else(|| node.field("body").map(Body::One));
-        [
-            node.field("condition"),
-            body.and_then(|body| body.single()),
-        ]
-        .into_iter()
-        .flatten()
-        .any(|child| {
-            matches!(child.kind_str(), "if" | "unless")
-                && child.field("alternative").is_some()
-        })
+        [node.field("condition"), body.and_then(|body| body.single())]
+            .into_iter()
+            .flatten()
+            .any(|child| {
+                matches!(child.kind_str(), "if" | "unless") && child.field("alternative").is_some()
+            })
     }
 
     fn min_body_length(&self, node: Node<'_>) -> bool {
@@ -306,7 +306,7 @@ impl Cop<'_, '_> {
 
     /// `heredoc_lines`: `(body.line...body.last_line)` of every heredoc the node opens.
     fn heredoc_lines(&self, node: Node<'_>) -> Vec<usize> {
-        let beginnings: Vec<usize> = descendants(node)
+        let beginnings: Vec<usize> = descendants(node, self.context)
             .into_iter()
             .filter(|inner| inner.kind_str() == "heredoc_beginning")
             .map(|inner| inner.start_byte())

data/src/rules/style/nil_lambda.rs

@@ -108,7 +108,7 @@ fn returns_nil(node: Node<'_>, context: &RuleContext<'_>) -> bool {
     match node.kind_str() {
         "nil" => true,
         "return" | "next" | "break" => {
-            let arguments = super::nodes::children(node);
+            let arguments = super::nodes::children_in(node, context);
             let [list] = arguments.as_slice() else {
                 return false;
             };
@@ -116,7 +116,7 @@ fn returns_nil(node: Node<'_>, context: &RuleContext<'_>) -> bool {
                 return false;
             }
             let _ = context;
-            matches!(super::nodes::children(*list).as_slice(), [only] if only.kind_str() == "nil")
+            matches!(super::nodes::children_in(*list, context).as_slice(), [only] if only.kind_str() == "nil")
         }
         _ => false,
     }

data/src/rules/style/nodes.rs

@@ -57,6 +57,10 @@ pub(super) fn is_operator_method(name: &str) -> bool {
 }
 
 /// The node's children as upstream's AST holds them.
+///
+/// The list comes from the file's index rather than from a tree cursor opened here: this is one of
+/// the most-called helpers in the registry, and the cursor walk was among the largest single costs
+/// a sampling profile found.
 pub(super) fn children<'tree>(node: Node<'tree>) -> Vec<Node<'tree>> {
     let mut cursor = node.walk();
     node.named_children(&mut cursor)
@@ -64,6 +68,23 @@ pub(super) fn children<'tree>(node: Node<'tree>) -> Vec<Node<'tree>> {
         .collect()
 }
 
+/// [`children`] answered from the file's index, for a caller that has the cop's context to hand.
+/// This is one of the most-called helpers in the registry, and the cursor walk `children` opens
+/// was among the largest single costs a sampling profile found.
+pub(super) fn children_in<'tree>(
+    node: Node<'tree>,
+    context: &'tree RuleContext<'_>,
+) -> Vec<Node<'tree>> {
+    match context.named_children(node) {
+        Some(found) => found
+            .iter()
+            .copied()
+            .filter(|child| is_child(*child))
+            .collect(),
+        None => children(node),
+    }
+}
+
 /// `ProcessedSource#contains_comment?`: whether a comment sits on any line the range spans. It
 /// reads *lines* rather than the range itself, so a trailing comment on the closing line counts.
 pub(super) fn contains_comment(range: &std::ops::Range<usize>, context: &RuleContext<'_>) -> bool {

data/src/rules/style/non_nil_check.rs

@@ -26,6 +26,17 @@ pub(super) fn check(context: &RuleContext<'_>, offenses: &mut Vec<Offense>) {
     }
 
     for node in context.nodes_of_any(&["binary", "call", "unary"]) {
+        if semantic_changes
+            && !is_predicate_method_result(context, node)
+            && let Some(edits) = semantic_change(context, node)
+        {
+            offenses.push(
+                context
+                    .offense(MSG_FOR_REDUNDANCY, node.byte_range())
+                    .corrected_by_all(edits),
+            );
+            continue;
+        }
         let Some(receiver) = comparison_with_nil(context, node) else {
             continue;
         };
@@ -56,6 +67,75 @@ pub(super) fn check(context: &RuleContext<'_>, offenses: &mut Vec<Offense>) {
     }
 }
 
+/// The two checks `IncludeSemanticChanges` adds: `not_and_nil_check?` (`!x.nil?`) and
+/// `unless_and_nil_check?` (`unless x.nil?`). Both drop the `nil?` call itself, which is the
+/// semantic change the option is named for -- `x` is falsy for `false` too.
+fn semantic_change(context: &RuleContext<'_>, node: Node<'_>) -> Option<Vec<Edit>> {
+    // `autocorrect_non_nil`: `!x.nil?` becomes `x`, and a receiverless `!nil?` becomes `self`.
+    // `not x.nil?` is the same `:!` send as `!x.nil?`. The grammar gives `!` an `operator` field
+    // and leaves `not` as an anonymous child, so both spellings have to be read.
+    let negation = node.kind_str() == "unary"
+        && node
+            .field("operator")
+            .or_else(|| node.child(0))
+            .is_some_and(|operator| matches!(context.source.node_text(operator), "!" | "not"));
+    if negation {
+        let operand = node.field("operand")?;
+        if !is_nil_predicate(context, operand) {
+            return None;
+        }
+        let replacement = match operand.field("receiver") {
+            Some(receiver) => context.source.node_text(receiver).to_owned(),
+            None => "self".to_owned(),
+        };
+        return Some(vec![Edit {
+            start: node.start_byte(),
+            end: node.end_byte(),
+            replacement,
+            safe: true,
+        }]);
+    }
+
+    // `autocorrect_unless_nil`: the keyword becomes `if` and the condition loses its `nil?`.
+    if !is_nil_predicate(context, node) {
+        return None;
+    }
+    let parent = node.parent_of(context)?;
+    if !matches!(parent.kind_str(), "unless" | "unless_modifier") {
+        return None;
+    }
+    if parent.field("condition")?.id() != node.id() {
+        return None;
+    }
+    let keyword = (0..parent.child_count())
+        .filter_map(|index| parent.child(index as u32))
+        .find(|child| context.source.node_text(*child) == "unless")?;
+    let receiver = node.field("receiver")?;
+    Some(vec![
+        Edit {
+            start: keyword.start_byte(),
+            end: keyword.end_byte(),
+            replacement: "if".to_owned(),
+            safe: true,
+        },
+        Edit {
+            start: node.start_byte(),
+            end: node.end_byte(),
+            replacement: context.source.node_text(receiver).to_owned(),
+            safe: true,
+        },
+    ])
+}
+
+/// `nil_check?`: `(send _ :nil?)` with no arguments.
+fn is_nil_predicate(context: &RuleContext<'_>, node: Node<'_>) -> bool {
+    node.kind_str() == "call"
+        && node
+            .field("method")
+            .is_some_and(|method| context.source.node_text(method) == "nil?")
+        && node.field("arguments").is_none()
+}
+
 /// `not_equal_to_nil?`: `(send _ :!= nil)`. The two checks `IncludeSemanticChanges` adds are
 /// `!x.nil?` and `unless x.nil?`, which the default configuration leaves alone.
 fn comparison_with_nil<'t>(context: &RuleContext<'_>, node: Node<'t>) -> Option<Node<'t>> {
@@ -66,7 +146,7 @@ fn comparison_with_nil<'t>(context: &RuleContext<'_>, node: Node<'t>) -> Option<
             node.field("right")?,
         ),
         "call" => {
-            let arguments = super::nodes::children(node.field("arguments")?);
+            let arguments = super::nodes::children_in(node.field("arguments")?, context);
             let [only] = arguments.as_slice() else {
                 return None;
             };
@@ -103,7 +183,7 @@ fn is_predicate_method_result(context: &RuleContext<'_>, node: Node<'_>) -> bool
         return false;
     }
     // The body is the statement itself when it stands alone, and its last statement otherwise.
-    super::nodes::children(parent)
+    super::nodes::children_in(parent, context)
         .last()
         .is_some_and(|last| last.id() == node.id())
 }

data/src/rules/style/numbered_parameters.rs

@@ -20,9 +20,12 @@ pub(super) fn check(context: &RuleContext<'_>, offenses: &mut Vec<Offense>) {
         .setting::<String>("EnforcedStyle")
         .is_some_and(|style| style == "disallow");
     let locals = LocalVariables::new(context);
-    for node in context.nodes_of("call") {
+    // **A lambda literal is a `block` upstream too.** `-> { _1 }` is a `numblock` whose send is
+    // the `lambda` call, while the grammar gives the arrow a node of its own that holds the block.
+    for node in context.nodes_of_any(&["call", "lambda"]) {
         let Some(block) = node
             .field("block")
+            .or_else(|| (node.kind_str() == "lambda").then(|| node.field("body")).flatten())
             .filter(|block| BLOCK_KINDS.contains(&block.kind_str()))
         else {
             continue;

data/src/rules/style/numbered_parameters_limit.rs

@@ -53,9 +53,9 @@ pub(super) fn check(context: &RuleContext<'_>, offenses: &mut Vec<Offense>) {
 /// `each_descendant(:lvar)` filtered by `/\A_[1-9]\z/`.
 fn numbered_parameters(node: Node<'_>, context: &RuleContext<'_>) -> HashSet<String> {
     let mut found = HashSet::new();
-    let mut stack: Vec<Node<'_>> = super::nodes::children(node);
+    let mut stack: Vec<Node<'_>> = super::nodes::children_in(node, 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() != "identifier" {
             continue;
         }

data/src/rules/style/numeric_literals.rs

@@ -14,6 +14,19 @@ const MSG: &str =
 pub(super) fn check(context: &RuleContext<'_>, offenses: &mut Vec<Offense>) {
     let min_digits: usize = context.setting("MinDigits").unwrap_or(5);
     let strict: bool = context.setting("Strict").unwrap_or(false);
+    // `allowed_numbers.include?(int)`: compared as **strings**, against the integer part alone.
+    let allowed: Vec<String> = context
+        .setting::<Vec<serde_yaml_ng::Value>>("AllowedNumbers")
+        .unwrap_or_default()
+        .iter()
+        .map(|value| match value {
+            serde_yaml_ng::Value::String(text) => text.clone(),
+            other => serde_yaml_ng::to_string(other)
+                .unwrap_or_default()
+                .trim()
+                .to_owned(),
+        })
+        .collect();
 
     for node in context.nodes_of_any(&["integer", "float"]) {
         // A rational or imaginary suffix makes a different literal upstream (`rational` / `complex`
@@ -30,7 +43,10 @@ pub(super) fn check(context: &RuleContext<'_>, offenses: &mut Vec<Offense>) {
         let integer = integer_part(source);
         // Anything starting with `0` is a non-decimal literal (`0x`, `0b`, `0o`, or a leading-zero
         // octal), which this cop does not know how to group.
-        if integer.starts_with('0') || integer.chars().count() < min_digits {
+        if integer.starts_with('0')
+            || allowed.iter().any(|entry| entry == integer)
+            || integer.chars().count() < min_digits
+        {
             continue;
         }
         if !offending(integer, strict) {

data/src/rules/style/numeric_predicate.rs

@@ -4,6 +4,11 @@ use tree_sitter::Node;
 use crate::diagnostic::{Edit, Offense};
 use crate::rules::RuleContext;
 use crate::rules::node_ext::NodeExt;
+use crate::rules::send_node;
+
+/// The version `positive?` and `negative?` were added in.
+const PREDICATES_SINCE: crate::ruby_version::RubyVersion =
+    crate::ruby_version::RubyVersion::new(2, 3);
 
 pub(super) fn check(context: &RuleContext<'_>, offenses: &mut Vec<Offense>) {
     let predicate_style = context
@@ -25,6 +30,11 @@ pub(super) fn check(context: &RuleContext<'_>, offenses: &mut Vec<Offense>) {
         {
             continue;
         }
+        // `replacement_supported?`: `positive?` and `negative?` arrived in 2.3, so a comparison is
+        // left alone below that -- `zero?` has always been there.
+        if matches!(operator, ">" | "<") && context.target_ruby_version() < PREDICATES_SINCE {
+            continue;
+        }
 
         let replacement = match predicate_style {
             true => format!(
@@ -86,7 +96,13 @@ fn predicate<'tree>(
     context: &RuleContext<'_>,
     node: Node<'tree>,
 ) -> Option<(Node<'tree>, &'static str)> {
-    if node.kind_str() != "call" || node.field("arguments").is_some() {
+    // Upstream dispatches `on_send` but does not alias it to `on_csend`: a predicate reached
+    // through `&.` is deliberately outside this cop even though the grammar calls both forms a
+    // `call`.
+    if node.kind_str() != "call"
+        || !send_node::is_plain_send(node, context)
+        || node.field("arguments").is_some()
+    {
         return None;
     }
     let receiver = node.field("receiver")?;
@@ -127,6 +143,11 @@ fn operands<'a, 'tree>(
             ))
         }
         _ => {
+            // `comparison` is a `(send …)` pattern, and `&.` is a `csend`: the grammar spells both
+            // a `call`, so the operator reached through a safe navigation has to be excluded here.
+            if !send_node::is_plain_send(node, context) {
+                return None;
+            }
             let method = node.field("method")?;
             let arguments = super::nodes::children(node.field("arguments")?);
             match arguments.as_slice() {
@@ -174,11 +195,9 @@ fn parenthesized_source(context: &RuleContext<'_>, node: Node<'_>) -> String {
 fn require_parentheses(context: &RuleContext<'_>, node: Node<'_>) -> bool {
     match node.kind_str() {
         // `&&` and `||` are not sends upstream, so they are not binary operations either.
-        "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))
+        }),
         // `a[b]` is a call to `:[]`, and its `loc.begin` is a bracket rather than a parenthesis.
         "element_reference" => true,
         "call" => {

data/src/rules/style/one_line_conditional.rs

@@ -34,6 +34,15 @@ pub(super) fn check(context: &RuleContext<'_>, offenses: &mut Vec<Offense>) {
         let Some(alternative) = node.field("alternative") else {
             continue;
         };
+        // `return unless node.else_branch`: upstream's `else_branch` is what the clause **holds**,
+        // so a bare `else end` answers `nil`. The grammar keeps the empty clause as a node, and
+        // taking its presence for a branch made `if cond then run else end` look convertible.
+        if !crate::rules::send_node::named_children_of(alternative, context)
+            .iter()
+            .any(|child| child.kind_str() != "comment")
+        {
+            continue;
+        }
         let consequence = node.field("consequence");
         // `node.if_branch&.begin_type?`: a then-branch upstream reads as a `begin` has no ternary
         // arm to become.
@@ -141,7 +150,7 @@ fn branch(context: &RuleContext<'_>, node: Option<Node<'_>>) -> String {
         return "nil".to_owned();
     };
     let (source, node) = match node.kind_str() {
-        "then" | "else" => match super::nodes::children(node).as_slice() {
+        "then" | "else" => match super::nodes::children_in(node, context).as_slice() {
             [only] => (context.source.node_text(*only).to_owned(), Some(*only)),
             [] => return "nil".to_owned(),
             [first, .., last] => (
@@ -191,11 +200,19 @@ fn requires_parentheses(context: &RuleContext<'_>, node: Node<'_>) -> bool {
     {
         return true;
     }
-    // `keyword_with_changed_precedence?`: `not x`, and a keyword written with arguments.
+    // `keyword_with_changed_precedence?`: `not x`, and a keyword written with arguments -- which
+    // includes `defined? :A`, a `defined?` node upstream and a `unary` here. Only `not` was read,
+    // so `defined? :A` lost the parentheses that keep the `?` of the ternary out of its argument.
     if node.kind_str() == "unary" {
-        return node
-            .field("operator")
-            .is_some_and(|operator| context.source.node_text(operator) == "not");
+        return node.field("operator").is_some_and(|operator| {
+            match context.source.node_text(operator) {
+                "not" => true,
+                "defined?" => node
+                    .field("operand")
+                    .is_some_and(|operand| !context.source.node_text(operand).starts_with('(')),
+                _ => false,
+            }
+        });
     }
     // `node.arguments? && !node.parenthesized_call?`: a keyword whose arguments are already in
     // parentheses takes nothing more from what follows, so it needs no parentheses of its own.
@@ -204,7 +221,7 @@ fn requires_parentheses(context: &RuleContext<'_>, node: Node<'_>) -> bool {
         && node
             .child(1)
             .is_some_and(|arguments| !context.source.node_text(arguments).starts_with('('))
-        && !super::nodes::children(node).is_empty()
+        && !super::nodes::children_in(node, context).is_empty()
 }
 
 /// `IfThenCorrector`: the same conditional written over several lines.
@@ -246,7 +263,7 @@ fn expanded(context: &RuleContext<'_>, node: Node<'_>, width: usize, column: usi
 
 /// The source of everything a `then` or `else` clause holds.
 fn clause_source(context: &RuleContext<'_>, clause: Node<'_>) -> String {
-    let written = super::nodes::children(clause);
+    let written = super::nodes::children_in(clause, context);
     match (written.first(), written.last()) {
         (Some(first), Some(last)) => context
             .source

data/src/rules/style/operator_method_call.rs

@@ -127,6 +127,11 @@ fn has_first_child(node: Node<'_>, locals: &LocalVariables<'_, '_>) -> bool {
         // A bare name is an `lvar` when it names a variable and a receiverless `send` otherwise.
         "identifier" => locals.is_lvar(node),
         "call" => node.field("receiver").is_some(),
+        // `(const nil :CONST)`: the namespace is the first child, and a plain constant has none.
+        // `::Foo` and `Foo::Bar` both carry one, which the grammar spells as a `scope_resolution`.
+        "constant" => false,
+        // An empty literal has no children either.
+        "array" | "hash" | "string_array" | "symbol_array" => node.named_child_count() > 0,
         "nil" | "true" | "false" | "self" | "super" => false,
         _ => true,
     }

data/src/rules/style/optional_arguments.rs

@@ -14,7 +14,7 @@ pub(super) fn check(context: &RuleContext<'_>, offenses: &mut Vec<Offense>) {
         let Some(parameters) = node.field("parameters") else {
             continue;
         };
-        let arguments = super::nodes::children(parameters);
+        let arguments = super::nodes::children_in(parameters, context);
         let optional: Vec<usize> = positions(&arguments, "optional_parameter");
         // `arg_type?`: only a plain argument counts. A destructuring `(a, b)` is an `mlhs`
         // upstream, and a keyword or splat argument is a type of its own.

data/src/rules/style/or_assignment.rs

@@ -72,7 +72,7 @@ pub(super) fn check(context: &RuleContext<'_>, offenses: &mut Vec<Offense>) {
         if empty_if
             && node
                 .field("consequence")
-                .is_some_and(|then| !super::nodes::children(then).is_empty())
+                .is_some_and(|then| !super::nodes::children_in(then, context).is_empty())
         {
             continue;
         }