sonicop 26.8.111 → 26.8.113

data/src/rules/style/string_literals.rs

@@ -84,7 +84,7 @@ fn skipped(node: Node<'_>, context: &RuleContext<'_>) -> bool {
     if is_dstr(source) {
         return true;
     }
-    inside_interpolation(node) || quoted_label_key(node, context)
+    inside_interpolation(node, context) || quoted_label_key(node, context)
 }
 
 /// RuboCop's `on_dstr`, which only reports under `ConsistentQuotesInMultiline`: a literal the
@@ -286,10 +286,10 @@ pub(super) fn has_interpolation(node: Node<'_>) -> bool {
 /// RuboCop's `StringHelp#inside_interpolation?`: from the innermost interpolation outwards, is the
 /// literal owned by a `dstr`, `dsym` or `regexp`? The walk continues past the first interpolation
 /// because a command literal nested in a string -- `"#{`cmd #{'x'}`}"` -- is still inside one.
-pub(super) fn inside_interpolation(node: Node<'_>) -> bool {
+pub(super) fn inside_interpolation(node: Node<'_>, context: &RuleContext<'_>) -> bool {
     let mut current = node;
     let mut interpolated = false;
-    while let Some(parent) = current.parent() {
+    while let Some(parent) = context.parent(current) {
         if parent.kind_str() == "interpolation" {
             interpolated = true;
         } else if interpolated && INTERPOLATION_OWNERS.contains(&parent.kind_str()) {

data/src/rules/style/string_literals_in_interpolation.rs

@@ -7,6 +7,9 @@ use super::string_literals::{
 };
 
 pub(super) fn check(context: &RuleContext<'_>, offenses: &mut Vec<Offense>) {
+    if context.nodes_of("interpolation").next().is_none() {
+        return;
+    }
     let style: String = context
         .setting("EnforcedStyle")
         .unwrap_or_else(|| "single_quotes".to_owned());
@@ -26,7 +29,7 @@ pub(super) fn check(context: &RuleContext<'_>, offenses: &mut Vec<Offense>) {
             || has_interpolation(node)
             || is_dstr(source)
             || quoted_label_key(node, context)
-            || !inside_interpolation(node)
+            || !inside_interpolation(node, context)
             || !wrong_quotes(source, single_quotes)
         {
             continue;

data/src/rules/style/struct_inheritance.rs

@@ -13,7 +13,7 @@ pub(super) fn check(context: &RuleContext<'_>, offenses: &mut Vec<Offense>) {
         let Some(superclass) = node.field("superclass") else {
             continue;
         };
-        let Some(parent) = super::nodes::children(superclass).into_iter().next() else {
+        let Some(parent) = super::nodes::children_in(superclass, context).into_iter().next() else {
             continue;
         };
         if !is_struct_constructor(context, parent) {
@@ -94,7 +94,7 @@ fn correct_parent(
     // `class_node.body.nil?`: a body holding nothing but comments is no body upstream.
     if class_node
         .field("body")
-        .is_none_or(|body| super::nodes::children(body).is_empty())
+        .is_none_or(|body| super::nodes::children_in(body, context).is_empty())
     {
         edits.push(empty_body_removal(context, class_node, parent));
         return;
@@ -150,7 +150,7 @@ fn unparenthesized_arguments(context: &RuleContext<'_>, parent: Node<'_>) -> Opt
     if arguments.child(0).is_some_and(|open| open.kind_str() == "(") {
         return None;
     }
-    let joined = super::nodes::children(arguments)
+    let joined = super::nodes::children_in(arguments, context)
         .into_iter()
         .map(|argument| context.source.node_text(argument))
         .collect::<Vec<_>>()

data/src/rules/style/super_arguments.rs

@@ -78,7 +78,7 @@ fn definition_parameters(definition: Node<'_>, context: &RuleContext<'_>) -> Vec
         return Vec::new();
     };
     let mut found = Vec::new();
-    for child in super::nodes::children(list) {
+    for child in super::nodes::children_in(list, context) {
         match unfolded_defaults(child) {
             Some(names) => found.extend(names.into_iter().map(|name| Parameter {
                 kind: "optional_parameter".to_owned(),
@@ -205,13 +205,21 @@ fn same_argument(
             if argument.kind_str() != "pair" {
                 return false;
             }
-            let (Some(key), Some(value)) = (argument.field("key"), argument.field("value")) else {
+            let Some(key) = argument.field("key") else {
                 return false;
             };
-            // `sym_node.source == lvar_node.source`: only the `name:` shorthand spelling.
-            context.source.node_text(key) == context.source.node_text(value)
-                && symbol_name(key, context) == parameter.name.as_deref()
-                && value.kind_str() == "identifier"
+            match argument.field("value") {
+                // `sym_node.source == lvar_node.source`: only the `name:` shorthand spelling.
+                Some(value) => {
+                    context.source.node_text(key) == context.source.node_text(value)
+                        && symbol_name(key, context) == parameter.name.as_deref()
+                        && value.kind_str() == "identifier"
+                }
+                // **`a:` with no value is the same pair spelled shorter.** The parser fills the
+                // omitted value in with the variable of that name, so `super(a:)` passes `a` --
+                // the grammar leaves the field empty instead.
+                None => symbol_name(key, context) == parameter.name.as_deref(),
+            }
         }
         // `keyword_rest_arg_same?`.
         "hash_splat_parameter" => match &parameter.name {
@@ -272,7 +280,7 @@ fn block_reassigned(context: &RuleContext<'_>, definition: Node<'_>, name: &str)
         {
             return true;
         }
-        crate::rules::push_named_children(node, &mut stack);
+        crate::rules::push_named_children_in(node, context, &mut stack);
     }
     false
 }

data/src/rules/style/super_with_args_parentheses.rs

@@ -8,22 +8,59 @@ const MSG: &str = "Use parentheses for `super` with arguments.";
 /// upstream and never reaches this cop, which is why only the calls that carry an argument list
 /// are walked here.
 pub(super) fn check(context: &RuleContext<'_>, offenses: &mut Vec<Offense>) {
-    for node in context.nodes_of("call") {
-        let Some(keyword) = node.field("method") else {
-            continue;
+    // **`super \\\n  +bar` is a `super` with one argument upstream.** The parser reads the sign as
+    // belonging to the operand; the grammar reads the whole line as a binary expression whose left
+    // operand is the keyword, so the call never appears and the offense went unreported.
+    for node in context.nodes_of_any(&["call", "binary"]) {
+        let (keyword, arguments) = match node.kind_str() {
+            "binary" => {
+                let (Some(left), Some(right), Some(operator)) =
+                    (node.field("left"), node.field("right"), node.field("operator"))
+                else {
+                    continue;
+                };
+                if left.kind_str() != "super" {
+                    continue;
+                }
+                // Only a sign the parser folds into the operand makes the line an argument:
+                // `super == bar` is a comparison, and `super + 1` an addition, wherever the
+                // spacing puts them. The sign has to hug its operand and stand apart from the
+                // keyword, which is the spelling `super \` + `-1` has after the continuation.
+                let text = context.source.node_text(operator);
+                let source = context.source.text();
+                let hugs = !source[operator.end_byte()..].starts_with([' ', '\t']);
+                if !matches!(text, "+" | "-") || !hugs {
+                    continue;
+                }
+                (left, right)
+            }
+            _ => {
+                let Some(keyword) = node.field("method") else {
+                    continue;
+                };
+                if keyword.kind_str() != "super" {
+                    continue;
+                }
+                let Some(arguments) = node.field("arguments") else {
+                    continue;
+                };
+                (keyword, arguments)
+            }
         };
-        if keyword.kind_str() != "super" {
+        // `node.parenthesized?`: the parser reads a `(` written apart from the keyword as the
+        // argument's own grouping rather than as the call's parentheses, so `super (x)` has no
+        // `loc.begin` and is an offense. The grammar puts that `(` inside the argument list either
+        // way, which leaves the space between the two as what tells them apart.
+        if arguments.start_byte() == keyword.end_byte()
+            && context.source.node_text(arguments).starts_with('(')
+        {
             continue;
         }
-        let Some(arguments) = node.field("arguments") else {
-            continue;
+        // A binary's right operand is the single argument; a list holds them all.
+        let written = match node.kind_str() {
+            "binary" => vec![arguments],
+            _ => super::nodes::children_in(arguments, context),
         };
-        // `node.parenthesized?`: the argument list starts at the paren when there is one, so its
-        // first byte is what decides.
-        if context.source.node_text(arguments).starts_with('(') {
-            continue;
-        }
-        let written = super::nodes::children(arguments);
         let (Some(first), Some(last)) = (written.first(), written.last()) else {
             continue;
         };

data/src/rules/style/swap_values.rs

@@ -26,7 +26,7 @@ pub(super) fn check(context: &RuleContext<'_>, offenses: &mut Vec<Offense>) {
         let Some(parent) = node.parent() else {
             continue;
         };
-        let statements: Vec<Node<'_>> = super::nodes::children(parent)
+        let statements: Vec<Node<'_>> = super::nodes::children_in(parent, context)
             .into_iter()
             .filter(|child| child.kind_str() != "comment")
             .collect();

data/src/rules/style/symbol_array.rs

@@ -1,6 +1,7 @@
 use tree_sitter::Node;
 
 use crate::diagnostic::{Edit, Offense};
+use crate::ruby_version::RubyVersion;
 use crate::rules::RuleContext;
 
 use super::literal::{node_value, to_string_literal, to_symbol_literal, trim_interpolation_escape};
@@ -17,13 +18,19 @@ const ARRAY_MSG: &str = "Use %<prefer>s for an array of symbols.";
 /// The characters `complex_content?` refuses to leave inside a percent literal.
 const DELIMITERS: [char; 4] = ['[', ']', '(', ')'];
 
+/// `minimum_target_ruby_version 2.0`: `%i[…]` arrived in 2.0.
+const MINIMUM: RubyVersion = RubyVersion::new(2, 0);
+
 pub(super) fn check(context: &RuleContext<'_>, offenses: &mut Vec<Offense>) {
+    if context.target_ruby_version() < MINIMUM {
+        return;
+    }
     let style: String = context
         .setting("EnforcedStyle")
         .unwrap_or_else(|| "percent".to_owned());
 
     for node in context.nodes_of("array") {
-        let items = nodes::children(node);
+        let items = nodes::children_in(node, context);
         if items.is_empty() || !items.iter().all(|item| is_symbol(context, *item)) {
             continue;
         }
@@ -82,7 +89,7 @@ pub(super) fn check(context: &RuleContext<'_>, offenses: &mut Vec<Offense>) {
 fn is_symbol(context: &RuleContext<'_>, node: Node<'_>) -> bool {
     matches!(node.kind_str(), "simple_symbol" | "delimited_symbol")
         && !interpolated(node)
-        && !context.source.node_text(node).contains('\n')
+        && !crate::rules::support::quoted_spans_lines(context.source.node_text(node))
 }
 
 fn interpolated(node: Node<'_>) -> bool {

data/src/rules/style/symbol_proc.rs

@@ -144,7 +144,7 @@ fn block_parameter(
     let Some(parameters) = parameters else {
         return implicit_parameter(context, locals, block);
     };
-    let written = super::nodes::children(parameters);
+    let written = super::nodes::children_in(parameters, context);
     let [only] = written.as_slice() else {
         return None;
     };
@@ -183,7 +183,7 @@ fn scan_implicit(
     uses_it: &mut bool,
     locals: &LocalVariables<'_, '_>,
 ) {
-    for child in super::nodes::children(node) {
+    for child in super::nodes::children_in(node, context) {
         // A nested block's implicit parameters are its own.
         if matches!(child.kind_str(), "block" | "do_block" | "lambda") {
             continue;
@@ -207,7 +207,7 @@ fn scan_implicit(
 /// passed to it.
 fn single_call(context: &RuleContext<'_>, block: Node<'_>, parameter: &str) -> Option<String> {
     let body = block.field("body")?;
-    let statements = super::nodes::children(body);
+    let statements = super::nodes::children_in(body, context);
     let [only] = statements.as_slice() else {
         return None;
     };

data/src/rules/style/tally_method.rs

@@ -124,14 +124,14 @@ fn counts_into_hash(context: &RuleContext<'_>, block: Node<'_>) -> bool {
         && left
             .field("object")
             .is_some_and(|object| names(object, &hash, context))
-        && matches!(super::nodes::children(left).as_slice(),
+        && matches!(super::nodes::children_in(left, context).as_slice(),
             [_, index] if names(*index, &element, context))
 }
 
 /// The element and hash names a block takes, whether declared or numbered.
 fn two_parameters(context: &RuleContext<'_>, block: Node<'_>) -> Option<(String, String)> {
     match block.field("parameters") {
-        Some(parameters) => match super::nodes::children(parameters).as_slice() {
+        Some(parameters) => match super::nodes::children_in(parameters, context).as_slice() {
             [element, hash]
                 if element.kind_str() == "identifier" && hash.kind_str() == "identifier" =>
             {
@@ -223,7 +223,7 @@ fn counts_block_value(context: &RuleContext<'_>, block: Node<'_>) -> bool {
 /// The one name a block reads its value by, declared or implicit.
 fn single_parameter(context: &RuleContext<'_>, block: Node<'_>) -> Option<String> {
     match block.field("parameters") {
-        Some(parameters) => match super::nodes::children(parameters).as_slice() {
+        Some(parameters) => match super::nodes::children_in(parameters, context).as_slice() {
             [only] if only.kind_str() == "identifier" => {
                 Some(context.source.node_text(*only).to_owned())
             }
@@ -244,7 +244,7 @@ fn implicit_name(context: &RuleContext<'_>, block: Node<'_>) -> String {
         if node.kind_str() == "identifier" && context.source.node_text(node) == "it" {
             return "it".to_owned();
         }
-        crate::rules::push_named_children(node, &mut stack);
+        crate::rules::push_named_children_in(node, context, &mut stack);
     }
     "_1".to_owned()
 }

data/src/rules/style/ternary_parentheses.rs

@@ -19,6 +19,14 @@ pub(super) fn check(context: &RuleContext<'_>, offenses: &mut Vec<Offense>) {
         let Some(condition) = node.field("condition") else {
             continue;
         };
+        // `not x ? a : b` is `not(x ? a : b)` upstream whatever the parentheses around `x`: the
+        // keyword binds looser than `?:`. The grammar agrees only while `x` is bare -- once it is
+        // parenthesized it hoists the conditional above the `not`, which would make the cop wrap
+        // `not (x)` and grow another pair of parentheses on every pass.
+        let condition = match keyword_not(condition, context) {
+            Some(operand) => operand,
+            None => condition,
+        };
         if only_closing_parenthesis_is_last_line(context, condition)
             || condition_as_parenthesized_one_line_pattern_matching(condition)
         {
@@ -68,6 +76,16 @@ pub(super) fn check(context: &RuleContext<'_>, offenses: &mut Vec<Offense>) {
     }
 }
 
+/// The operand of a `not` written as the condition, which upstream reads as standing outside the
+/// conditional entirely. `!` is not one of these -- it binds tighter than `?:` and stays inside.
+fn keyword_not<'tree>(node: Node<'tree>, context: &RuleContext<'_>) -> Option<Node<'tree>> {
+    if node.kind_str() != "unary" {
+        return None;
+    }
+    let operator = node.child(0)?;
+    (context.source.node_text(operator) == "not").then(|| node.field("operand"))?
+}
+
 /// `only_closing_parenthesis_is_last_line?`: a condition whose last line is nothing but `)` is
 /// spread over lines on purpose, and pulling the parentheses off it would run the lines together.
 fn only_closing_parenthesis_is_last_line(context: &RuleContext<'_>, condition: Node<'_>) -> bool {
@@ -105,17 +123,18 @@ fn parenthesized_modifier_condition(condition: 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;
     };
-    only.kind_str() == "assignment" && !super::nodes::is_match_assignment(*only, context.source.text())
+    only.kind_str() == "assignment"
+        && !super::nodes::is_match_assignment(*only, context.source.text())
 }
 
 /// `complex_condition?`: a parenthesized condition is complex when anything written inside it is.
 fn complex_condition(context: &RuleContext<'_>, condition: Node<'_>) -> bool {
     if condition.kind_str() == "parenthesized_statements" {
-        return super::nodes::children(condition)
+        return super::nodes::children_in(condition, context)
             .into_iter()
             .any(|child| complex_condition(context, child));
     }
@@ -137,11 +156,9 @@ fn non_complex_expression(context: &RuleContext<'_>, node: Node<'_>) -> bool {
             .is_some_and(|operator| context.source.node_text(operator) == "defined?"),
         // A call carrying a block is a `block` node upstream rather than a `send`, and no `block`
         // is ever simple.
-        "call" if node.field("block").is_none() => {
-            node.field("method").is_some_and(|method| {
-                !super::nodes::is_operator_method(context.source.node_text(method))
-            })
-        }
+        "call" if node.field("block").is_none() => node.field("method").is_some_and(|method| {
+            !super::nodes::is_operator_method(context.source.node_text(method))
+        }),
         // `a.b = 1` is a `send` named `b=`, which is no operator; `a[0] = 1` is `:[]=`, which is.
         "assignment" => node
             .field("left")
@@ -153,14 +170,12 @@ fn non_complex_expression(context: &RuleContext<'_>, node: Node<'_>) -> bool {
 /// `unsafe_autocorrect?`: `and`, `or` and `not` all bind looser than the ternary, so the
 /// parentheses are what make the condition one.
 fn unsafe_autocorrect(context: &RuleContext<'_>, condition: Node<'_>) -> bool {
-    super::nodes::children(condition)
+    super::nodes::children_in(condition, context)
         .into_iter()
         .any(|child| match child.kind_str() {
-            "binary" | "unary" => child
-                .field("operator")
-                .is_some_and(|operator| {
-                    matches!(context.source.node_text(operator), "and" | "or" | "not")
-                }),
+            "binary" | "unary" => child.field("operator").is_some_and(|operator| {
+                matches!(context.source.node_text(operator), "and" | "or" | "not")
+            }),
             _ => false,
         })
 }
@@ -218,7 +233,7 @@ fn correct_parenthesized(context: &RuleContext<'_>, condition: Node<'_>) -> Vec<
             safe: true,
         });
     }
-    if let Some(call) = super::nodes::children(condition).last().copied() {
+    if let Some(call) = super::nodes::children_in(condition, context).last().copied() {
         edits.extend(parenthesize_condition_arguments(context, call));
     }
     edits

data/src/rules/style/top_level_method_definition.rs

@@ -12,10 +12,15 @@ const MSG: &str = "Do not define methods at the top-level.";
 /// statement list, which is the same as having `program` for a parent here.
 pub(super) fn check(context: &RuleContext<'_>, offenses: &mut Vec<Offense>) {
     for node in context.nodes_of_any(&["method", "singleton_method", "call"]) {
-        if !node
-            .parent()
-            .is_some_and(|parent| parent.kind_str() == "program")
-        {
+        // `node.parent&.begin_type? ? node.parent.root? : node.root?`: a definition wrapped in
+        // parentheses is a `begin` at the top level upstream, and counts as written there.
+        if !node.parent().is_some_and(|parent| match parent.kind_str() {
+            "program" => true,
+            "parenthesized_statements" => parent
+                .parent()
+                .is_some_and(|outer| outer.kind_str() == "program"),
+            _ => false,
+        }) {
             continue;
         }
         if node.kind_str() == "call" && !defines_a_method(node, context) {
@@ -40,5 +45,5 @@ fn defines_a_method(node: Node<'_>, context: &RuleContext<'_>) -> bool {
         return true;
     }
     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)
 }

data/src/rules/style/trailing_body.rs

@@ -18,7 +18,7 @@ pub(super) fn check(
     let Some(body) = node.field("body") else {
         return;
     };
-    let statements = super::nodes::children(body);
+    let statements = super::nodes::children_in(body, context);
     let (Some(first), Some(last)) = (statements.first(), statements.last()) else {
         return;
     };