sonicop 26.8.111 → 26.8.113

data/src/rules/style/format_string_token.rs

@@ -13,6 +13,11 @@ use crate::rules::node_ext::NodeExt;
 const FORMAT_METHODS: &[&str] = &["format", "sprintf", "printf"];
 
 pub(super) fn check(context: &RuleContext<'_>, offenses: &mut Vec<Offense>) {
+    // Every sequence this cop can report starts with `%`. Avoid collecting and splitting every
+    // string literal in files that cannot possibly contain one.
+    if !context.source.text().contains('%') {
+        return;
+    }
     let style = parse_style(
         context
             .setting::<String>("EnforcedStyle")
@@ -26,17 +31,29 @@ pub(super) fn check(context: &RuleContext<'_>, offenses: &mut Vec<Offense>) {
         .setting::<String>("Mode")
         .is_some_and(|mode| mode == "conservative");
     let allowed_methods: Vec<String> = context.setting("AllowedMethods").unwrap_or_default();
+    // `allowed_method?(name) || matches_allowed_pattern?(name)`: both are matched against the
+    // **enclosing call's method name**, not against the string.
+    let allowed_patterns =
+        crate::rules::naming::support::forbidden_patterns_named(context, "AllowedPatterns");
 
     for literal in literals(context) {
-        if surrounded_by_command_or_regexp(literal.anchor)
+        if surrounded_by_command_or_regexp(literal.anchor, context)
             || allowed_method(context, literal.anchor, &allowed_methods)
+            || allowed_call_pattern(context, literal.anchor, &allowed_patterns)
         {
             continue;
         }
         // `format_string_in_typical_context?` reads the node `on_str` was handed: for a literal the
         // parser split into parts that is the enclosing `dstr`, which is never a call's argument.
-        let single = literal.parts.len() == 1;
-        let typical = single && typical_context(context, literal.anchor);
+        // `format_string_context?` is `format_string_in_typical_context?(node) || any ancestor
+        // `dstr` in one`. The anchor **is** the node upstream asks about, whether the parser split
+        // it into parts or not -- requiring a single part made every interpolated format string
+        // uncorrectable, and `format("c#{b}%{template}")` was reported and then left alone.
+        let typical = typical_context(context, literal.anchor);
+        // Whether the parser cut the literal into parts, which is what puts a `dstr` between each
+        // part and the call.
+        let split = literal.parts.len() > 1
+            || crate::rules::send_node::has_interpolation(literal.anchor);
         let correctable = typical || enclosing_typical_context(context, literal.anchor);
 
         for part in &literal.parts {
@@ -50,8 +67,13 @@ pub(super) fn check(context: &RuleContext<'_>, offenses: &mut Vec<Offense>) {
                 .filter(|sequence| {
                     // `allowed_string?`: an unannotated token outside a format call is left alone,
                     // and `conservative` mode extends that to every token.
+                    //
+                    // **The node `on_str` is handed is the part, not the literal.** A `"#{x} %s"`
+                    // splits into a `dstr` of parts, and a part's parent is that `dstr` rather
+                    // than the call -- so `format_string_in_typical_context?` is false there and
+                    // every unannotated token in an interpolated format string is allowed.
                     let allowed = sequence.style == SequenceStyle::Unannotated || conservative;
-                    !(allowed && !typical)
+                    !(allowed && !(typical && !split))
                 })
                 .collect();
             if detected.is_empty() || allowed_unannotated(&detected, style, max_unannotated) {
@@ -84,7 +106,7 @@ fn literals<'a>(context: &'a RuleContext<'_>) -> Vec<Literal<'a>> {
         // `"%s" %[a]` is a `send` upstream: the second literal is the operator's argument, not a
         // string at all.
         if open.id() == close.id()
-            || (super::percent::is_modulo_operand(node)
+            || (super::percent::is_modulo_operand(node, context)
                 && context.source.node_text(node).starts_with('%'))
         {
             continue;
@@ -203,14 +225,17 @@ fn typical_context(context: &RuleContext<'_>, node: Node<'_>) -> bool {
     if parent.kind_str() != "argument_list" {
         return false;
     }
-    let Some(call) = parent.parent_of(context).filter(|call| call.kind_str() == "call") else {
+    let Some(call) = parent
+        .parent_of(context)
+        .filter(|call| call.kind_str() == "call")
+    else {
         return false;
     };
     let named = call
         .field("method")
         .is_some_and(|method| FORMAT_METHODS.contains(&context.source.node_text(method)));
     named
-        && super::nodes::children(parent)
+        && super::nodes::children_in(parent, context)
             .first()
             .is_some_and(|first| first.id() == node.id())
 }
@@ -220,8 +245,10 @@ fn typical_context(context: &RuleContext<'_>, node: Node<'_>) -> bool {
 fn enclosing_typical_context(context: &RuleContext<'_>, node: Node<'_>) -> bool {
     let mut current = node.parent_of(context);
     while let Some(parent) = current {
-        if matches!(parent.kind_str(), "chained_string" | "string" | "heredoc_body")
-            && typical_context(context, parent)
+        if matches!(
+            parent.kind_str(),
+            "chained_string" | "string" | "heredoc_body"
+        ) && typical_context(context, parent)
         {
             return true;
         }
@@ -232,13 +259,13 @@ fn enclosing_typical_context(context: &RuleContext<'_>, node: Node<'_>) -> bool
 
 /// `format_string_token?`: a literal written inside a command or a regexp is none of this cop's
 /// business.
-fn surrounded_by_command_or_regexp(node: Node<'_>) -> bool {
-    let mut current = node.parent();
+fn surrounded_by_command_or_regexp(node: Node<'_>, context: &RuleContext<'_>) -> bool {
+    let mut current = context.parent(node);
     while let Some(parent) = current {
         if matches!(parent.kind_str(), "subshell" | "regex") {
             return true;
         }
-        current = parent.parent();
+        current = context.parent(parent);
     }
     false
 }
@@ -355,3 +382,25 @@ fn describe(style: SequenceStyle) -> &'static str {
         _ => "unannotated tokens (like `%s`)",
     }
 }
+
+/// `matches_allowed_pattern?(send_parent.method_name)`.
+fn allowed_call_pattern(
+    context: &RuleContext<'_>,
+    anchor: Node<'_>,
+    patterns: &[&regex::Regex],
+) -> bool {
+    if patterns.is_empty() {
+        return false;
+    }
+    let mut current = anchor.parent_of(context);
+    while let Some(node) = current {
+        if node.kind_str() == "call"
+            && let Some(method) = node.field("method")
+        {
+            let name = context.source.node_text(method);
+            return patterns.iter().any(|pattern| pattern.is_match(name));
+        }
+        current = node.parent_of(context);
+    }
+    false
+}

data/src/rules/style/frozen_string_literal_comment.rs

@@ -2,6 +2,7 @@ use std::ops::Range;
 
 use crate::diagnostic::{Edit, Offense};
 use crate::magic_comment::MagicComment;
+use crate::ruby_version::RubyVersion;
 use crate::rules::RuleContext;
 
 const MSG_MISSING: &str = "Missing frozen string literal comment.";
@@ -9,8 +10,16 @@ const MSG_MISSING_TRUE: &str = "Missing magic comment `# frozen_string_literal:
 const MSG_UNNECESSARY: &str = "Unnecessary frozen string literal comment.";
 const MSG_DISABLED: &str = "Frozen string literal comment must be set to `true`.";
 
+/// `minimum_target_ruby_version 2.3`: the frozen string literal comment is only valid in Ruby 2.3+.
+const MINIMUM: RubyVersion = RubyVersion::new(2, 3);
+
 pub(super) fn check(context: &RuleContext<'_>, offenses: &mut Vec<Offense>) {
-    if context.source.text().trim().is_empty() {
+    if context.target_ruby_version() < MINIMUM {
+        return;
+    }
+    // `processed_source.tokens.empty?`: a file of nothing but a data section has no tokens at
+    // all, and the cop returns before it looks for a comment.
+    if crate::rules::support::code_before_data(context).trim().is_empty() {
         return;
     }
     let style: String = context
@@ -19,6 +28,15 @@ pub(super) fn check(context: &RuleContext<'_>, offenses: &mut Vec<Offense>) {
 
     match style.as_str() {
         "never" => {
+            // `ensure_no_comment` asks `frozen_string_literal_comment_exists?`, which reads only
+            // the **leading** comments -- a magic comment written after code does not reach Ruby,
+            // so there is nothing unnecessary to remove. The offense itself is then placed on the
+            // comment found anywhere, which is what `specified_comment` returns.
+            let leading = leading_comments(context)
+                .any(|(_, line)| MagicComment::parse(line).valid_literal_value());
+            if !leading {
+                return;
+            }
             if let Some(comment) = specified_comment(context) {
                 offenses.push(
                     context
@@ -44,7 +62,10 @@ pub(super) fn check(context: &RuleContext<'_>, offenses: &mut Vec<Offense>) {
                         .corrected_by(Edit {
                             start: comment.start,
                             end: comment.end,
-                            replacement: "# frozen_string_literal: true".to_owned(),
+                            // `MagicComment#new_frozen_string_literal(true)` keeps the comment's
+                            // own shape -- `# -*- frozen_string_literal: false -*-` becomes the
+                            // same line with `true`, not a plain one.
+                            replacement: enabled_form(context.source.slice(comment.clone())),
                             safe: false,
                         }),
                 );
@@ -151,9 +172,21 @@ fn line_content_end(context: &RuleContext<'_>, line_number: usize) -> usize {
 /// Removes the comment along with the line it sits on, so no blank line is left behind.
 fn remove_comment(context: &RuleContext<'_>, comment: Range<usize>) -> Edit {
     let line_number = context.source.line_column(comment.start).0;
+    let start = context.source.line_start(line_number);
+    // `range_with_surrounding_space(node.pos, side: :right)`: the blank lines the comment left
+    // behind go with it, so removing it does not open a gap at the head of the file.
+    let text = context.source.text();
+    let mut end = context.source.line_range(line_number).end;
+    while text[end..]
+        .chars()
+        .next()
+        .is_some_and(|character| character.is_whitespace())
+    {
+        end += text[end..].chars().next().map_or(0, char::len_utf8);
+    }
     Edit {
-        start: context.source.line_start(line_number),
-        end: context.source.line_range(line_number).end,
+        start,
+        end,
         replacement: String::new(),
         safe: false,
     }
@@ -187,3 +220,28 @@ fn specified_comment(context: &RuleContext<'_>) -> Option<Range<usize>> {
         Some(start..start + trimmed.len())
     })
 }
+
+/// `MagicComment#new_frozen_string_literal(true)`: the value changes and nothing else does.
+fn enabled_form(comment: &str) -> String {
+    let mut out = String::with_capacity(comment.len());
+    let mut rest = comment;
+    while let Some(index) = rest.find("frozen_string_literal") {
+        let (before, after) = rest.split_at(index + "frozen_string_literal".len());
+        out.push_str(before);
+        let value_start = after
+            .find(|character: char| character != ':' && character != ' ' && character != '=')
+            .unwrap_or(after.len());
+        out.push_str(&after[..value_start]);
+        let tail = &after[value_start..];
+        let value_end = tail
+            .find(|character: char| !character.is_ascii_alphanumeric())
+            .unwrap_or(tail.len());
+        out.push_str("true");
+        rest = &tail[value_end..];
+    }
+    out.push_str(rest);
+    match out.is_empty() {
+        true => "# frozen_string_literal: true".to_owned(),
+        false => out,
+    }
+}

data/src/rules/style/guard_clause.rs

@@ -11,6 +11,7 @@ use super::conditional::{
 use crate::diagnostic::{Edit, Offense};
 use crate::rules::RuleContext;
 use crate::rules::node_ext::NodeExt;
+use crate::rules::send_node::named_children_of;
 
 const MSG: &str = "Use a guard clause (`%<example>s`) instead of wrapping the code inside a \
      conditional expression.";
@@ -331,7 +332,7 @@ impl Cop<'_, '_> {
     /// The span of one branch, which is the whole statement list when it holds more than one.
     fn branch_range(&self, node: Node<'_>, field: &str) -> Option<Range<usize>> {
         let clause = node.field(field)?;
-        let statements = super::nodes::children(clause);
+        let statements = super::nodes::children_in(clause, self.context);
         let first = statements.first()?;
         let last = statements.last()?;
         Some(first.start_byte()..last.end_byte())
@@ -421,7 +422,7 @@ impl Cop<'_, '_> {
     /// *descendant* of the condition holds, while `if x, y = foo` writes two.
     fn assigned_locals(&self, condition: Node<'_>) -> Vec<String> {
         let mut names = Vec::new();
-        for inner in descendants(condition) {
+        for inner in descendants(condition, self.context) {
             if !matches!(inner.kind_str(), "assignment" | "operator_assignment") {
                 continue;
             }
@@ -454,13 +455,13 @@ impl Cop<'_, '_> {
         let body = body_of(consequence);
         let roots: Vec<Node<'_>> = match &body {
             Body::Missing => return Vec::new(),
-            Body::One(node) => super::nodes::children(*node),
+            Body::One(node) => super::nodes::children_in(*node, self.context),
             Body::Begin(statements) => statements.clone(),
         };
         let mut names = Vec::new();
         let mut pending: Vec<Node<'_>> = roots;
         while let Some(root) = pending.pop() {
-            for inner in descendants(root) {
+            for inner in descendants(root, self.context) {
                 if inner.kind_str() == "heredoc_beginning"
                     && let Some(body) = self.heredoc_body(inner)
                 {
@@ -602,9 +603,9 @@ fn heredoc_end(context: &RuleContext<'_>, beginning: Node<'_>) -> Option<Range<u
         .nodes_of("heredoc_beginning")
         .position(|node| node.id() == beginning.id())?;
     let body = context.nodes_of("heredoc_body").nth(index)?;
-    let mut cursor = body.walk();
-    let terminator = body
-        .named_children(&mut cursor)
+    let _cursor = body.walk();
+    let terminator = named_children_of(body, context)
+        .into_iter()
         .find(|child| child.kind_str() == "heredoc_end")?;
     Some(terminator.byte_range())
 }

data/src/rules/style/hash_as_last_array_item.rs

@@ -142,8 +142,8 @@ fn trailing_comma(context: &RuleContext<'_>, end: usize) -> Option<usize> {
 }
 
 /// `array.values`: the elements, with the trailing key-value pairs folded into one hash.
-fn values<'tree>(context: &RuleContext<'_>, array: Node<'tree>) -> Vec<Value<'tree>> {
-    let children = super::nodes::children(array);
+fn values<'tree>(context: &'tree RuleContext<'_>, array: Node<'tree>) -> Vec<Value<'tree>> {
+    let children = super::nodes::children_in(array, context);
     let split = children.iter().position(|child| is_pair(*child));
     let (elements, pairs) = match split {
         Some(index) => children.split_at(index),
@@ -158,10 +158,10 @@ fn values<'tree>(context: &RuleContext<'_>, array: Node<'tree>) -> Vec<Value<'tr
             is_hash: element.kind_str() == "hash",
             braces: element.kind_str() == "hash",
             opens_with_splat: element.kind_str() == "hash"
-                && super::nodes::children(*element)
+                && super::nodes::children_in(*element, context)
                     .first()
                     .is_some_and(|first| first.kind_str() == "hash_splat_argument"),
-            empty: element.kind_str() == "hash" && super::nodes::children(*element).is_empty(),
+            empty: element.kind_str() == "hash" && super::nodes::children_in(*element, context).is_empty(),
         })
         .collect();
     let _ = context;

data/src/rules/style/hash_each_methods.rs

@@ -200,7 +200,7 @@ fn on_block_pass(context: &RuleContext<'_>, offenses: &mut Vec<Offense>, node: N
     if block_pass.kind_str() != "block_argument" {
         return;
     }
-    let symbol = send_node::named_children(block_pass);
+    let symbol = send_node::named_children_of(block_pass, context);
     if !matches!(symbol.as_slice(), [only] if send_node::symbol_name(*only, context).is_some()) {
         return;
     }

data/src/rules/style/hash_like_case.rs

@@ -17,7 +17,7 @@ pub(super) fn check(context: &RuleContext<'_>, offenses: &mut Vec<Offense>) {
         .unwrap_or(3) as usize;
 
     for node in context.nodes_of("case") {
-        let branches = super::nodes::children(node);
+        let branches = super::nodes::children_in(node, context);
         let whens: Vec<Node<'_>> = branches
             .iter()
             .copied()
@@ -33,7 +33,7 @@ pub(super) fn check(context: &RuleContext<'_>, offenses: &mut Vec<Offense>) {
         let mut conditions = Vec::new();
         let mut bodies = Vec::new();
         for when in &whens {
-            let children = super::nodes::children(*when);
+            let children = super::nodes::children_in(*when, context);
             let [pattern, body] = children.as_slice() else {
                 conditions.clear();
                 break;
@@ -42,8 +42,8 @@ pub(super) fn check(context: &RuleContext<'_>, offenses: &mut Vec<Offense>) {
                 conditions.clear();
                 break;
             }
-            let patterns = super::nodes::children(*pattern);
-            let statements = super::nodes::children(*body);
+            let patterns = super::nodes::children_in(*pattern, context);
+            let statements = super::nodes::children_in(*body, context);
             let ([condition], [statement]) = (patterns.as_slice(), statements.as_slice()) else {
                 conditions.clear();
                 break;
@@ -88,14 +88,14 @@ fn recursive_basic_literal(context: &RuleContext<'_>, node: Node<'_>) -> bool {
                 .is_some_and(|operator| {
                     RECURSIVE_METHODS.contains(&context.source.node_text(operator))
                 })
-                && super::nodes::children(node)
+                && super::nodes::children_in(node, context)
                     .into_iter()
                     .all(|child| recursive_basic_literal(context, child))
         }
         "call" => {
             node.field("method")
                 .is_some_and(|method| RECURSIVE_METHODS.contains(&context.source.node_text(method)))
-                && super::nodes::children(node)
+                && super::nodes::children_in(node, context)
                     .into_iter()
                     .all(|child| recursive_basic_literal(context, child))
         }
@@ -107,10 +107,10 @@ fn recursive_basic_literal(context: &RuleContext<'_>, node: Node<'_>) -> bool {
         | "regex"
         | "subshell"
         | "boolean"
-        | "parenthesized_statements" => super::nodes::children(node)
+        | "parenthesized_statements" => super::nodes::children_in(node, context)
             .into_iter()
             .all(|child| recursive_basic_literal(context, child)),
-        "string" | "delimited_symbol" if is_interpolated(node) => super::nodes::children(node)
+        "string" | "delimited_symbol" if is_interpolated(node) => super::nodes::children_in(node, context)
             .into_iter()
             .all(|child| recursive_basic_literal(context, child)),
         _ => matches!(upstream_type(context, node), Some(name) if BASIC_LITERALS.contains(&name)),

data/src/rules/style/hash_lookup_method.rs

@@ -53,7 +53,7 @@ fn bracket_offense(
     if node.field("block").is_some() || !send_node::is_plain_send(node, context) {
         return None;
     }
-    let arguments = super::nodes::children(node.field("arguments")?);
+    let arguments = super::nodes::children_in(node.field("arguments")?, context);
     let [key] = arguments.as_slice() else {
         return None;
     };
@@ -75,10 +75,16 @@ fn bracket_offense(
 
 /// `offense_for_fetch?`: a one-argument `[]`, in either of the two spellings the grammar has for it.
 fn fetch_offense(node: Node<'_>, context: &RuleContext<'_>) -> Option<Offense> {
+    // `node.method?(:[])`: written on the left of an assignment the same brackets are `[]=`, which
+    // `fetch` has no counterpart for. The grammar spells both as an `element_reference`, so the
+    // parent has to be asked which one this is.
+    if is_assignment_target(node, context) {
+        return None;
+    }
     let (key, selector_start, safe_navigation) = match node.kind_str() {
         "element_reference" => {
             let object = node.field("object")?;
-            let indices = super::nodes::children(node);
+            let indices = super::nodes::children_in(node, context);
             let [_, key] = indices.as_slice() else {
                 return None;
             };
@@ -91,7 +97,7 @@ fn fetch_offense(node: Node<'_>, context: &RuleContext<'_>) -> Option<Offense> {
             if context.source.node_text(selector) != "[]" {
                 return None;
             }
-            let arguments = super::nodes::children(node.field("arguments")?);
+            let arguments = super::nodes::children_in(node.field("arguments")?, context);
             let [key] = arguments.as_slice() else {
                 return None;
             };
@@ -142,3 +148,37 @@ fn receiver_name(receiver: Node<'_>, context: &RuleContext<'_>) -> String {
     }
     context.source.node_text(receiver).to_owned()
 }
+
+/// Whether the node stands on the left of an assignment, where its brackets mean `[]=`.
+///
+/// Only a plain assignment counts. `x[k] += 1` is `(op-asgn (send x :[] k) :+ 1)` upstream -- the
+/// read is a `send :[]` of its own, and the cop reports it -- while `x[k] = 1` is a single
+/// `send :[]=` with no read in it at all. A multiple assignment writes through `[]=` as well, so
+/// its target list is excluded too.
+fn is_assignment_target(node: Node<'_>, context: &RuleContext<'_>) -> bool {
+    let Some(parent) = node.parent_of(context) else {
+        return false;
+    };
+    match parent.kind_str() {
+        // The grammar also spells `value[index] =~ /pattern/` as an `assignment`: `=` is the
+        // assignment token and `~ /pattern/` its unary right side. With no whitespace between
+        // those two characters Ruby reads the pair as the match operator, so the brackets remain
+        // a `send :[]` upstream and must not be mistaken for an `[]=` target.
+        "assignment" => {
+            if parent.field("left") != Some(node) {
+                return false;
+            }
+            let match_operator = parent.field("right").is_some_and(|right| {
+                right.kind_str() == "unary"
+                    && right
+                        .field("operator")
+                        .is_some_and(|operator| context.source.node_text(operator) == "~")
+                    && right.start_byte() > 0
+                    && context.source.text().as_bytes()[right.start_byte() - 1] == b'='
+            });
+            !match_operator
+        }
+        "left_assignment_list" | "rest_assignment" => true,
+        _ => false,
+    }
+}

data/src/rules/style/hash_subset.rs

@@ -50,20 +50,26 @@ pub(super) fn check(
         if !arguments(node).is_empty() {
             continue;
         }
-        let parameters = super::nodes::children(match block.field("parameters") {
-            Some(parameters) => parameters,
-            None => continue,
-        });
+        let parameters = super::nodes::children_in(
+            match block.field("parameters") {
+                Some(parameters) => parameters,
+                None => continue,
+            },
+            context,
+        );
         let [key, value] = parameters.as_slice() else {
             continue;
         };
         if key.kind_str() != "identifier" || value.kind_str() != "identifier" {
             continue;
         }
-        let body = super::nodes::children(match block.field("body") {
-            Some(body) => body,
-            None => continue,
-        });
+        let body = super::nodes::children_in(
+            match block.field("body") {
+                Some(body) => body,
+                None => continue,
+            },
+            context,
+        );
         let [statement] = body.as_slice() else {
             continue;
         };
@@ -221,13 +227,13 @@ fn semantically_except(selector: &str, test: &Test<'_>) -> bool {
 /// `except_key_source`: the keys as the replacement writes them out.
 fn key_source(key: Node<'_>, context: &RuleContext<'_>) -> String {
     match key.kind_str() {
-        "array" => super::nodes::children(key)
+        "array" => super::nodes::children_in(key, context)
             .iter()
             .map(|value| context.source.node_text(*value).to_owned())
             .collect::<Vec<_>>()
             .join(", "),
         // `percent_literal?`: the elements are written bare, so each is spelled back as a literal.
-        "string_array" | "symbol_array" => super::nodes::children(key)
+        "string_array" | "symbol_array" => super::nodes::children_in(key, context)
             .iter()
             .map(|value| decorate_source(*value, context))
             .collect::<Vec<_>>()