sonicop 26.8.101

data/src/rules/lint/unused_block_argument.rs

@@ -0,0 +1,74 @@
+use std::collections::HashSet;
+
+use tree_sitter::Node;
+
+use crate::diagnostic::{Edit, Offense};
+use crate::rules::{RuleContext, first_identifier, walk_named};
+
+pub(super) fn check(context: &RuleContext<'_>, offenses: &mut Vec<Offense>) {
+    let ignore_empty: bool = context.setting("IgnoreEmptyBlocks").unwrap_or(true);
+    for node in context.nodes_of_any(&["block", "do_block"]) {
+        let (Some(parameters), Some(body)) = (
+            node.child_by_field_name("parameters"),
+            node.child_by_field_name("body"),
+        ) else {
+            continue;
+        };
+        if ignore_empty && context.source.node_text(body).trim().is_empty() {
+            continue;
+        }
+
+        let mut parameter_nodes = Vec::new();
+        let mut seen = HashSet::new();
+        let mut cursor = parameters.walk();
+        for parameter in parameters.named_children(&mut cursor) {
+            if parameter.kind() == "identifier" {
+                if seen.insert(parameter.start_byte()) {
+                    parameter_nodes.push(parameter);
+                }
+            } else if let Some(identifier) = first_identifier(parameter)
+                && seen.insert(identifier.start_byte())
+            {
+                parameter_nodes.push(identifier);
+            }
+        }
+
+        for parameter in parameter_nodes {
+            let name = context.source.node_text(parameter);
+            if name.starts_with('_') || identifier_used(body, name, parameter, context) {
+                continue;
+            }
+            offenses.push(
+                context
+                    .offense(
+                        format!("Unused block argument - `{name}`. If it's necessary, use `_` or `_name` as an argument name."),
+                        parameter.byte_range(),
+                    )
+                    .corrected_by(Edit {
+                        start: parameter.start_byte(),
+                        end: parameter.start_byte(),
+                        replacement: "_".to_owned(),
+                        safe: true,
+                    }),
+            );
+        }
+    }
+}
+
+fn identifier_used(
+    body: Node<'_>,
+    name: &str,
+    definition: Node<'_>,
+    context: &RuleContext<'_>,
+) -> bool {
+    let mut used = false;
+    walk_named(body, &mut |candidate| {
+        if candidate.kind() == "identifier"
+            && candidate.byte_range() != definition.byte_range()
+            && context.source.node_text(candidate) == name
+        {
+            used = true;
+        }
+    });
+    used
+}

data/src/rules/lint/useless_assignment.rs

@@ -0,0 +1,104 @@
+use tree_sitter::Node;
+
+use crate::diagnostic::{Edit, Offense};
+use crate::rules::{RuleContext, walk_named};
+
+pub(super) fn check(context: &RuleContext<'_>, offenses: &mut Vec<Offense>) {
+    let root = context.root_node();
+    for assignment in context.nodes_of("assignment") {
+        let Some(left) = assignment.child_by_field_name("left") else {
+            continue;
+        };
+        if left.kind() != "identifier" {
+            continue;
+        }
+        let name = context.source.node_text(left);
+        if name.starts_with('_') {
+            continue;
+        }
+        if assignment.parent().is_some_and(|parent| {
+            parent.kind() == "assignment"
+                && parent
+                    .child_by_field_name("right")
+                    .is_some_and(|right| right.byte_range() == assignment.byte_range())
+        }) {
+            continue;
+        }
+        let scope = enclosing_scope(assignment).unwrap_or(root);
+        if has_other_read(scope, assignment, name, context) {
+            continue;
+        }
+        offenses.push(
+            context
+                .offense(
+                    format!("Useless assignment to variable - `{name}`."),
+                    left.byte_range(),
+                )
+                .corrected_by(Edit {
+                    start: assignment.start_byte(),
+                    end: assignment
+                        .child_by_field_name("right")
+                        .map_or(left.end_byte(), |right| right.start_byte()),
+                    replacement: String::new(),
+                    safe: true,
+                }),
+        );
+    }
+}
+
+fn enclosing_scope(mut node: Node<'_>) -> Option<Node<'_>> {
+    while let Some(parent) = node.parent() {
+        if matches!(parent.kind(), "method" | "singleton_method") {
+            return Some(parent);
+        }
+        node = parent;
+    }
+    None
+}
+
+fn has_other_read(
+    scope: Node<'_>,
+    assignment: Node<'_>,
+    name: &str,
+    context: &RuleContext<'_>,
+) -> bool {
+    let mut found = false;
+    walk_named(scope, &mut |candidate| {
+        if found {
+            return;
+        }
+        if candidate.kind() == "pair"
+            && context.source.node_text(candidate).trim() == format!("{name}:")
+        {
+            found = true;
+            return;
+        }
+        if candidate.kind() == "call"
+            && candidate
+                .child_by_field_name("method")
+                .is_some_and(|method| context.source.node_text(method) == "binding")
+        {
+            found = true;
+            return;
+        }
+        if candidate.kind() == "identifier" && context.source.node_text(candidate) == "binding" {
+            found = true;
+            return;
+        }
+        if candidate.kind() != "identifier" || context.source.node_text(candidate) != name {
+            return;
+        }
+        let is_this_assignment = candidate.byte_range()
+            == assignment
+                .child_by_field_name("left")
+                .map_or(assignment.byte_range(), |left| left.byte_range());
+        let is_write = candidate.parent().is_some_and(|parent| {
+            parent.kind() == "assignment"
+                && parent
+                    .child_by_field_name("left")
+                    .is_some_and(|left| left.byte_range() == candidate.byte_range())
+        });
+        found = !is_this_assignment && !is_write;
+    });
+    found
+}

data/src/rules/metrics/block_length.rs

@@ -0,0 +1,39 @@
+use tree_sitter::Node;
+
+use super::support::{LengthTarget, report_length};
+use crate::diagnostic::Offense;
+use crate::rules::RuleContext;
+
+pub(super) fn check(context: &RuleContext<'_>, offenses: &mut Vec<Offense>) {
+    let max: usize = context.setting("Max").unwrap_or(25);
+    let allowed: Vec<String> = context.setting("AllowedMethods").unwrap_or_default();
+    for node in context.nodes_of_any(&["block", "do_block"]) {
+        if block_method_allowed(node, context, &allowed) {
+            continue;
+        }
+        report_length(context, offenses, node, max, "Block", LengthTarget::Block);
+    }
+}
+
+/// `Class.new`/`Struct.new` bodies are class definitions in disguise, which RuboCop measures with
+/// `Metrics/ClassLength` instead.
+fn block_method_allowed(node: Node<'_>, context: &RuleContext<'_>, allowed: &[String]) -> bool {
+    let Some(call) = node.parent().filter(|parent| parent.kind() == "call") else {
+        return false;
+    };
+    let Some(method) = call.child_by_field_name("method") else {
+        return false;
+    };
+    if context.source.node_text(method) == "new"
+        && call
+            .child_by_field_name("receiver")
+            .is_some_and(|receiver| {
+                matches!(context.source.node_text(receiver), "Class" | "Struct")
+            })
+    {
+        return true;
+    }
+    allowed
+        .iter()
+        .any(|name| name == context.source.node_text(method))
+}

data/src/rules/metrics/class_length.rs

@@ -0,0 +1,34 @@
+use tree_sitter::Node;
+
+use super::support::{LengthTarget, report_length};
+use crate::diagnostic::Offense;
+use crate::rules::RuleContext;
+
+pub(super) fn check(context: &RuleContext<'_>, offenses: &mut Vec<Offense>) {
+    let max: usize = context.setting("Max").unwrap_or(100);
+    for node in context.nodes_of_any(&["class", "singleton_class"]) {
+        // A `class << self` inside a class body is part of that class's length rather than a
+        // class of its own.
+        if node.kind() == "singleton_class" && has_class_ancestor(node) {
+            continue;
+        }
+        report_length(
+            context,
+            offenses,
+            node,
+            max,
+            "Class",
+            LengthTarget::Classlike,
+        );
+    }
+}
+
+fn has_class_ancestor(mut node: Node<'_>) -> bool {
+    while let Some(parent) = node.parent() {
+        if parent.kind() == "class" {
+            return true;
+        }
+        node = parent;
+    }
+    false
+}

data/src/rules/metrics/method_length.rs

@@ -0,0 +1,10 @@
+use super::support::{LengthTarget, report_length};
+use crate::diagnostic::Offense;
+use crate::rules::RuleContext;
+
+pub(super) fn check(context: &RuleContext<'_>, offenses: &mut Vec<Offense>) {
+    let max: usize = context.setting("Max").unwrap_or(10);
+    for node in context.nodes_of_any(&["method", "singleton_method"]) {
+        report_length(context, offenses, node, max, "Method", LengthTarget::Method);
+    }
+}

data/src/rules/metrics/mod.rs

@@ -0,0 +1,10 @@
+department_rules! {
+    "Metrics";
+    block_length => ("BlockLength", Convention),
+    class_length => ("ClassLength", Convention),
+    method_length => ("MethodLength", Convention),
+    module_length => ("ModuleLength", Convention),
+    parameter_lists => ("ParameterLists", Convention),
+}
+
+mod support;

data/src/rules/metrics/module_length.rs

@@ -0,0 +1,17 @@
+use super::support::{LengthTarget, report_length};
+use crate::diagnostic::Offense;
+use crate::rules::RuleContext;
+
+pub(super) fn check(context: &RuleContext<'_>, offenses: &mut Vec<Offense>) {
+    let max: usize = context.setting("Max").unwrap_or(100);
+    for node in context.nodes_of("module") {
+        report_length(
+            context,
+            offenses,
+            node,
+            max,
+            "Module",
+            LengthTarget::Classlike,
+        );
+    }
+}

data/src/rules/metrics/parameter_lists.rs

@@ -0,0 +1,21 @@
+use crate::diagnostic::Offense;
+use crate::rules::RuleContext;
+
+pub(super) fn check(context: &RuleContext<'_>, offenses: &mut Vec<Offense>) {
+    let max: usize = context.setting("Max").unwrap_or(5);
+    let count_keywords: bool = context.setting("CountKeywordArgs").unwrap_or(true);
+    for node in context.nodes_of("method_parameters") {
+        let mut cursor = node.walk();
+        let count = node
+            .named_children(&mut cursor)
+            .filter(|parameter| count_keywords || parameter.kind() != "keyword_parameter")
+            .count();
+        if count <= max {
+            continue;
+        }
+        offenses.push(context.offense(
+            format!("Avoid parameter lists longer than {max} parameters. [{count}/{max}]"),
+            node.byte_range(),
+        ));
+    }
+}

data/src/rules/metrics/support.rs

@@ -0,0 +1,105 @@
+//! Line counting shared by the length cops.
+
+use std::collections::HashSet;
+
+use tree_sitter::Node;
+
+use crate::diagnostic::Offense;
+use crate::rules::{RuleContext, walk_named};
+
+/// What kind of construct a length cop measures. The three differ in how the body is counted and
+/// where the offense is reported, so naming the kind keeps those differences in one place instead
+/// of spreading cop-name comparisons through the counting code.
+#[derive(Clone, Copy, Eq, PartialEq)]
+pub(super) enum LengthTarget {
+    /// A method, counted over its body.
+    Method,
+    /// A class or module, counted over its interior with nested classes and modules removed.
+    Classlike,
+    /// A block, reported against the call that owns it.
+    Block,
+}
+
+/// Reports `node` when it holds more than `max` lines of code, in the shape RuboCop's length cops
+/// use: `Method has too many lines. [12/10]`.
+pub(super) fn report_length(
+    context: &RuleContext<'_>,
+    offenses: &mut Vec<Offense>,
+    node: Node<'_>,
+    max: usize,
+    label: &str,
+    target: LengthTarget,
+) {
+    let count_comments: bool = context.setting("CountComments").unwrap_or(false);
+    let Some(body) = node.child_by_field_name("body") else {
+        return;
+    };
+    let mut length = if target == LengthTarget::Classlike {
+        classlike_code_line_count(node, context, count_comments)
+    } else {
+        code_line_count(body, context, count_comments)
+    };
+    // A block whose whole body is one heredoc spends a line on the heredoc opener, which RuboCop
+    // attributes to the enclosing statement rather than to the block.
+    if target == LengthTarget::Block
+        && body.named_child_count() == 1
+        && context.heredoc_count(body.byte_range()) > 0
+    {
+        length = length.saturating_sub(1);
+    }
+    if length <= max {
+        return;
+    }
+    let location = if target == LengthTarget::Block {
+        node.parent()
+            .filter(|parent| parent.kind() == "call")
+            .unwrap_or(node)
+    } else {
+        node
+    };
+    offenses.push(context.offense(
+        format!("{label} has too many lines. [{length}/{max}]"),
+        location.byte_range(),
+    ));
+}
+
+fn classlike_code_line_count(
+    node: Node<'_>,
+    context: &RuleContext<'_>,
+    count_comments: bool,
+) -> usize {
+    let mut excluded_lines = HashSet::new();
+    walk_named(node, &mut |descendant| {
+        if descendant == node || !matches!(descendant.kind(), "class" | "module") {
+            return;
+        }
+        let first = descendant.start_position().row + 1;
+        let last = descendant.end_position().row + 1;
+        excluded_lines.extend(first..=last);
+    });
+
+    // RuboCop's ProcessedSource is indexed from zero after constructing the
+    // one-based interior line range. Preserve that observable offset exactly.
+    let start = node.start_position().row + 2;
+    let end = node.end_position().row;
+    (start..=end)
+        .filter(|line| {
+            if excluded_lines.contains(line) {
+                return false;
+            }
+            let text = context.source.line(*line + 1).trim();
+            !text.is_empty() && (count_comments || !text.starts_with('#'))
+        })
+        .count()
+}
+
+fn code_line_count(node: Node<'_>, context: &RuleContext<'_>, count_comments: bool) -> usize {
+    let start = node.start_position().row + 1;
+    let end = node.end_position().row + 1;
+    (start..=end)
+        .filter(|line| {
+            let text = context.source.line(*line).trim();
+            !text.is_empty() && (count_comments || !text.starts_with('#'))
+        })
+        .count()
+}