thailint 0.16.0__py3-none-any.whl → 0.17.0__py3-none-any.whl

src/linters/clone_abuse/linter.py

@@ -0,0 +1,183 @@
+"""
+Purpose: Main linter rule for detecting clone abuse in Rust code
+
+Scope: Entry point for clone abuse detection implementing BaseLintRule interface
+
+Overview: Provides CloneAbuseRule class that implements the BaseLintRule interface for
+    detecting .clone() abuse patterns in Rust code. Validates that files are Rust with
+    content, loads configuration, checks ignored paths, and delegates analysis to
+    RustCloneAnalyzer. Filters detected calls based on configuration (allow_in_tests,
+    pattern toggles, ignored paths) and converts remaining calls to Violation objects
+    via the violation builder. Supports disabling via configuration.
+
+Dependencies: BaseLintRule, RustCloneAnalyzer, CloneAbuseConfig, violation_builder
+
+Exports: CloneAbuseRule
+
+Interfaces: check(context: BaseLintContext) -> list[Violation]
+
+Implementation: Single-file analysis with config-driven filtering and tree-sitter-based detection
+"""
+
+from src.core.base import BaseLintContext, BaseLintRule
+from src.core.linter_utils import (
+    has_file_content,
+    is_ignored_path,
+    load_linter_config,
+    resolve_file_path,
+)
+from src.core.types import Violation
+
+from .config import CloneAbuseConfig
+from .rust_analyzer import CloneCall, RustCloneAnalyzer
+from .violation_builder import (
+    build_clone_chain_violation,
+    build_clone_in_loop_violation,
+    build_unnecessary_clone_violation,
+)
+
+_PATTERN_BUILDERS = {
+    "clone-in-loop": build_clone_in_loop_violation,
+    "clone-chain": build_clone_chain_violation,
+    "unnecessary-clone": build_unnecessary_clone_violation,
+}
+
+_PATTERN_CONFIG_KEYS = {
+    "clone-in-loop": "detect_clone_in_loop",
+    "clone-chain": "detect_clone_chain",
+    "unnecessary-clone": "detect_unnecessary_clone",
+}
+
+
+class CloneAbuseRule(BaseLintRule):
+    """Detects clone abuse patterns in Rust code."""
+
+    def __init__(self, config: CloneAbuseConfig | None = None) -> None:
+        """Initialize clone abuse rule.
+
+        Args:
+            config: Optional configuration override for testing
+        """
+        self._config_override = config
+        self._analyzer = RustCloneAnalyzer()
+
+    @property
+    def rule_id(self) -> str:
+        """Unique identifier for this rule."""
+        return "clone-abuse"
+
+    @property
+    def rule_name(self) -> str:
+        """Human-readable name for this rule."""
+        return "Rust Clone Abuse"
+
+    @property
+    def description(self) -> str:
+        """Description of what this rule checks."""
+        return (
+            "Detects .clone() abuse patterns in Rust code including clone in loops, "
+            "chained clones, and unnecessary clones. Suggests safer alternatives like "
+            "borrowing, Rc/Arc, or Cow patterns."
+        )
+
+    def check(self, context: BaseLintContext) -> list[Violation]:
+        """Check for clone abuse violations in a Rust file.
+
+        Args:
+            context: Lint context with file content and metadata
+
+        Returns:
+            List of violations found
+        """
+        config = self._get_config(context)
+        if not self._should_analyze(context, config):
+            return []
+
+        file_path = resolve_file_path(context)
+        calls = self._analyzer.find_clone_calls(context.file_content or "")
+        return self._build_violations(calls, config, file_path)
+
+    def _should_analyze(self, context: BaseLintContext, config: CloneAbuseConfig) -> bool:
+        """Determine if the file should be analyzed.
+
+        Args:
+            context: Lint context to check
+            config: Clone abuse configuration
+
+        Returns:
+            True if the file should be analyzed
+        """
+        if context.language != "rust":
+            return False
+        if not has_file_content(context):
+            return False
+        if not config.enabled:
+            return False
+        return not is_ignored_path(resolve_file_path(context), config.ignore)
+
+    def _get_config(self, context: BaseLintContext) -> CloneAbuseConfig:
+        """Load configuration from override or context metadata.
+
+        Args:
+            context: Lint context with metadata
+
+        Returns:
+            CloneAbuseConfig instance
+        """
+        if self._config_override is not None:
+            return self._config_override
+        return load_linter_config(context, "clone-abuse", CloneAbuseConfig)
+
+    def _build_violations(
+        self,
+        calls: list[CloneCall],
+        config: CloneAbuseConfig,
+        file_path: str,
+    ) -> list[Violation]:
+        """Convert clone calls to violations with config filtering.
+
+        Args:
+            calls: Detected clone calls from analyzer
+            config: Configuration for filtering
+            file_path: Path of the analyzed file
+
+        Returns:
+            List of filtered violations
+        """
+        return [
+            _build_violation_for_call(call, file_path)
+            for call in calls
+            if not _should_skip_call(call, config)
+        ]
+
+
+def _should_skip_call(call: CloneCall, config: CloneAbuseConfig) -> bool:
+    """Determine if a clone call should be skipped based on config.
+
+    Args:
+        call: Detected clone call
+        config: Configuration for filtering
+
+    Returns:
+        True if the call should be skipped
+    """
+    if call.is_in_test and config.allow_in_tests:
+        return True
+    config_key = _PATTERN_CONFIG_KEYS.get(call.pattern)
+    if config_key and not getattr(config, config_key):
+        return True
+    return False
+
+
+def _build_violation_for_call(call: CloneCall, file_path: str) -> Violation:
+    """Build a violation for a specific clone call.
+
+    Args:
+        call: Detected clone call with pattern info
+        file_path: Path of the analyzed file
+
+    Returns:
+        Violation instance
+    """
+    builder = _PATTERN_BUILDERS.get(call.pattern, build_clone_in_loop_violation)
+    return builder(file_path, call.line, call.column, call.context)

src/linters/clone_abuse/rust_analyzer.py

@@ -0,0 +1,356 @@
+"""
+Purpose: Analyzer for detecting clone abuse patterns in Rust code using tree-sitter AST
+
+Scope: Pattern detection for .clone() method calls including loop, chain, and unnecessary patterns
+
+Overview: Provides RustCloneAnalyzer that extends RustBaseAnalyzer to detect .clone() abuse
+    patterns in Rust code. Detects three patterns: clone-in-loop (clone calls inside for,
+    while, or loop bodies), clone-chain (chained .clone().clone() calls), and unnecessary-clone
+    (clone in let binding where the source identifier is not used again in the enclosing block).
+    Uses tree-sitter AST to find call_expression nodes with field_identifier matching "clone"
+    and classifies each call by walking the AST structure. Returns structured CloneCall dataclass
+    instances with location, pattern type, test context, and surrounding code for violation reporting.
+
+Dependencies: src.analyzers.rust_base for tree-sitter parsing and traversal
+
+Exports: RustCloneAnalyzer, CloneCall
+
+Interfaces: find_clone_calls(code: str) -> list[CloneCall]
+
+Implementation: Recursive AST traversal with pattern classification using parent-chain walking
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import TYPE_CHECKING
+
+from src.analyzers.rust_base import RustBaseAnalyzer
+from src.core.linter_utils import get_line_context
+
+if TYPE_CHECKING:
+    from tree_sitter import Node
+
+_LOOP_NODE_TYPES = frozenset({"for_expression", "while_expression", "loop_expression"})
+
+
+@dataclass
+class CloneCall:
+    """Represents a detected clone call with its abuse pattern."""
+
+    line: int
+    column: int
+    pattern: str  # "clone-in-loop", "clone-chain", "unnecessary-clone"
+    is_in_test: bool
+    context: str  # Surrounding code snippet
+
+
+class RustCloneAnalyzer(RustBaseAnalyzer):
+    """Analyzer for detecting clone abuse patterns in Rust code."""
+
+    def find_clone_calls(self, code: str) -> list[CloneCall]:
+        """Find all abusive .clone() calls in code.
+
+        Args:
+            code: Rust source code to analyze
+
+        Returns:
+            List of detected clone calls with pattern classification
+        """
+        if not self.tree_sitter_available:
+            return []
+
+        root = self.parse_rust(code)
+        if root is None:
+            return []
+
+        calls: list[CloneCall] = []
+        self._find_clone_recursive(root, code, calls)
+        return calls
+
+    def _find_clone_recursive(self, node: Node, code: str, calls: list[CloneCall]) -> None:
+        """Recursively find abusive clone calls in AST.
+
+        Args:
+            node: Current tree-sitter node to inspect
+            code: Original source code for context extraction
+            calls: Accumulator list for detected calls
+        """
+        if node.type == "call_expression":
+            method_name = self._get_method_name(node)
+            if method_name == "clone":
+                pattern = self._classify_clone(node, code)
+                if pattern is not None:
+                    calls.append(
+                        CloneCall(
+                            line=node.start_point[0] + 1,
+                            column=node.start_point[1],
+                            pattern=pattern,
+                            is_in_test=self.is_inside_test(node),
+                            context=get_line_context(code, node.start_point[0]),
+                        )
+                    )
+
+        for child in node.children:
+            self._find_clone_recursive(child, code, calls)
+
+    def _get_method_name(self, call_node: Node) -> str:
+        """Extract method name from a call expression.
+
+        Args:
+            call_node: A call_expression node
+
+        Returns:
+            Method name string, or empty string if not a method call
+        """
+        for child in call_node.children:
+            if child.type == "field_expression":
+                return self._extract_field_identifier(child)
+        return ""
+
+    def _extract_field_identifier(self, field_expr: Node) -> str:
+        """Extract the field identifier from a field expression.
+
+        Args:
+            field_expr: A field_expression node
+
+        Returns:
+            The field identifier text (e.g., "clone")
+        """
+        for subchild in field_expr.children:
+            if subchild.type == "field_identifier":
+                return self.extract_node_text(subchild)
+        return ""
+
+    def _classify_clone(self, node: Node, code: str) -> str | None:
+        """Classify a clone call into an abuse pattern.
+
+        Checks patterns in priority order: chain, loop, unnecessary.
+        Returns None if the clone does not match any abuse pattern.
+
+        Args:
+            node: The call_expression node for the .clone() call
+            code: Original source code
+
+        Returns:
+            Pattern string or None if not abusive
+        """
+        _ = code
+        if self._is_chained_clone(node):
+            return "clone-chain"
+        if self._is_inside_loop(node):
+            return "clone-in-loop"
+        if self._is_unnecessary_clone(node):
+            return "unnecessary-clone"
+        return None
+
+    def _is_inside_loop(self, node: Node) -> bool:
+        """Check if node is inside a loop body.
+
+        Walks the parent chain looking for loop node types.
+
+        Args:
+            node: Node to check
+
+        Returns:
+            True if inside a for, while, or loop expression
+        """
+        current: Node | None = node.parent
+        while current is not None:
+            if current.type in _LOOP_NODE_TYPES:
+                return True
+            current = current.parent
+        return False
+
+    def _is_chained_clone(self, node: Node) -> bool:
+        """Check if this clone's receiver is itself a .clone() call.
+
+        Detects patterns like data.clone().clone() where the outer clone's
+        receiver (via field_expression) is a call_expression with method "clone".
+
+        Args:
+            node: The call_expression node for this .clone() call
+
+        Returns:
+            True if this clone is chained on another clone
+        """
+        field_expr = _get_field_expression(node)
+        if field_expr is None:
+            return False
+        receiver = _get_receiver_node(field_expr)
+        if receiver is None or receiver.type != "call_expression":
+            return False
+        return self._get_method_name(receiver) == "clone"
+
+    def _is_unnecessary_clone(self, node: Node) -> bool:
+        """Check if clone is unnecessary (source not used after cloning).
+
+        Only flags when ALL conditions are met:
+        - The clone is in a let declaration: let x = y.clone();
+        - The receiver y is a simple identifier (not self.field, not foo.bar())
+        - y does not appear in any subsequent statement in the same block
+
+        Args:
+            node: The call_expression node for this .clone() call
+
+        Returns:
+            True if the clone appears unnecessary
+        """
+        let_node = _find_parent_let_declaration(node)
+        if let_node is None:
+            return False
+
+        identifier = self._get_clone_receiver_identifier(node)
+        if identifier is None:
+            return False
+
+        block_node = _find_parent_block(let_node)
+        if block_node is None:
+            return False
+
+        return not _identifier_used_after(identifier, let_node, block_node)
+
+    def _get_clone_receiver_identifier(self, node: Node) -> str | None:
+        """Extract the simple identifier being cloned.
+
+        Returns None for complex expressions like self.field or foo.bar().
+
+        Args:
+            node: The call_expression node for this .clone() call
+
+        Returns:
+            Simple identifier string, or None for complex receivers
+        """
+        field_expr = _get_field_expression(node)
+        if field_expr is None:
+            return None
+        receiver = _get_receiver_node(field_expr)
+        if receiver is None:
+            return None
+        if receiver.type != "identifier":
+            return None
+        return self.extract_node_text(receiver)
+
+
+def _get_field_expression(call_node: Node) -> Node | None:
+    """Get the field_expression child of a call_expression.
+
+    Args:
+        call_node: A call_expression node
+
+    Returns:
+        The field_expression child, or None
+    """
+    for child in call_node.children:
+        if child.type == "field_expression":
+            return child
+    return None
+
+
+def _get_receiver_node(field_expr: Node) -> Node | None:
+    """Get the receiver (first child) of a field_expression.
+
+    In Rust tree-sitter, field_expression children are:
+    [receiver, ".", field_identifier]
+
+    Args:
+        field_expr: A field_expression node
+
+    Returns:
+        The receiver node, or None
+    """
+    children = field_expr.children
+    if children:
+        return children[0]
+    return None
+
+
+def _find_parent_let_declaration(node: Node) -> Node | None:
+    """Find the enclosing let_declaration for a node.
+
+    Args:
+        node: Starting node to search from
+
+    Returns:
+        The let_declaration node, or None if not inside one
+    """
+    current: Node | None = node.parent
+    while current is not None:
+        if current.type == "let_declaration":
+            return current
+        if current.type in ("block", "function_item"):
+            return None
+        current = current.parent
+    return None
+
+
+def _find_parent_block(node: Node) -> Node | None:
+    """Find the enclosing block for a node.
+
+    Args:
+        node: Starting node to search from
+
+    Returns:
+        The block node, or None
+    """
+    current: Node | None = node.parent
+    while current is not None:
+        if current.type == "block":
+            return current
+        current = current.parent
+    return None
+
+
+def _identifier_used_after(identifier: str, let_node: Node, block_node: Node) -> bool:
+    """Check if identifier appears in statements after let_node in the block.
+
+    Scans subsequent siblings of let_node within block_node for any reference
+    to the given identifier.
+
+    Args:
+        identifier: The variable name to search for
+        let_node: The let_declaration node
+        block_node: The enclosing block node
+
+    Returns:
+        True if identifier is referenced after the let_node
+    """
+    found_let = False
+    for child in block_node.children:
+        if child.id == let_node.id:
+            found_let = True
+            continue
+        if found_let and _node_contains_identifier(child, identifier):
+            return True
+    return False
+
+
+def _node_contains_identifier(node: Node, identifier: str) -> bool:
+    """Recursively check if a node or its descendants contain an identifier reference.
+
+    Args:
+        node: Node to search in
+        identifier: Identifier name to look for
+
+    Returns:
+        True if the identifier is found
+    """
+    if _is_matching_identifier(node, identifier):
+        return True
+    return any(_node_contains_identifier(child, identifier) for child in node.children)
+
+
+def _is_matching_identifier(node: Node, identifier: str) -> bool:
+    """Check if a node is an identifier matching the given name.
+
+    Args:
+        node: Node to check
+        identifier: Expected identifier name
+
+    Returns:
+        True if node is an identifier with the given name
+    """
+    if node.type != "identifier":
+        return False
+    text = node.text
+    return text is not None and text.decode() == identifier

src/linters/clone_abuse/violation_builder.py

@@ -0,0 +1,94 @@
+"""
+Purpose: Build Violation objects for Rust clone abuse patterns
+
+Scope: Creates violations with actionable suggestions for clone-in-loop, clone-chain,
+    and unnecessary-clone patterns
+
+Overview: Provides module-level functions that create Violation objects for detected
+    .clone() abuse patterns in Rust code. Each violation includes the rule ID, location,
+    descriptive message explaining the performance or correctness impact, and a suggestion
+    for safer alternatives such as borrowing, Rc/Arc for shared ownership, or Cow for
+    clone-on-write patterns.
+
+Dependencies: src.core.types for Violation dataclass
+
+Exports: build_clone_in_loop_violation, build_clone_chain_violation, build_unnecessary_clone_violation
+
+Interfaces: Module functions taking file_path, line, column, context and returning Violation
+
+Implementation: Factory functions for each clone abuse pattern with pattern-specific suggestions
+"""
+
+from src.core.types import Violation
+
+_CLONE_IN_LOOP_SUGGESTION = (
+    "Consider borrowing instead of cloning in a loop. "
+    "If ownership is needed, use Rc/Arc for shared ownership or collect references."
+)
+
+_CLONE_CHAIN_SUGGESTION = (
+    "Chained .clone().clone() is redundant. "
+    "A single .clone() produces an owned copy; the second clone is unnecessary."
+)
+
+_UNNECESSARY_CLONE_SUGGESTION = (
+    "This .clone() may be unnecessary if the original value is not used after cloning. "
+    "Consider passing ownership directly, borrowing, or using Cow for clone-on-write."
+)
+
+
+def build_clone_in_loop_violation(
+    file_path: str,
+    line: int,
+    column: int,
+    context: str,
+) -> Violation:
+    """Build a violation for .clone() call inside a loop body."""
+    message = f".clone() called inside a loop body may cause performance issues: {context}"
+
+    return Violation(
+        rule_id="clone-abuse.clone-in-loop",
+        file_path=file_path,
+        line=line,
+        column=column,
+        message=message,
+        suggestion=_CLONE_IN_LOOP_SUGGESTION,
+    )
+
+
+def build_clone_chain_violation(
+    file_path: str,
+    line: int,
+    column: int,
+    context: str,
+) -> Violation:
+    """Build a violation for chained .clone().clone() calls."""
+    message = f"Chained .clone().clone() is redundant: {context}"
+
+    return Violation(
+        rule_id="clone-abuse.clone-chain",
+        file_path=file_path,
+        line=line,
+        column=column,
+        message=message,
+        suggestion=_CLONE_CHAIN_SUGGESTION,
+    )
+
+
+def build_unnecessary_clone_violation(
+    file_path: str,
+    line: int,
+    column: int,
+    context: str,
+) -> Violation:
+    """Build a violation for unnecessary .clone() before move."""
+    message = f".clone() may be unnecessary when the original is not used afterward: {context}"
+
+    return Violation(
+        rule_id="clone-abuse.unnecessary-clone",
+        file_path=file_path,
+        line=line,
+        column=column,
+        message=message,
+        suggestion=_UNNECESSARY_CLONE_SUGGESTION,
+    )