sonicop 26.8.101

data/src/rules/layout/mod.rs

@@ -0,0 +1,13 @@
+department_rules! {
+    "Layout";
+    empty_line_after_magic_comment => ("EmptyLineAfterMagicComment", Convention),
+    end_of_line => ("EndOfLine", Convention),
+    line_length => ("LineLength", Convention),
+    space_after_comma => ("SpaceAfterComma", Convention),
+    space_around_operators => ("SpaceAroundOperators", Convention),
+    space_inside_parens => ("SpaceInsideParens", Convention),
+    trailing_empty_lines => ("TrailingEmptyLines", Convention),
+    trailing_whitespace => ("TrailingWhitespace", Convention),
+}
+
+mod support;

data/src/rules/layout/space_after_comma.rs

@@ -0,0 +1,32 @@
+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 ranges = context.protected_ranges();
+    let bytes = context.source.text().as_bytes();
+    for index in 0..bytes.len() {
+        if bytes[index] != b',' || is_protected(index, ranges) {
+            continue;
+        }
+        let next = bytes.get(index + 1).copied();
+        if next.is_none_or(|byte| {
+            matches!(
+                byte,
+                b' ' | b'\t' | b'\r' | b'\n' | b')' | b']' | b'}' | b'|'
+            )
+        }) {
+            continue;
+        }
+        offenses.push(
+            context
+                .offense("Space missing after comma.", index..index + 1)
+                .corrected_by(Edit {
+                    start: index + 1,
+                    end: index + 1,
+                    replacement: " ".to_owned(),
+                    safe: true,
+                }),
+        );
+    }
+}

data/src/rules/layout/space_around_operators.rs

@@ -0,0 +1,104 @@
+use tree_sitter::Node;
+
+use super::support::{whitespace_after, whitespace_before};
+use crate::diagnostic::{Edit, Offense};
+use crate::rules::RuleContext;
+
+pub(super) fn check(context: &RuleContext<'_>, offenses: &mut Vec<Offense>) {
+    for node in context.nodes_of_any(&["binary", "assignment", "operator_assignment"]) {
+        match node.kind() {
+            "binary" => {
+                let Some(operator) = node.child_by_field_name("operator") else {
+                    continue;
+                };
+                let text = context.source.node_text(operator);
+                if matches!(text, "+" | "-")
+                    && node
+                        .child_by_field_name("left")
+                        .is_some_and(|left| matches!(left.kind(), "return" | "break" | "next"))
+                {
+                    continue;
+                }
+                let require_space = text != "**";
+                check_operator(context, offenses, operator, require_space);
+            }
+            _ => {
+                if let Some(operator) = operator_child(node) {
+                    check_operator(context, offenses, operator, true);
+                }
+            }
+        }
+    }
+}
+
+fn operator_child(node: Node<'_>) -> Option<Node<'_>> {
+    let left = node.child_by_field_name("left")?;
+    let right = node.child_by_field_name("right")?;
+    let mut cursor = node.walk();
+    node.children(&mut cursor).find(|child| {
+        child.start_byte() >= left.end_byte() && child.end_byte() <= right.start_byte()
+    })
+}
+
+fn check_operator(
+    context: &RuleContext<'_>,
+    offenses: &mut Vec<Offense>,
+    operator: Node<'_>,
+    require_space: bool,
+) {
+    if context.in_heredoc(operator.byte_range()) {
+        return;
+    }
+    let source = context.source.text();
+    let before = whitespace_before(source, operator.start_byte());
+    let after = whitespace_after(source, operator.end_byte());
+    let operator_text = context.source.node_text(operator);
+    if operator_text == "=" && source.as_bytes().get(operator.end_byte()) == Some(&b'~') {
+        return;
+    }
+    let touches_line_break = operator
+        .start_byte()
+        .checked_sub(1)
+        .and_then(|index| source.as_bytes().get(index))
+        .is_some_and(|byte| matches!(byte, b'\r' | b'\n'))
+        || source
+            .as_bytes()
+            .get(operator.end_byte())
+            .is_some_and(|byte| matches!(byte, b'\r' | b'\n'));
+    let alignment_allowed: bool = context.setting("AllowForAlignment").unwrap_or(true);
+    if touches_line_break || (alignment_allowed && (before.len() > 1 || after.len() > 1)) {
+        return;
+    }
+    let correct = if require_space {
+        before.len() == 1
+            && &source[before.clone()] == " "
+            && after.len() == 1
+            && &source[after.clone()] == " "
+    } else {
+        before.is_empty() && after.is_empty()
+    };
+    if correct {
+        return;
+    }
+
+    let message = if require_space {
+        format!("Surrounding space missing for operator `{operator_text}`.")
+    } else {
+        format!("Space around operator `{operator_text}` detected.")
+    };
+    let replacement = if require_space {
+        format!(" {operator_text} ")
+    } else {
+        operator_text.to_owned()
+    };
+    offenses.push(
+        context
+            .offense(message, operator.start_byte()..operator.end_byte())
+            .corrected_by(Edit {
+                start: before.start,
+                end: after.end,
+                replacement,
+                safe: true,
+            }),
+    );
+}

data/src/rules/layout/space_inside_parens.rs

@@ -0,0 +1,100 @@
+use std::collections::HashSet;
+use std::ops::Range;
+
+use super::support::{whitespace_after, whitespace_before};
+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 ranges = context.protected_ranges();
+    let text = context.source.text();
+    let bytes = text.as_bytes();
+    let percent_literal_parens = percent_literal_parens(text, ranges);
+    for index in 0..bytes.len() {
+        if is_protected(index, ranges) || percent_literal_parens.contains(&index) {
+            continue;
+        }
+        match bytes[index] {
+            b'(' => {
+                let spaces = whitespace_after(text, index + 1);
+                if !spaces.is_empty()
+                    && bytes.get(spaces.end) != Some(&b')')
+                    && bytes.get(spaces.end) != Some(&b'#')
+                {
+                    offenses.push(paren_space_offense(context, spaces));
+                }
+            }
+            b')' => {
+                let spaces = whitespace_before(text, index);
+                let starts_after_line_break =
+                    spaces.start > 0 && matches!(bytes[spaces.start - 1], b'\r' | b'\n');
+                if !spaces.is_empty()
+                    && !starts_after_line_break
+                    && bytes.get(spaces.start.wrapping_sub(1)) != Some(&b'(')
+                {
+                    offenses.push(paren_space_offense(context, spaces));
+                }
+            }
+            _ => {}
+        }
+    }
+}
+
+fn percent_literal_parens(text: &str, protected: &[Range<usize>]) -> HashSet<usize> {
+    let bytes = text.as_bytes();
+    let mut parens = HashSet::new();
+    let mut index = 0;
+    while index < bytes.len() {
+        if bytes[index] != b'%' || is_protected(index, protected) {
+            index += 1;
+            continue;
+        }
+        let opening = if bytes.get(index + 1) == Some(&b'(') {
+            index + 1
+        } else if bytes.get(index + 1).is_some_and(u8::is_ascii_alphabetic)
+            && bytes.get(index + 2) == Some(&b'(')
+        {
+            index + 2
+        } else {
+            index += 1;
+            continue;
+        };
+
+        let mut depth = 1;
+        let mut cursor = opening + 1;
+        while cursor < bytes.len() {
+            if bytes[cursor] == b'\\' {
+                cursor = (cursor + 2).min(bytes.len());
+                continue;
+            }
+            match bytes[cursor] {
+                b'(' => depth += 1,
+                b')' => {
+                    depth -= 1;
+                    if depth == 0 {
+                        parens.insert(opening);
+                        parens.insert(cursor);
+                        index = cursor;
+                        break;
+                    }
+                }
+                _ => {}
+            }
+            cursor += 1;
+        }
+        index += 1;
+    }
+    parens
+}
+
+fn paren_space_offense(context: &RuleContext<'_>, spaces: Range<usize>) -> Offense {
+    context
+        .offense("Space inside parentheses detected.", spaces.clone())
+        .corrected_by(Edit {
+            start: spaces.start,
+            end: spaces.end,
+            replacement: String::new(),
+            safe: true,
+        })
+}

data/src/rules/layout/support.rs

@@ -0,0 +1,23 @@
+//! Horizontal whitespace scanning shared by the spacing cops.
+
+use std::ops::Range;
+
+/// The run of spaces and tabs ending at `offset`.
+pub(super) fn whitespace_before(source: &str, offset: usize) -> Range<usize> {
+    let bytes = source.as_bytes();
+    let mut start = offset;
+    while start > 0 && matches!(bytes[start - 1], b' ' | b'\t') {
+        start -= 1;
+    }
+    start..offset
+}
+
+/// The run of spaces and tabs starting at `offset`.
+pub(super) fn whitespace_after(source: &str, offset: usize) -> Range<usize> {
+    let bytes = source.as_bytes();
+    let mut end = offset;
+    while end < bytes.len() && matches!(bytes[end], b' ' | b'\t') {
+        end += 1;
+    }
+    offset..end
+}

data/src/rules/layout/trailing_empty_lines.rs

@@ -0,0 +1,38 @@
+use crate::diagnostic::{Edit, Offense};
+use crate::rules::RuleContext;
+
+pub(super) fn check(context: &RuleContext<'_>, offenses: &mut Vec<Offense>) {
+    let text = context.source.text();
+    if text.is_empty() {
+        return;
+    }
+    let style: String = context
+        .setting("EnforcedStyle")
+        .unwrap_or_else(|| "final_newline".to_owned());
+    let expected_newlines = usize::from(style == "final_blank_line") + 1;
+    let without_newlines = text.trim_end_matches(['\r', '\n']);
+    let actual_start = without_newlines.len();
+    let actual = &text[actual_start..];
+    // Only `\n` is counted, as RuboCop does. A carriage return is `Layout/EndOfLine`'s business;
+    // reporting CRLF here as well would make the two cops rewrite the same bytes in opposite
+    // directions on Windows, where the expected ending is CRLF.
+    let newline_count = actual.bytes().filter(|byte| *byte == b'\n').count();
+    if newline_count == expected_newlines {
+        return;
+    }
+    let message = if newline_count < expected_newlines {
+        "Final newline missing."
+    } else {
+        "Extra blank line detected at file end."
+    };
+    offenses.push(
+        context
+            .offense(message, actual_start.saturating_sub(1)..text.len())
+            .corrected_by(Edit {
+                start: actual_start,
+                end: text.len(),
+                replacement: "\n".repeat(expected_newlines),
+                safe: true,
+            }),
+    );
+}

data/src/rules/layout/trailing_whitespace.rs

@@ -0,0 +1,26 @@
+use crate::diagnostic::{Edit, Offense};
+use crate::rules::RuleContext;
+
+pub(super) fn check(context: &RuleContext<'_>, offenses: &mut Vec<Offense>) {
+    let text = context.source.text();
+    for line_number in 1..=context.source.line_count() {
+        let range = context.source.line_range(line_number);
+        let line = &text[range.clone()];
+        let content_end = line.trim_end_matches(['\r', '\n']).len();
+        let trimmed_end = line[..content_end].trim_end_matches([' ', '\t']).len();
+        if trimmed_end < content_end {
+            let start = range.start + trimmed_end;
+            let end = range.start + content_end;
+            offenses.push(
+                context
+                    .offense("Trailing whitespace detected.", start..end)
+                    .corrected_by(Edit {
+                        start,
+                        end,
+                        replacement: String::new(),
+                        safe: true,
+                    }),
+            );
+        }
+    }
+}

data/src/rules/lint/duplicate_methods.rs

@@ -0,0 +1,72 @@
+use std::collections::HashMap;
+
+use tree_sitter::Node;
+
+use crate::diagnostic::Offense;
+use crate::rules::{RuleContext, push_named_children};
+
+pub(super) fn check(context: &RuleContext<'_>, offenses: &mut Vec<Offense>) {
+    inspect_method_scope(context.root_node(), context, offenses);
+    for node in context.nodes_of_any(&["class", "module", "singleton_class"]) {
+        inspect_method_scope(node, context, offenses);
+    }
+}
+
+fn inspect_method_scope(scope: Node<'_>, context: &RuleContext<'_>, offenses: &mut Vec<Offense>) {
+    let mut methods: HashMap<(bool, String), usize> = HashMap::new();
+    collect_scope_methods(scope, scope, &mut |method| {
+        if inside_ignored_method_context(method, scope) {
+            return;
+        }
+        let Some(name) = method.child_by_field_name("name") else {
+            return;
+        };
+        let singleton = method.kind() == "singleton_method";
+        let key = (singleton, context.source.node_text(name).to_owned());
+        if let Some(first_line) = methods.insert(key.clone(), name.start_position().row + 1) {
+            offenses.push(context.offense(
+                format!(
+                    "Method `{}` is defined at both line {first_line} and line {}.",
+                    key.1,
+                    name.start_position().row + 1
+                ),
+                name.byte_range(),
+            ));
+        }
+    });
+}
+
+fn inside_ignored_method_context(mut node: Node<'_>, scope: Node<'_>) -> bool {
+    while let Some(parent) = node.parent() {
+        if parent == scope {
+            return false;
+        }
+        if matches!(
+            parent.kind(),
+            "block" | "do_block" | "if" | "unless" | "if_modifier" | "unless_modifier" | "rescue"
+        ) {
+            return true;
+        }
+        node = parent;
+    }
+    false
+}
+
+fn collect_scope_methods<'tree>(
+    node: Node<'tree>,
+    root: Node<'tree>,
+    callback: &mut impl FnMut(Node<'tree>),
+) {
+    let mut stack = Vec::new();
+    push_named_children(node, &mut stack);
+    while let Some(current) = stack.pop() {
+        if current != root && matches!(current.kind(), "class" | "module" | "singleton_class") {
+            continue;
+        }
+        if matches!(current.kind(), "method" | "singleton_method") {
+            callback(current);
+            continue;
+        }
+        push_named_children(current, &mut stack);
+    }
+}

data/src/rules/lint/mod.rs

@@ -0,0 +1,7 @@
+department_rules! {
+    "Lint";
+    duplicate_methods => ("DuplicateMethods", Warning),
+    syntax => ("Syntax", Fatal),
+    unused_block_argument => ("UnusedBlockArgument", Warning),
+    useless_assignment => ("UselessAssignment", Warning),
+}

data/src/rules/lint/syntax.rs

@@ -0,0 +1,200 @@
+use tree_sitter::Node;
+
+use crate::diagnostic::Offense;
+use crate::ruby_version::RubyVersion;
+use crate::rules::RuleContext;
+
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+enum SyntaxFeature {
+    BeginlessRange,
+    ArgumentForwarding,
+}
+
+#[derive(Clone, Copy, Debug)]
+struct SyntaxFeatureSpec {
+    feature: SyntaxFeature,
+    available_since: RubyVersion,
+}
+
+const SYNTAX_FEATURES: &[SyntaxFeatureSpec] = &[
+    SyntaxFeatureSpec {
+        feature: SyntaxFeature::BeginlessRange,
+        available_since: RubyVersion::new(2, 7),
+    },
+    SyntaxFeatureSpec {
+        feature: SyntaxFeature::ArgumentForwarding,
+        available_since: RubyVersion::new(2, 7),
+    },
+];
+
+pub(super) fn check(context: &RuleContext<'_>, offenses: &mut Vec<Offense>) {
+    if context.root_node().has_error() {
+        for node in context.nodes() {
+            let nested_error = node.parent().is_some_and(|parent| parent.is_error());
+            if (!node.is_error() && !node.is_missing()) || nested_error {
+                continue;
+            }
+            let token = context.source.node_text(node).trim();
+            let message = if node.is_missing() {
+                format!("unexpected end-of-input; expected {}", node.kind())
+            } else if token.is_empty() {
+                "unexpected token".to_owned()
+            } else {
+                let display: String = token.chars().take(24).collect();
+                format!("unexpected token `{display}`")
+            };
+            offenses.push(
+                context.offense(
+                    syntax_message(&message, context.target_ruby_version()),
+                    node.start_byte()
+                        ..node
+                            .end_byte()
+                            .max(node.start_byte() + usize::from(!context.source.is_empty())),
+                ),
+            );
+        }
+    }
+    version_gated_syntax(context, offenses);
+}
+
+fn version_gated_syntax(context: &RuleContext<'_>, offenses: &mut Vec<Offense>) {
+    let target = context.target_ruby_version();
+    for node in context.nodes() {
+        let Some((feature, start, end, token_name)) = feature_use(node, context) else {
+            continue;
+        };
+        let Some(spec) = SYNTAX_FEATURES.iter().find(|spec| spec.feature == feature) else {
+            continue;
+        };
+        if target >= spec.available_since {
+            continue;
+        }
+        offenses.push(context.offense(
+            syntax_message(&format!("unexpected token {token_name}"), target),
+            start..end,
+        ));
+        if feature == SyntaxFeature::ArgumentForwarding && node.kind() == "forward_parameter" {
+            legacy_forwarding_recovery(node, context, offenses);
+        }
+    }
+}
+
+fn feature_use(
+    node: Node<'_>,
+    context: &RuleContext<'_>,
+) -> Option<(SyntaxFeature, usize, usize, &'static str)> {
+    match node.kind() {
+        "range" if node.child_by_field_name("begin").is_none() => {
+            let text = context.source.node_text(node);
+            if text.starts_with("...") {
+                Some((
+                    SyntaxFeature::BeginlessRange,
+                    node.start_byte(),
+                    node.start_byte() + 3,
+                    "tDOT3",
+                ))
+            } else if text.starts_with("..") {
+                Some((
+                    SyntaxFeature::BeginlessRange,
+                    node.start_byte(),
+                    node.start_byte() + 2,
+                    "tDOT2",
+                ))
+            } else {
+                None
+            }
+        }
+        "forward_parameter" | "forward_argument" => Some((
+            SyntaxFeature::ArgumentForwarding,
+            node.start_byte(),
+            node.end_byte(),
+            "tDOT3",
+        )),
+        _ => None,
+    }
+}
+
+fn legacy_forwarding_recovery(
+    parameter: Node<'_>,
+    context: &RuleContext<'_>,
+    offenses: &mut Vec<Offense>,
+) {
+    let Some(method) = ancestor_matching(parameter, |node| {
+        matches!(node.kind(), "method" | "singleton_method")
+    }) else {
+        return;
+    };
+    let Some(container) =
+        ancestor_matching(method, |node| matches!(node.kind(), "class" | "module"))
+    else {
+        return;
+    };
+    let Some(body) = container.child_by_field_name("body") else {
+        return;
+    };
+    let later_nodes = significant_named_children(body)
+        .filter(|node| node.start_byte() >= method.end_byte())
+        .collect::<Vec<_>>();
+    if later_nodes.is_empty() {
+        return;
+    }
+
+    let (keyword, reason) = if container.kind() == "class" {
+        ("class", "class definition in method body")
+    } else {
+        ("module", "module definition in method body")
+    };
+    offenses.push(context.offense(
+        syntax_message(reason, context.target_ruby_version()),
+        container.start_byte()..container.start_byte() + keyword.len(),
+    ));
+
+    let has_preceding_top_level_statement =
+        std::iter::successors(container.prev_named_sibling(), |node| {
+            node.prev_named_sibling()
+        })
+        .any(|node| node.kind() != "comment");
+    let later_nonempty_method = later_nodes.iter().any(|node| {
+        matches!(node.kind(), "method" | "singleton_method")
+            && node
+                .child_by_field_name("body")
+                .is_some_and(|body| significant_named_children(body).next().is_some())
+    });
+    if container.kind() != "module" || !has_preceding_top_level_statement || !later_nonempty_method
+    {
+        return;
+    }
+
+    let end = container.end_byte();
+    let start = end.saturating_sub(3);
+    if context.source.slice(start..end) == "end" {
+        offenses.push(context.offense(
+            syntax_message("unexpected token kEND", context.target_ruby_version()),
+            start..end,
+        ));
+    }
+}
+
+fn significant_named_children(node: Node<'_>) -> impl Iterator<Item = Node<'_>> {
+    let mut cursor = node.walk();
+    node.named_children(&mut cursor)
+        .filter(|child| child.kind() != "comment")
+        .collect::<Vec<_>>()
+        .into_iter()
+}
+
+fn ancestor_matching(mut node: Node<'_>, predicate: impl Fn(Node<'_>) -> bool) -> Option<Node<'_>> {
+    while let Some(parent) = node.parent() {
+        if predicate(parent) {
+            return Some(parent);
+        }
+        node = parent;
+    }
+    None
+}
+
+fn syntax_message(reason: &str, target: RubyVersion) -> String {
+    format!(
+        "{reason}\n(Using Ruby {target} parser; configure using `TargetRubyVersion` parameter, under `AllCops`)"
+    )
+}