sonicop 26.8.101

data/src/rules/security/eval.rs

@@ -0,0 +1,170 @@
+use tree_sitter::Node;
+
+use crate::diagnostic::Offense;
+use crate::rules::RuleContext;
+
+/// Operators RuboCop's `Node#recursive_literal?` looks through
+/// (`LITERAL_RECURSIVE_METHODS`): comparisons plus `*`, `!` and `<=>`. Note the
+/// absence of `+`, so `"#{1 + 1}"` counts as dynamic while `"#{1 * 2}"` does not.
+const LITERAL_RECURSIVE_OPERATORS: &[&str] =
+    &["==", "===", "!=", "<=", ">=", ">", "<", "*", "!", "<=>"];
+
+const NUMERIC_LEAF_KINDS: &[&str] = &["integer", "float", "rational", "complex"];
+
+/// Leaf nodes that are literals outright (`BASIC_LITERALS`, plus the fragments
+/// tree-sitter splits literal text into).
+const LITERAL_LEAF_KINDS: &[&str] = &[
+    "integer",
+    "float",
+    "rational",
+    "complex",
+    "true",
+    "false",
+    "nil",
+    "simple_symbol",
+    "hash_key_symbol",
+    "character",
+    "string_content",
+    "escape_sequence",
+    "heredoc_content",
+    "heredoc_end",
+    "regex_options",
+];
+
+/// Literals built out of other nodes (`COMPOSITE_LITERALS`, plus `begin`/`pair`
+/// and tree-sitter's own grouping nodes): literal only if every part is.
+const LITERAL_COMPOSITE_KINDS: &[&str] = &[
+    "string",
+    "bare_string",
+    "chained_string",
+    "delimited_symbol",
+    "subshell",
+    "regex",
+    "array",
+    "string_array",
+    "symbol_array",
+    "hash",
+    "pair",
+    "range",
+    "interpolation",
+    "heredoc_body",
+    "parenthesized_statements",
+];
+
+pub(super) fn check(context: &RuleContext<'_>, offenses: &mut Vec<Offense>) {
+    for node in context.nodes_of("call") {
+        let Some(method) = node.child_by_field_name("method") else {
+            continue;
+        };
+        if context.source.node_text(method) != "eval" || !receiver_is_eval_scope(node, context) {
+            continue;
+        }
+        let Some(arguments) = node.child_by_field_name("arguments") else {
+            continue;
+        };
+        let Some(argument) = arguments.named_child(0) else {
+            continue;
+        };
+        if literal_code(argument, context) {
+            continue;
+        }
+        offenses.push(context.offense(
+            "The use of `eval` is a serious security risk.",
+            method.byte_range(),
+        ));
+    }
+}
+
+/// RuboCop only matches `eval`, `binding.eval` and `Kernel.eval` - the receivers
+/// that evaluate in the caller's own scope. `::Kernel` is the same constant, but
+/// `Binding` and any other constant are different methods entirely.
+fn receiver_is_eval_scope(call: Node<'_>, context: &RuleContext<'_>) -> bool {
+    let Some(receiver) = call.child_by_field_name("receiver") else {
+        return true;
+    };
+    match receiver.kind() {
+        "constant" => context.source.node_text(receiver) == "Kernel",
+        // `::Kernel`, but not a `Foo::Kernel` that merely ends in the name.
+        "scope_resolution" => {
+            receiver.child_by_field_name("scope").is_none()
+                && receiver
+                    .child_by_field_name("name")
+                    .is_some_and(|name| context.source.node_text(name) == "Kernel")
+        }
+        "identifier" => context.source.node_text(receiver) == "binding",
+        _ => false,
+    }
+}
+
+/// Whether the evaluated argument is a literal chunk of code. RuboCop exempts a
+/// plain string outright, and an interpolated one whose interpolations are all
+/// recursively literal, because neither can smuggle in new code. Only those two
+/// shapes are exempt: a backtick command or a symbol still counts as an offense
+/// even though both are literals.
+fn literal_code(argument: Node<'_>, context: &RuleContext<'_>) -> bool {
+    match argument.kind() {
+        "string" | "chained_string" => recursive_literal(argument, context),
+        // A heredoc's body is a sibling of the enclosing statement rather than a
+        // child of the opener, so it has to be looked up separately.
+        "heredoc_beginning" => {
+            heredoc_body(argument, context).is_some_and(|body| recursive_literal(body, context))
+        }
+        _ => false,
+    }
+}
+
+/// The `heredoc_body` opened by `beginning`. Bodies appear after the statement in
+/// the same order as their openers, so the nth opener owns the nth body.
+fn heredoc_body<'a>(beginning: Node<'_>, context: &'a RuleContext<'_>) -> Option<Node<'a>> {
+    let position = context
+        .nodes_of("heredoc_beginning")
+        .position(|node| node.id() == beginning.id())?;
+    context.nodes_of("heredoc_body").nth(position)
+}
+
+/// Mirrors RuboCop's `Node#recursive_literal?`.
+fn recursive_literal(node: Node<'_>, context: &RuleContext<'_>) -> bool {
+    let kind = node.kind();
+    if LITERAL_LEAF_KINDS.contains(&kind) {
+        return true;
+    }
+    if LITERAL_COMPOSITE_KINDS.contains(&kind) {
+        return named_children(node).all(|child| recursive_literal(child, context));
+    }
+    if matches!(kind, "unary" | "binary" | "boolean") {
+        let Some(operator) = node
+            .child_by_field_name("operator")
+            .map(|operator| context.source.node_text(operator))
+            .or_else(|| operator_token(node, context))
+        else {
+            return false;
+        };
+        // A signed number is a single numeric literal to RuboCop's parser rather
+        // than a call, so `-1` is literal while `-foo` is not.
+        if kind == "unary" && matches!(operator, "-" | "+") {
+            return node
+                .child_by_field_name("operand")
+                .is_some_and(|operand| NUMERIC_LEAF_KINDS.contains(&operand.kind()));
+        }
+        return (LITERAL_RECURSIVE_OPERATORS.contains(&operator)
+            || matches!(operator, "and" | "or"))
+            && named_children(node).all(|child| recursive_literal(child, context));
+    }
+    false
+}
+
+/// The operator of a node that exposes it as an anonymous token rather than a
+/// named `operator` field.
+fn operator_token<'a>(node: Node<'_>, context: &'a RuleContext<'_>) -> Option<&'a str> {
+    let mut cursor = node.walk();
+    node.children(&mut cursor)
+        .find(|child| !child.is_named())
+        .map(|child| context.source.node_text(child))
+}
+
+fn named_children<'tree>(node: Node<'tree>) -> impl Iterator<Item = Node<'tree>> {
+    let mut cursor = node.walk();
+    node.named_children(&mut cursor)
+        .collect::<Vec<_>>()
+        .into_iter()
+}

data/src/rules/security/mod.rs

@@ -0,0 +1,6 @@
+department_rules! {
+    "Security";
+    // `Security/Eval` inherits `Base#default_severity`, which is `:convention` for every
+    // department except `Lint`, and `config/default.yml` gives it no `Severity:` override.
+    eval => ("Eval", Convention),
+}

data/src/rules/style/frozen_string_literal_comment.rs

@@ -0,0 +1,56 @@
+use crate::diagnostic::{Edit, Offense};
+use crate::rules::RuleContext;
+
+pub(super) fn check(context: &RuleContext<'_>, offenses: &mut Vec<Offense>) {
+    if context.source.text().trim().is_empty() {
+        return;
+    }
+    let style: String = context
+        .setting("EnforcedStyle")
+        .unwrap_or_else(|| "always".to_owned());
+    let lines: Vec<&str> = context.source.text().lines().take(4).collect();
+    let existing = lines
+        .iter()
+        .position(|line| line.trim_start().starts_with("# frozen_string_literal:"));
+
+    if style == "never" {
+        if let Some(index) = existing {
+            let start = context.source.line_start(index + 1);
+            let end = context.source.line_range(index + 1).end;
+            offenses.push(
+                context
+                    .offense("Remove the frozen string literal comment.", start..end)
+                    .corrected_by(Edit {
+                        start,
+                        end,
+                        replacement: String::new(),
+                        safe: false,
+                    }),
+            );
+        }
+        return;
+    }
+    if existing.is_some() {
+        return;
+    }
+
+    let first = context.source.line(1);
+    let insertion = if first.starts_with("#!") {
+        context.source.line_range(1).end
+    } else {
+        0
+    };
+    offenses.push(
+        context
+            .offense(
+                "Missing frozen string literal comment.",
+                insertion..insertion,
+            )
+            .corrected_by(Edit {
+                start: insertion,
+                end: insertion,
+                replacement: "# frozen_string_literal: true\n\n".to_owned(),
+                safe: false,
+            }),
+    );
+}

data/src/rules/style/hash_syntax.rs

@@ -0,0 +1,63 @@
+use std::sync::LazyLock;
+
+use regex::Regex;
+use tree_sitter::Node;
+
+use crate::diagnostic::{Edit, Offense};
+use crate::rules::RuleContext;
+
+static HASH_ROCKET: LazyLock<Regex> =
+    LazyLock::new(|| Regex::new(r"^:([A-Za-z_][A-Za-z0-9_]*)\s*=>").unwrap());
+
+pub(super) fn check(context: &RuleContext<'_>, offenses: &mut Vec<Offense>) {
+    let style: String = context
+        .setting("EnforcedStyle")
+        .unwrap_or_else(|| "ruby19".to_owned());
+    if style != "ruby19" && style != "ruby19_no_mixed_keys" {
+        return;
+    }
+    for node in context.nodes_of("pair") {
+        let text = context.source.node_text(node);
+        let Some(captures) = HASH_ROCKET.captures(text) else {
+            continue;
+        };
+        // `ruby19` leaves a hash alone unless every key can take the new syntax, so that one
+        // rocket that has to stay does not leave the hash in two styles at once.
+        if style == "ruby19" && !all_hash_keys_are_symbols(node, context) {
+            continue;
+        }
+        let whole = captures.get(0).unwrap();
+        let name = captures.get(1).unwrap().as_str();
+        let start = node.start_byte() + whole.start();
+        let end = node.start_byte() + whole.end();
+        offenses.push(
+            context
+                .offense("Use the new Ruby 1.9 hash syntax.", start..end)
+                .corrected_by(Edit {
+                    start,
+                    end,
+                    replacement: format!("{name}:"),
+                    safe: true,
+                }),
+        );
+    }
+}
+
+fn all_hash_keys_are_symbols(node: Node<'_>, context: &RuleContext<'_>) -> bool {
+    let Some(container) = node.parent() else {
+        return false;
+    };
+    let mut cursor = container.walk();
+    let pairs = container
+        .named_children(&mut cursor)
+        .filter(|child| child.kind() == "pair")
+        .collect::<Vec<_>>();
+    !pairs.is_empty()
+        && pairs.iter().all(|pair| {
+            let Some(key) = pair.child_by_field_name("key") else {
+                return false;
+            };
+            context.source.node_text(key).starts_with(':')
+                || context.source.text().as_bytes().get(key.end_byte()) == Some(&b':')
+        })
+}

data/src/rules/style/mod.rs

@@ -0,0 +1,9 @@
+department_rules! {
+    "Style";
+    frozen_string_literal_comment => ("FrozenStringLiteralComment", Convention),
+    hash_syntax => ("HashSyntax", Convention),
+    numeric_literals => ("NumericLiterals", Convention),
+    redundant_return => ("RedundantReturn", Convention),
+    semicolon => ("Semicolon", Convention),
+    string_literals => ("StringLiterals", Convention),
+}

data/src/rules/style/numeric_literals.rs

@@ -0,0 +1,59 @@
+use crate::diagnostic::{Edit, Offense};
+use crate::rules::RuleContext;
+
+pub(super) fn check(context: &RuleContext<'_>, offenses: &mut Vec<Offense>) {
+    let min_digits: usize = context.setting("MinDigits").unwrap_or(5);
+    for node in context.nodes_of("integer") {
+        let text = context.source.node_text(node);
+        if text.len() < min_digits
+            || text.contains('_')
+            || text.starts_with('0')
+            || !text.bytes().all(|byte| byte.is_ascii_digit())
+        {
+            continue;
+        }
+        let replacement = grouped_number(text);
+        offenses.push(
+            context
+                .offense(
+                    "Use underscores(_) as thousands separator and separate every 3 digits with them.",
+                    node.byte_range(),
+                )
+                .corrected_by(Edit {
+                    start: node.start_byte(),
+                    end: node.end_byte(),
+                    replacement,
+                    safe: true,
+                }),
+        );
+    }
+}
+
+fn grouped_number(number: &str) -> String {
+    let first = number.len() % 3;
+    let mut output = String::with_capacity(number.len() + number.len() / 3);
+    let mut index = 0;
+    if first != 0 {
+        output.push_str(&number[..first]);
+        index = first;
+    }
+    while index < number.len() {
+        if !output.is_empty() {
+            output.push('_');
+        }
+        output.push_str(&number[index..index + 3]);
+        index += 3;
+    }
+    output
+}
+
+#[cfg(test)]
+mod tests {
+    use super::grouped_number;
+
+    #[test]
+    fn groups_decimal_digits() {
+        assert_eq!(grouped_number("12345"), "12_345");
+        assert_eq!(grouped_number("1234567"), "1_234_567");
+    }
+}

data/src/rules/style/redundant_return.rs

@@ -0,0 +1,143 @@
+use tree_sitter::Node;
+
+use crate::diagnostic::{Edit, Offense};
+use crate::rules::RuleContext;
+
+pub(super) fn check(context: &RuleContext<'_>, offenses: &mut Vec<Offense>) {
+    let allow_multiple_return_values: bool = context
+        .setting("AllowMultipleReturnValues")
+        .unwrap_or(false);
+    for node in context.nodes_of_any(&["method", "singleton_method"]) {
+        let Some(body) = node.child_by_field_name("body") else {
+            continue;
+        };
+        let Some(last) = last_body_statement(body) else {
+            continue;
+        };
+        if last.kind() != "return" {
+            continue;
+        }
+        let arguments = return_arguments(last);
+        let multiple_values = arguments.len() > 1 && !braceless_hash(&arguments);
+        if allow_multiple_return_values && multiple_values {
+            continue;
+        }
+        let message = if multiple_values {
+            "Redundant `return` detected. To return multiple values, use an array."
+        } else {
+            "Redundant `return` detected."
+        };
+        offenses.push(
+            context
+                .offense(
+                    message,
+                    last.start_byte()..last.start_byte() + "return".len(),
+                )
+                .corrected_by(redundant_return_edit(
+                    context,
+                    last,
+                    &arguments,
+                    multiple_values,
+                )),
+        );
+    }
+}
+
+/// The expression a method body evaluates last. A trailing comment is a named
+/// node here but absent from RuboCop's AST, so it must not stand in for the
+/// final expression and hide the `return` behind it.
+fn last_body_statement(body: Node<'_>) -> Option<Node<'_>> {
+    let mut cursor = body.walk();
+    body.named_children(&mut cursor)
+        .filter(|child| child.kind() != "comment")
+        .last()
+}
+
+/// The values a `return` yields. RuboCop reads them off the `return` node
+/// itself, where a braceless trailing hash has already been folded into one
+/// `hash` argument, while tree-sitter keeps its `pair`s separate.
+fn return_arguments<'tree>(node: Node<'tree>) -> Vec<Node<'tree>> {
+    let Some(list) = node
+        .named_child(0)
+        .filter(|child| child.kind() == "argument_list")
+    else {
+        return Vec::new();
+    };
+    let mut cursor = list.walk();
+    list.named_children(&mut cursor).collect()
+}
+
+fn braceless_hash(arguments: &[Node<'_>]) -> bool {
+    !arguments.is_empty() && arguments.iter().all(|argument| argument.kind() == "pair")
+}
+
+/// Mirrors RuboCop's autocorrection: an argument-less `return` becomes `nil`,
+/// multiple values gain `[]`, a braceless hash gains `{}`, a leading splat is
+/// unwrapped, and the keyword plus its trailing space goes away. Dropping the
+/// keyword alone would leave `return a, b` as the syntax error `a, b`.
+fn redundant_return_edit(
+    context: &RuleContext<'_>,
+    node: Node<'_>,
+    arguments: &[Node<'_>],
+    multiple_values: bool,
+) -> Edit {
+    let (Some(first), Some(last)) = (arguments.first(), arguments.last()) else {
+        return Edit {
+            start: node.start_byte(),
+            end: node.end_byte(),
+            replacement: "nil".to_owned(),
+            safe: true,
+        };
+    };
+    let wrapper = if multiple_values {
+        Some(('[', ']'))
+    } else if braceless_hash(arguments) {
+        Some(('{', '}'))
+    } else {
+        None
+    };
+    let splat = arguments
+        .iter()
+        .any(|argument| argument.kind() == "splat_argument");
+
+    let text = context.source.node_text(node);
+    let keyword_end = node.start_byte() + "return".len();
+    let whitespace_end = keyword_end
+        + text["return".len()..]
+            .bytes()
+            .take_while(|byte| matches!(byte, b' ' | b'\t'))
+            .count();
+    if wrapper.is_none() && !splat {
+        return Edit {
+            start: node.start_byte(),
+            end: whitespace_end,
+            replacement: String::new(),
+            safe: true,
+        };
+    }
+
+    // Rebuilt rather than spliced so that text the arguments do not cover -
+    // `return(1, 2)`'s parentheses - survives verbatim.
+    let mut replacement = String::new();
+    replacement.push_str(context.source.slice(whitespace_end..first.start_byte()));
+    if let Some((open, _)) = wrapper {
+        replacement.push(open);
+    }
+    let first_text = context.source.node_text(*first);
+    replacement.push_str(if splat {
+        first_text.strip_prefix('*').unwrap_or(first_text)
+    } else {
+        first_text
+    });
+    replacement.push_str(context.source.slice(first.end_byte()..last.end_byte()));
+    if let Some((_, close)) = wrapper {
+        replacement.push(close);
+    }
+    replacement.push_str(context.source.slice(last.end_byte()..node.end_byte()));
+    Edit {
+        start: node.start_byte(),
+        end: node.end_byte(),
+        replacement,
+        safe: true,
+    }
+}

data/src/rules/style/semicolon.rs

@@ -0,0 +1,48 @@
+use crate::diagnostic::{Edit, Offense};
+use crate::rules::RuleContext;
+use crate::source::is_protected;
+
+pub(super) fn check(context: &RuleContext<'_>, offenses: &mut Vec<Offense>) {
+    let allow_as_expression_separator: bool = context
+        .setting("AllowAsExpressionSeparator")
+        .unwrap_or(false);
+    let ranges = context.protected_ranges();
+    let text = context.source.text();
+    let bytes = text.as_bytes();
+    for (index, byte) in bytes.iter().enumerate() {
+        if *byte != b';' || is_protected(index, ranges) {
+            continue;
+        }
+        let rest = &text[index + 1..];
+        let until_newline = rest.split_once('\n').map_or(rest, |(line, _)| line);
+        if until_newline.trim_start().starts_with("end") {
+            continue;
+        }
+        let only_comment =
+            until_newline.trim().is_empty() || until_newline.trim_start().starts_with('#');
+        let before_on_line = text[..index]
+            .rsplit_once('\n')
+            .map_or(&text[..index], |(_, line)| line);
+        let adjacent_to_curly =
+            until_newline.trim_start().starts_with('}') || before_on_line.trim_end().ends_with('{');
+        if allow_as_expression_separator && !only_comment && !adjacent_to_curly {
+            continue;
+        }
+        let offense = context.offense(
+            "Do not use semicolons to terminate expressions.",
+            index..index + 1,
+        );
+        // Only a semicolon with nothing but a comment after it can be dropped outright; removing
+        // one that separates two expressions would join them into a single statement.
+        offenses.push(if only_comment {
+            offense.corrected_by(Edit {
+                start: index,
+                end: index + 1,
+                replacement: String::new(),
+                safe: true,
+            })
+        } else {
+            offense
+        });
+    }
+}

data/src/rules/style/string_literals.rs

@@ -0,0 +1,74 @@
+use tree_sitter::Node;
+
+use crate::diagnostic::{Edit, Offense};
+use crate::rules::RuleContext;
+
+pub(super) fn check(context: &RuleContext<'_>, offenses: &mut Vec<Offense>) {
+    let style: String = context
+        .setting("EnforcedStyle")
+        .unwrap_or_else(|| "single_quotes".to_owned());
+    for node in context.nodes_of("string") {
+        if inside_interpolation(node) || quoted_label_key(node, context) {
+            continue;
+        }
+        let text = context.source.node_text(node);
+        let (from, to, message) = if style == "single_quotes" {
+            (
+                '"',
+                '\'',
+                "Prefer single-quoted strings when you don't need string interpolation or special symbols.",
+            )
+        } else {
+            (
+                '\'',
+                '"',
+                "Prefer double-quoted strings unless you need single quotes to avoid extra backslashes for escaping.",
+            )
+        };
+        if !text.starts_with(from) || !text.ends_with(from) || text.len() < 2 {
+            continue;
+        }
+        let content = &text[1..text.len() - 1];
+        if content.contains(to)
+            || content.contains('\\')
+            || content.contains("#{")
+            || content.contains('\n')
+        {
+            continue;
+        }
+        let replacement = format!("{to}{content}{to}");
+        offenses.push(
+            context
+                .offense(message, node.byte_range())
+                .corrected_by(Edit {
+                    start: node.start_byte(),
+                    end: node.end_byte(),
+                    replacement,
+                    safe: true,
+                }),
+        );
+    }
+}
+
+fn inside_interpolation(mut node: Node<'_>) -> bool {
+    while let Some(parent) = node.parent() {
+        if parent.kind() == "interpolation" {
+            return true;
+        }
+        node = parent;
+    }
+    false
+}
+
+/// A quoted hash key such as `'a': 1` is a symbol rather than a string, so re-quoting it would
+/// change what it means.
+fn quoted_label_key(node: Node<'_>, context: &RuleContext<'_>) -> bool {
+    let Some(parent) = node.parent() else {
+        return false;
+    };
+    parent.kind() == "pair"
+        && parent
+            .child_by_field_name("key")
+            .is_some_and(|key| key.byte_range() == node.byte_range())
+        && context.source.text().as_bytes().get(node.end_byte()) == Some(&b':')
+}

data/src/rules/support.rs

@@ -0,0 +1,31 @@
+//! Tree walks shared by cops in more than one department.
+
+use tree_sitter::Node;
+
+/// Pushes `node`'s named children so that popping the stack yields them in
+/// source order, making a `pop`-driven loop reproduce depth-first pre-order.
+pub(crate) fn push_named_children<'tree>(node: Node<'tree>, stack: &mut Vec<Node<'tree>>) {
+    let start = stack.len();
+    let mut cursor = node.walk();
+    stack.extend(node.named_children(&mut cursor));
+    stack[start..].reverse();
+}
+
+pub(crate) fn walk_named(node: Node<'_>, callback: &mut impl FnMut(Node<'_>)) {
+    let mut stack = vec![node];
+    while let Some(current) = stack.pop() {
+        callback(current);
+        push_named_children(current, &mut stack);
+    }
+}
+
+pub(crate) fn first_identifier(node: Node<'_>) -> Option<Node<'_>> {
+    let mut stack = vec![node];
+    while let Some(current) = stack.pop() {
+        if current.kind() == "identifier" {
+            return Some(current);
+        }
+        push_named_children(current, &mut stack);
+    }
+    None
+}