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

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,
+    )

src/linters/magic_numbers/linter.py

@@ -32,6 +32,7 @@ import ast
 from pathlib import Path
 from typing import Any
 
+from src.analyzers.rust_base import TREE_SITTER_RUST_AVAILABLE
 from src.core.base import BaseLintContext, MultiLanguageLintRule
 from src.core.linter_utils import load_linter_config
 from src.core.types import Violation
@@ -42,6 +43,7 @@ from .config import MagicNumberConfig
 from .context_analyzer import is_acceptable_context
 from .definition_detector import is_definition_file
 from .python_analyzer import PythonMagicNumberAnalyzer
+from .rust_analyzer import RustMagicNumberAnalyzer
 from .typescript_analyzer import TypeScriptMagicNumberAnalyzer
 from .typescript_ignore_checker import TypeScriptIgnoreChecker
 from .violation_builder import ViolationBuilder
@@ -456,6 +458,96 @@ class MagicNumberRule(MultiLanguageLintRule):  # thailint: ignore[srp]
             for pattern in [".test.", ".spec.", "test_", "_test.", "/tests/", "/test/"]
         )
 
+    def _check_rust(self, context: BaseLintContext, config: MagicNumberConfig) -> list[Violation]:
+        """Check Rust code for magic number violations.
+
+        Args:
+            context: Lint context with Rust file information
+            config: Magic numbers configuration
+
+        Returns:
+            List of violations found in Rust code
+        """
+        if not TREE_SITTER_RUST_AVAILABLE:
+            return []
+
+        if self._is_file_ignored(context, config):
+            return []
+
+        analyzer = RustMagicNumberAnalyzer()
+        root_node = analyzer.parse_rust(context.file_content or "")
+        if root_node is None:
+            return []
+
+        numeric_literals = analyzer.find_numeric_literals(root_node)
+        return self._collect_rust_violations(numeric_literals, context, config, analyzer)
+
+    def _collect_rust_violations(
+        self,
+        numeric_literals: list,
+        context: BaseLintContext,
+        config: MagicNumberConfig,
+        analyzer: RustMagicNumberAnalyzer,
+    ) -> list[Violation]:
+        """Collect violations from Rust numeric literals.
+
+        Args:
+            numeric_literals: List of (node, value, line_number) tuples
+            context: Lint context
+            config: Configuration
+            analyzer: Rust analyzer instance
+
+        Returns:
+            List of violations
+        """
+        violations = []
+        for node, value, line_number in numeric_literals:
+            violation = self._try_create_rust_violation(
+                node, value, line_number, context, config, analyzer
+            )
+            if violation is not None:
+                violations.append(violation)
+        return violations
+
+    def _try_create_rust_violation(  # pylint: disable=too-many-arguments,too-many-positional-arguments
+        self,
+        node: object,
+        value: float | int,
+        line_number: int,
+        context: BaseLintContext,
+        config: MagicNumberConfig,
+        analyzer: RustMagicNumberAnalyzer,
+    ) -> Violation | None:
+        """Try to create a violation for a Rust numeric literal.
+
+        Args:
+            node: Tree-sitter node
+            value: Numeric value
+            line_number: Line number of literal
+            context: Lint context
+            config: Configuration
+            analyzer: Rust analyzer
+
+        Returns:
+            Violation or None if should not flag
+        """
+        if value in config.allowed_numbers:
+            return None
+
+        if analyzer.is_constant_definition(node):
+            return None
+
+        if analyzer.is_test_context(node):
+            return None
+
+        violation = self._violation_builder.create_rust_violation(
+            value, line_number, context.file_path
+        )
+        if self._should_ignore(violation, context):
+            return None
+
+        return violation
+
     def _should_ignore_typescript(self, violation: Violation, context: BaseLintContext) -> bool:
         """Check if TypeScript violation should be ignored.
 

src/linters/magic_numbers/rust_analyzer.py

@@ -0,0 +1,148 @@
+"""
+Purpose: Rust magic number detection using tree-sitter AST analysis
+
+Scope: Tree-sitter based numeric literal detection for Rust code
+
+Overview: Analyzes Rust code to detect numeric literals that should be extracted to named
+    constants. Uses tree-sitter parser to traverse Rust AST and identify integer_literal
+    and float_literal nodes with their line numbers and values. Detects acceptable contexts
+    such as const/static definitions and UPPERCASE constant declarations to avoid false
+    positives. Handles Rust-specific syntax including const items, static items, and
+    array/slice indexing.
+
+Dependencies: RustBaseAnalyzer for tree-sitter parsing, TREE_SITTER_RUST_AVAILABLE
+
+Exports: RustMagicNumberAnalyzer class with find_numeric_literals and context detection
+
+Interfaces: find_numeric_literals(root_node) -> list[tuple], is_constant_definition(node)
+
+Implementation: Tree-sitter node traversal with visitor pattern, context-aware filtering
+"""
+
+from typing import Any
+
+from src.analyzers.rust_base import TREE_SITTER_RUST_AVAILABLE, RustBaseAnalyzer
+
+
+class RustMagicNumberAnalyzer(RustBaseAnalyzer):
+    """Analyzes Rust code for magic numbers using tree-sitter."""
+
+    # Node types that represent numeric literals in Rust
+    NUMERIC_LITERAL_TYPES = {"integer_literal", "float_literal"}
+
+    def find_numeric_literals(self, root_node: Any) -> list[tuple[Any, float | int, int]]:
+        """Find all numeric literal nodes in Rust AST.
+
+        Args:
+            root_node: Root tree-sitter node to search from
+
+        Returns:
+            List of (node, value, line_number) tuples for each numeric literal
+        """
+        if not TREE_SITTER_RUST_AVAILABLE or root_node is None:
+            return []
+
+        literals: list[tuple[Any, float | int, int]] = []
+        self._collect_numeric_literals(root_node, literals)
+        return literals
+
+    def _collect_numeric_literals(
+        self, node: Any, literals: list[tuple[Any, float | int, int]]
+    ) -> None:
+        """Recursively collect numeric literals from AST.
+
+        Args:
+            node: Current tree-sitter node
+            literals: List to accumulate found literals
+        """
+        if node.type in self.NUMERIC_LITERAL_TYPES:
+            value = self._extract_numeric_value(node)
+            if value is not None:
+                line_number = node.start_point[0] + 1
+                literals.append((node, value, line_number))
+
+        for child in node.children:
+            self._collect_numeric_literals(child, literals)
+
+    def _extract_numeric_value(self, node: Any) -> float | int | None:
+        """Extract numeric value from a literal node.
+
+        Handles Rust integer suffixes (i32, u64, etc.) and various formats.
+
+        Args:
+            node: Tree-sitter numeric literal node
+
+        Returns:
+            Numeric value (int or float) or None if parsing fails
+        """
+        text = self.extract_node_text(node)
+        # Strip Rust type suffixes (i32, u64, f64, usize, etc.)
+        cleaned = self._strip_type_suffix(text)
+        # Strip underscores used as visual separators (e.g., 1_000_000)
+        cleaned = cleaned.replace("_", "")
+        try:
+            if node.type == "float_literal":
+                return float(cleaned)
+            return int(cleaned, 0)  # Handles hex, octal, binary
+        except (ValueError, TypeError):
+            return None
+
+    def _strip_type_suffix(self, text: str) -> str:
+        """Strip Rust numeric type suffixes from literal text.
+
+        Args:
+            text: Raw literal text (e.g., "42i32", "3.14f64")
+
+        Returns:
+            Text with suffix removed
+        """
+        suffixes = (
+            "u8",
+            "u16",
+            "u32",
+            "u64",
+            "u128",
+            "usize",
+            "i8",
+            "i16",
+            "i32",
+            "i64",
+            "i128",
+            "isize",
+            "f32",
+            "f64",
+        )
+        for suffix in suffixes:
+            if text.endswith(suffix):
+                return text[: -len(suffix)]
+        return text
+
+    def is_constant_definition(self, node: Any) -> bool:
+        """Check if numeric literal is in a const or static definition.
+
+        Args:
+            node: Numeric literal node
+
+        Returns:
+            True if inside const_item or static_item
+        """
+        if not TREE_SITTER_RUST_AVAILABLE:
+            return False
+
+        current = node.parent
+        while current is not None:
+            if current.type in ("const_item", "static_item"):
+                return True
+            current = current.parent
+        return False
+
+    def is_test_context(self, node: Any) -> bool:
+        """Check if numeric literal is inside test code.
+
+        Args:
+            node: Numeric literal node
+
+        Returns:
+            True if inside #[test] function or #[cfg(test)] module
+        """
+        return self.is_inside_test(node)

src/linters/magic_numbers/violation_builder.py

@@ -68,6 +68,37 @@ class ViolationBuilder:
             suggestion=suggestion,
         )
 
+    def create_rust_violation(
+        self,
+        value: int | float,
+        line: int,
+        file_path: Path | None,
+    ) -> Violation:
+        """Create a violation for a Rust magic number.
+
+        Args:
+            value: The numeric value
+            line: Line number where the violation occurs
+            file_path: Path to the file
+
+        Returns:
+            Violation object with details about the magic number
+        """
+        message = f"Magic number {value} should be a named constant"
+
+        suggestion = (
+            f"Extract {value} to a named constant (e.g., const CONSTANT_NAME: i32 = {value})"
+        )
+
+        return Violation(
+            rule_id=self.rule_id,
+            file_path=str(file_path) if file_path else "",
+            line=line,
+            column=0,
+            message=message,
+            suggestion=suggestion,
+        )
+
     def create_typescript_violation(
         self,
         value: int | float,

src/linters/nesting/linter.py

@@ -21,6 +21,7 @@ Implementation: Composition pattern with helper classes, AST-based analysis with
 
 from typing import Any
 
+from src.analyzers.rust_base import TREE_SITTER_RUST_AVAILABLE
 from src.core.base import BaseLintContext, MultiLanguageLintRule
 from src.core.linter_utils import load_linter_config, with_parsed_python
 from src.core.types import Violation
@@ -28,6 +29,7 @@ from src.linter_config.ignore import get_ignore_parser
 
 from .config import NestingConfig
 from .python_analyzer import PythonNestingAnalyzer
+from .rust_analyzer import RustNestingAnalyzer
 from .typescript_analyzer import TypeScriptNestingAnalyzer
 from .violation_builder import NestingViolationBuilder
 
@@ -42,6 +44,7 @@ class NestingDepthRule(MultiLanguageLintRule):
         # Singleton analyzers for performance (avoid recreating per-file)
         self._python_analyzer = PythonNestingAnalyzer()
         self._typescript_analyzer = TypeScriptNestingAnalyzer()
+        self._rust_analyzer = RustNestingAnalyzer()
 
     @property
     def rule_id(self) -> str:
@@ -165,6 +168,53 @@ class NestingDepthRule(MultiLanguageLintRule):
             functions, self._typescript_analyzer, config, context
         )
 
+    def _check_rust(self, context: BaseLintContext, config: NestingConfig) -> list[Violation]:
+        """Check Rust code for nesting violations.
+
+        Args:
+            context: Lint context with Rust file information
+            config: Nesting configuration
+
+        Returns:
+            List of violations found in Rust code
+        """
+        if not TREE_SITTER_RUST_AVAILABLE:
+            return []
+
+        root_node = self._rust_analyzer.parse_rust(context.file_content or "")
+        if root_node is None:
+            return []
+
+        functions = self._rust_analyzer.find_all_functions(root_node)
+        return self._process_rust_functions(functions, config, context)
+
+    def _process_rust_functions(
+        self, functions: list, config: NestingConfig, context: BaseLintContext
+    ) -> list[Violation]:
+        """Process Rust functions and collect violations.
+
+        Args:
+            functions: List of (function_node, function_name) tuples
+            config: Nesting configuration
+            context: Lint context
+
+        Returns:
+            List of violations
+        """
+        violations = []
+        for func_node, func_name in functions:
+            max_depth, _line = self._rust_analyzer.calculate_max_depth(func_node)
+            if max_depth <= config.max_nesting_depth:
+                continue
+
+            violation = self._violation_builder.create_rust_nesting_violation(
+                (func_node, func_name), max_depth, config, context
+            )
+            # dry: ignore-block - Standard linter pattern (check-ignore-append)
+            if not self._should_ignore(violation, context):
+                violations.append(violation)
+        return violations
+
     def _should_ignore(self, violation: Violation, context: BaseLintContext) -> bool:
         """Check if violation should be ignored based on inline directives.
 

src/linters/nesting/rust_analyzer.py

@@ -0,0 +1,118 @@
+"""
+Purpose: Rust AST-based nesting depth calculator
+
+Scope: Rust code nesting depth analysis using tree-sitter parser
+
+Overview: Analyzes Rust code to calculate maximum nesting depth using AST traversal.
+    Extends RustBaseAnalyzer to reuse common tree-sitter initialization and parsing.
+    Implements visitor pattern to walk Rust AST, tracking current depth and maximum
+    depth found. Increments depth for control flow statements (if, match, loop, while,
+    for) and closures. Returns maximum depth and location for each function.
+
+Dependencies: RustBaseAnalyzer, TREE_SITTER_RUST_AVAILABLE
+
+Exports: RustNestingAnalyzer class with calculate_max_depth and find_all_functions
+
+Interfaces: calculate_max_depth(func_node) -> tuple[int, int], find_all_functions(root_node)
+
+Implementation: Inherits tree-sitter parsing from base, visitor pattern with depth tracking
+"""
+
+from typing import Any
+
+from src.analyzers.rust_base import TREE_SITTER_RUST_AVAILABLE, RustBaseAnalyzer
+
+
+class RustNestingAnalyzer(RustBaseAnalyzer):
+    """Calculates maximum nesting depth in Rust functions."""
+
+    # Tree-sitter node types that increase nesting depth
+    NESTING_NODE_TYPES = {
+        "if_expression",
+        "match_expression",
+        "loop_expression",
+        "while_expression",
+        "for_expression",
+        "closure_expression",
+    }
+
+    def calculate_max_depth(self, func_node: Any) -> tuple[int, int]:
+        """Calculate maximum nesting depth in a Rust function.
+
+        Args:
+            func_node: Function item AST node
+
+        Returns:
+            Tuple of (max_depth, line_number)
+        """
+        if not TREE_SITTER_RUST_AVAILABLE:
+            return 0, 0
+
+        body_node = self._find_function_body(func_node)
+        if not body_node:
+            return 0, func_node.start_point[0] + 1
+
+        max_depth = 0
+        max_depth_line = body_node.start_point[0] + 1
+
+        def visit_node(node: Any, current_depth: int = 0) -> None:
+            nonlocal max_depth, max_depth_line
+
+            if current_depth > max_depth:
+                max_depth = current_depth
+                max_depth_line = node.start_point[0] + 1
+
+            new_depth = current_depth + 1 if node.type in self.NESTING_NODE_TYPES else current_depth
+
+            for child in node.children:
+                visit_node(child, new_depth)
+
+        # Start at depth 1 for function body children
+        for child in body_node.children:
+            visit_node(child, 1)
+
+        return max_depth, max_depth_line
+
+    def find_all_functions(self, root_node: Any) -> list[tuple[Any, str]]:
+        """Find all function definitions in Rust AST.
+
+        Args:
+            root_node: Root node to search from
+
+        Returns:
+            List of (function_node, function_name) tuples
+        """
+        if not TREE_SITTER_RUST_AVAILABLE or root_node is None:
+            return []
+
+        functions: list[tuple[Any, str]] = []
+        self._collect_functions_recursive(root_node, functions)
+        return functions
+
+    def _collect_functions_recursive(self, node: Any, functions: list[tuple[Any, str]]) -> None:
+        """Recursively collect function nodes from Rust AST.
+
+        Args:
+            node: Current node to examine
+            functions: List to append found functions to
+        """
+        if node.type == "function_item":
+            name = self.extract_identifier_name(node)
+            functions.append((node, name))
+
+        for child in node.children:
+            self._collect_functions_recursive(child, functions)
+
+    def _find_function_body(self, func_node: Any) -> Any:
+        """Find the block node (function body) in a function item.
+
+        Args:
+            func_node: Function item node to search
+
+        Returns:
+            Block node or None
+        """
+        for child in func_node.children:
+            if child.type == "block":
+                return child
+        return None

src/linters/nesting/violation_builder.py

@@ -123,6 +123,38 @@ class NestingViolationBuilder(BaseViolationBuilder):
             suggestion=self._generate_suggestion(max_depth, config.max_nesting_depth),
         )
 
+    def create_rust_nesting_violation(
+        self,
+        func_info: tuple[Any, str],
+        max_depth: int,
+        config: NestingConfig,
+        context: BaseLintContext,
+    ) -> Violation:
+        """Create violation for excessive nesting in Rust function.
+
+        Args:
+            func_info: Tuple of (func_node, func_name)
+            max_depth: Actual max nesting depth found
+            config: Nesting configuration
+            context: Lint context
+
+        Returns:
+            Nesting depth violation
+        """
+        func_node, func_name = func_info
+        line = func_node.start_point[0] + 1  # Convert to 1-indexed
+        column = func_node.start_point[1]
+
+        return self.build_from_params(
+            rule_id=self.rule_id,
+            file_path=str(context.file_path or ""),
+            line=line,
+            column=column,
+            message=f"Function '{func_name}' has excessive nesting depth ({max_depth})",
+            severity=Severity.ERROR,
+            suggestion=self._generate_suggestion(max_depth, config.max_nesting_depth),
+        )
+
     def _generate_suggestion(self, actual_depth: int, max_depth: int) -> str:
         """Generate refactoring suggestion based on depth.
 

src/linters/print_statements/__init__.py

@@ -1,33 +1,45 @@
 """
 File: src/linters/print_statements/__init__.py
 
-Purpose: Print statements linter package exports and convenience functions
+Purpose: Improper logging linter package exports and convenience functions
 
-Exports: PrintStatementRule class, PrintStatementConfig dataclass, lint() convenience function
+Exports: PrintStatementRule, ConditionalVerboseRule classes, PrintStatementConfig dataclass,
+    lint() convenience function, ImproperLoggingPrintRule alias
 
-Depends: .linter for PrintStatementRule, .config for PrintStatementConfig
+Depends: .linter for PrintStatementRule, .conditional_verbose_rule for ConditionalVerboseRule,
+    .config for PrintStatementConfig
 
 Implements: lint(file_path, config) -> list[Violation] for simple linting operations
 
 Related: src/linters/magic_numbers/__init__.py, src/core/base.py
 
-Overview: Provides the public interface for the print statements linter package. Exports main
-    PrintStatementRule class for use by the orchestrator and PrintStatementConfig for configuration.
-    Includes lint() convenience function that provides a simple API for running the print statements
-    linter on a file without directly interacting with the orchestrator. This module serves as the
-    entry point for users of the print statements linter, hiding implementation details and exposing
-    only the essential components needed for linting operations.
+Overview: Provides the public interface for the improper logging linter package (formerly
+    print-statements). Exports PrintStatementRule for detecting print/console statements and
+    ConditionalVerboseRule for detecting conditional verbose logging anti-patterns. Both rules
+    use rule IDs prefixed with 'improper-logging.' for unified filtering. Includes lint()
+    convenience function for simple API usage without the orchestrator. ImproperLoggingPrintRule
+    is provided as an alias for PrintStatementRule for semantic clarity.
 
-Usage: from src.linters.print_statements import PrintStatementRule, lint
+Usage: from src.linters.print_statements import PrintStatementRule, ConditionalVerboseRule, lint
     violations = lint("path/to/file.py")
 
 Notes: Module-level exports with __all__ definition, convenience function wrapper
 """
 
+from .conditional_verbose_rule import ConditionalVerboseRule
 from .config import PrintStatementConfig
 from .linter import PrintStatementRule
 
-__all__ = ["PrintStatementRule", "PrintStatementConfig", "lint"]
+# Alias for semantic clarity (both detect improper logging patterns)
+ImproperLoggingPrintRule = PrintStatementRule
+
+__all__ = [
+    "PrintStatementRule",
+    "ConditionalVerboseRule",
+    "PrintStatementConfig",
+    "ImproperLoggingPrintRule",
+    "lint",
+]
 
 
 def lint(file_path: str, config: dict | None = None) -> list: