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

src/linters/srp/rust_analyzer.py

@@ -0,0 +1,206 @@
+"""
+Purpose: Rust AST analyzer for detecting SRP violations in Rust structs
+
+Scope: RustSRPAnalyzer class for analyzing Rust struct + impl block patterns using tree-sitter
+
+Overview: Implements Rust-specific SRP analysis using tree-sitter parser. Extends
+    RustBaseAnalyzer to reuse common tree-sitter initialization and traversal patterns.
+    Walks the AST to find all struct declarations and impl blocks. Matches impl blocks
+    to their corresponding structs by type identifier name. Counts methods across all
+    impl blocks for a given struct and calculates total lines of code. Collects
+    comprehensive metrics including struct name, method count, LOC, keyword presence,
+    and location information. In Rust, a struct + its impl blocks is analogous to a
+    class in other languages for SRP analysis purposes.
+
+Dependencies: RustBaseAnalyzer, SRPConfig
+
+Exports: RustSRPAnalyzer class
+
+Interfaces: find_all_structs(root_node), analyze_struct(struct_node, impl_blocks, source, config)
+
+Implementation: Inherits tree-sitter parsing from base, aggregates methods across impl blocks
+"""
+
+from typing import Any
+
+from src.analyzers.rust_base import RustBaseAnalyzer
+
+from .config import SRPConfig
+
+
+class RustSRPAnalyzer(RustBaseAnalyzer):
+    """Analyzes Rust structs and impl blocks for SRP violations."""
+
+    def find_all_structs(self, root_node: Any) -> list[Any]:
+        """Find all struct declarations in Rust AST.
+
+        Args:
+            root_node: Root tree-sitter node to search
+
+        Returns:
+            List of all struct_item nodes
+        """
+        return self.walk_tree(root_node, "struct_item")
+
+    def find_all_impl_blocks(self, root_node: Any) -> list[Any]:
+        """Find all impl blocks in Rust AST.
+
+        Args:
+            root_node: Root tree-sitter node to search
+
+        Returns:
+            List of all impl_item nodes
+        """
+        return self.walk_tree(root_node, "impl_item")
+
+    def get_impl_target_name(self, impl_node: Any) -> str:
+        """Extract the type name that an impl block targets.
+
+        Args:
+            impl_node: An impl_item tree-sitter node
+
+        Returns:
+            The type identifier name (e.g., "Foo" from "impl Foo {}")
+        """
+        for child in impl_node.children:
+            if child.type == "type_identifier":
+                return self.extract_node_text(child)
+        return ""
+
+    def count_impl_methods(self, impl_node: Any) -> int:
+        """Count function items (methods) in an impl block.
+
+        Counts all function_item children that are public (not prefixed with _).
+
+        Args:
+            impl_node: An impl_item tree-sitter node
+
+        Returns:
+            Number of public methods in the impl block
+        """
+        declaration_list = self._find_declaration_list(impl_node)
+        if declaration_list is None:
+            return 0
+
+        count = 0
+        for child in declaration_list.children:
+            if child.type == "function_item" and self._is_countable_method(child):
+                count += 1
+        return count
+
+    def analyze_struct(
+        self,
+        struct_node: Any,
+        impl_blocks: list[Any],
+        source: str,
+        config: SRPConfig,
+    ) -> dict[str, Any]:
+        """Analyze a Rust struct and its impl blocks for SRP metrics.
+
+        Args:
+            struct_node: Tree-sitter node representing a struct declaration
+            impl_blocks: List of impl_item nodes targeting this struct
+            source: Full source code of the file
+            config: SRP configuration with thresholds and keywords
+
+        Returns:
+            Dictionary with struct metrics (class_name, method_count, loc, etc.)
+        """
+        struct_name = self._extract_type_name(struct_node)
+        method_count = self._count_total_methods(impl_blocks)
+        loc = self._calculate_loc(struct_node, impl_blocks, source)
+        has_keyword = any(keyword in struct_name for keyword in config.keywords)
+
+        return {
+            "class_name": struct_name,
+            "method_count": method_count,
+            "loc": loc,
+            "has_keyword": has_keyword,
+            "line": struct_node.start_point[0] + 1,
+            "column": struct_node.start_point[1],
+        }
+
+    def _count_total_methods(self, impl_blocks: list[Any]) -> int:
+        """Count methods across all impl blocks.
+
+        Args:
+            impl_blocks: List of impl_item nodes for a struct
+
+        Returns:
+            Total public method count
+        """
+        return sum(self.count_impl_methods(impl_node) for impl_node in impl_blocks)
+
+    def _calculate_loc(self, struct_node: Any, impl_blocks: list[Any], source: str) -> int:
+        """Calculate lines of code for struct and its impl blocks.
+
+        Args:
+            struct_node: Struct declaration node
+            impl_blocks: List of impl blocks for this struct
+            source: Full source code
+
+        Returns:
+            Total lines of code
+        """
+        struct_loc = self._node_loc(struct_node, source)
+        impl_loc = sum(self._node_loc(impl_node, source) for impl_node in impl_blocks)
+        return struct_loc + impl_loc
+
+    def _node_loc(self, node: Any, source: str) -> int:
+        """Calculate lines of code for a single node.
+
+        Args:
+            node: Tree-sitter node
+            source: Full source code
+
+        Returns:
+            Number of non-blank, non-comment lines
+        """
+        start_line = node.start_point[0]
+        end_line = node.end_point[0]
+        lines = source.split("\n")[start_line : end_line + 1]
+        return sum(1 for line in lines if line.strip() and not line.strip().startswith("//"))
+
+    def _find_declaration_list(self, impl_node: Any) -> Any:
+        """Find the declaration_list node in an impl block.
+
+        Args:
+            impl_node: An impl_item tree-sitter node
+
+        Returns:
+            The declaration_list child node or None
+        """
+        for child in impl_node.children:
+            if child.type == "declaration_list":
+                return child
+        return None
+
+    def _extract_type_name(self, node: Any) -> str:
+        """Extract type name from a struct or impl node.
+
+        Rust struct declarations use type_identifier instead of identifier.
+
+        Args:
+            node: A struct_item or impl_item tree-sitter node
+
+        Returns:
+            The type name or "anonymous" fallback
+        """
+        for child in node.children:
+            if child.type == "type_identifier":
+                return self.extract_node_text(child)
+        return self.extract_identifier_name(node)
+
+    def _is_countable_method(self, func_node: Any) -> bool:
+        """Check if a function should be counted as a public method.
+
+        Excludes functions starting with underscore (private convention).
+
+        Args:
+            func_node: A function_item tree-sitter node
+
+        Returns:
+            True if the function should be counted
+        """
+        name = self.extract_identifier_name(func_node)
+        return not name.startswith("_")

src/linters/unwrap_abuse/__init__.py

@@ -0,0 +1,30 @@
+"""
+Purpose: Rust unwrap abuse detector package exports
+
+Scope: Detect .unwrap() and .expect() abuse in Rust code and suggest safer alternatives
+
+Overview: Package providing unwrap/expect abuse detection for Rust code. Identifies .unwrap()
+    and .expect() calls outside test code that may panic at runtime. Suggests safer alternatives
+    including the ? operator, unwrap_or(), unwrap_or_default(), and match/if-let expressions.
+    Supports configuration for allowing calls in test code, example files, and benchmark
+    directories. Uses tree-sitter for accurate AST-based detection.
+
+Dependencies: tree-sitter-rust (optional) for AST parsing, src.core for base classes
+
+Exports: UnwrapAbuseConfig, UnwrapAbuseRule, RustUnwrapAnalyzer, UnwrapCall
+
+Interfaces: UnwrapAbuseConfig.from_dict() for YAML configuration loading
+
+Implementation: Tree-sitter AST-based pattern detection with configurable filtering
+"""
+
+from .config import UnwrapAbuseConfig
+from .linter import UnwrapAbuseRule
+from .rust_analyzer import RustUnwrapAnalyzer, UnwrapCall
+
+__all__ = [
+    "UnwrapAbuseConfig",
+    "UnwrapAbuseRule",
+    "RustUnwrapAnalyzer",
+    "UnwrapCall",
+]

src/linters/unwrap_abuse/config.py

@@ -0,0 +1,59 @@
+"""
+Purpose: Configuration dataclass for Rust unwrap abuse detector
+
+Scope: Pattern toggles, ignore patterns, and configuration for unwrap/expect detection
+
+Overview: Provides UnwrapAbuseConfig dataclass with toggles for controlling detection of
+    .unwrap() and .expect() calls in Rust code. Supports configuration for allowing calls
+    in test code, example files, and benchmark directories. Includes an option to allow
+    .expect() calls (which provide error context) while still flagging bare .unwrap() calls.
+    Configuration loads from YAML with sensible defaults via from_dict() class method.
+
+Dependencies: dataclasses, typing
+
+Exports: UnwrapAbuseConfig
+
+Interfaces: UnwrapAbuseConfig.from_dict() for YAML configuration loading
+
+Implementation: Dataclass with factory defaults and conservative default settings
+"""
+
+from dataclasses import dataclass, field
+from typing import Any
+
+
+@dataclass
+class UnwrapAbuseConfig:
+    """Configuration for unwrap abuse detection."""
+
+    enabled: bool = True
+
+    # Allow .unwrap()/.expect() in test functions and #[cfg(test)] modules
+    allow_in_tests: bool = True
+
+    # Allow .expect() calls (they provide error context unlike bare .unwrap()).
+    # Defaults to True because .expect("reason") is the Rust community recommended
+    # alternative to bare .unwrap(), providing panic context.
+    allow_expect: bool = True
+
+    # File path patterns to ignore (e.g., examples/, benches/)
+    ignore: list[str] = field(default_factory=lambda: ["examples/", "benches/", "tests/"])
+
+    @classmethod
+    def from_dict(cls, config: dict[str, Any], language: str | None = None) -> "UnwrapAbuseConfig":
+        """Load configuration from dictionary.
+
+        Args:
+            config: Configuration dictionary from YAML
+            language: Language parameter (reserved for future use)
+
+        Returns:
+            Configured UnwrapAbuseConfig instance
+        """
+        _ = language
+        return cls(
+            enabled=config.get("enabled", True),
+            allow_in_tests=config.get("allow_in_tests", True),
+            allow_expect=config.get("allow_expect", True),
+            ignore=config.get("ignore", ["examples/", "benches/", "tests/"]),
+        )

src/linters/unwrap_abuse/linter.py

@@ -0,0 +1,166 @@
+"""
+Purpose: Main linter rule for detecting unwrap/expect abuse in Rust code
+
+Scope: Entry point for unwrap abuse detection implementing BaseLintRule interface
+
+Overview: Provides UnwrapAbuseRule class that implements the BaseLintRule interface for
+    detecting .unwrap() and .expect() abuse in Rust code. Validates that files are Rust
+    with content, loads configuration, checks ignored paths, and delegates analysis to
+    RustUnwrapAnalyzer. Filters detected calls based on configuration (allow_in_tests,
+    allow_expect, ignored paths) and converts remaining calls to Violation objects via
+    the violation builder. Supports disabling via configuration.
+
+Dependencies: BaseLintRule, RustUnwrapAnalyzer, UnwrapAbuseConfig, violation_builder
+
+Exports: UnwrapAbuseRule
+
+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 UnwrapAbuseConfig
+from .rust_analyzer import RustUnwrapAnalyzer, UnwrapCall
+from .violation_builder import build_expect_violation, build_unwrap_violation
+
+
+class UnwrapAbuseRule(BaseLintRule):
+    """Detects unwrap/expect abuse in Rust code."""
+
+    def __init__(self, config: UnwrapAbuseConfig | None = None) -> None:
+        """Initialize the unwrap abuse rule.
+
+        Args:
+            config: Optional configuration override for testing
+        """
+        self._config_override = config
+        self._analyzer = RustUnwrapAnalyzer()
+
+    @property
+    def rule_id(self) -> str:
+        """Unique identifier for this rule."""
+        return "unwrap-abuse"
+
+    @property
+    def rule_name(self) -> str:
+        """Human-readable name for this rule."""
+        return "Rust Unwrap Abuse"
+
+    @property
+    def description(self) -> str:
+        """Description of what this rule checks."""
+        return (
+            "Detects .unwrap() and .expect() calls in Rust code that may panic at runtime. "
+            "Suggests safer alternatives like the ? operator, unwrap_or(), unwrap_or_default(), "
+            "or match/if-let expressions."
+        )
+
+    def check(self, context: BaseLintContext) -> list[Violation]:
+        """Check for unwrap/expect abuse in Rust code.
+
+        Args:
+            context: The lint context containing file information.
+
+        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_unwrap_calls(context.file_content or "")
+        return self._build_violations(calls, config, file_path)
+
+    def _should_analyze(self, context: BaseLintContext, config: UnwrapAbuseConfig) -> bool:
+        """Check if context should be analyzed.
+
+        Args:
+            context: Lint context to check
+            config: Active configuration
+
+        Returns:
+            True if file is Rust with content and rule is enabled
+        """
+        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) -> UnwrapAbuseConfig:
+        """Get configuration, using override if provided.
+
+        Args:
+            context: Lint context for loading config from metadata
+
+        Returns:
+            Configuration instance
+        """
+        if self._config_override is not None:
+            return self._config_override
+        return load_linter_config(context, "unwrap-abuse", UnwrapAbuseConfig)
+
+    def _build_violations(
+        self,
+        calls: list[UnwrapCall],
+        config: UnwrapAbuseConfig,
+        file_path: str,
+    ) -> list[Violation]:
+        """Convert filtered unwrap calls to violations.
+
+        Args:
+            calls: Detected unwrap/expect calls
+            config: Active configuration
+            file_path: Path to the file being analyzed
+
+        Returns:
+            List of violations for non-excluded calls
+        """
+        return [
+            _build_violation_for_call(call, file_path)
+            for call in calls
+            if not self._should_skip_call(call, config)
+        ]
+
+    def _should_skip_call(self, call: UnwrapCall, config: UnwrapAbuseConfig) -> bool:
+        """Determine if a detected call should be skipped based on config.
+
+        Args:
+            call: Detected unwrap/expect call
+            config: Active configuration
+
+        Returns:
+            True if the call should be excluded from violations
+        """
+        if call.is_in_test and config.allow_in_tests:
+            return True
+        if call.method == "expect" and config.allow_expect:
+            return True
+        return False
+
+
+def _build_violation_for_call(call: UnwrapCall, file_path: str) -> Violation:
+    """Build the appropriate violation for a detected call.
+
+    Args:
+        call: Detected unwrap/expect call
+        file_path: Path to the file
+
+    Returns:
+        Violation object for the call
+    """
+    if call.method == "unwrap":
+        return build_unwrap_violation(file_path, call.line, call.column, call.context)
+    return build_expect_violation(file_path, call.line, call.column, call.context)

src/linters/unwrap_abuse/rust_analyzer.py

@@ -0,0 +1,118 @@
+"""
+Purpose: Analyzer for detecting unwrap/expect abuse in Rust code using tree-sitter AST
+
+Scope: Pattern detection for .unwrap() and .expect() method calls in Rust source files
+
+Overview: Provides RustUnwrapAnalyzer that extends RustBaseAnalyzer to detect .unwrap() and
+    .expect() method calls in Rust code. Uses tree-sitter AST to find call_expression nodes
+    containing field_expression with field_identifier matching "unwrap" or "expect". Determines
+    whether each call is inside test code using the base analyzer's is_inside_test() method.
+    Returns structured UnwrapCall dataclass instances with location, method name, test context,
+    and surrounding code for violation reporting.
+
+Dependencies: src.analyzers.rust_base for tree-sitter parsing and traversal
+
+Exports: RustUnwrapAnalyzer, UnwrapCall
+
+Interfaces: find_unwrap_calls(code: str) -> list[UnwrapCall]
+
+Implementation: Recursive AST traversal with field_expression pattern matching for method calls
+"""
+
+from dataclasses import dataclass
+
+from src.analyzers.rust_base import TREE_SITTER_RUST_AVAILABLE, RustBaseAnalyzer
+from src.core.linter_utils import get_line_context
+
+if TREE_SITTER_RUST_AVAILABLE:
+    from tree_sitter import Node
+
+
+@dataclass
+class UnwrapCall:
+    """Represents a detected unwrap/expect call."""
+
+    line: int
+    column: int
+    method: str  # "unwrap" or "expect"
+    is_in_test: bool
+    context: str  # Surrounding code snippet
+
+
+class RustUnwrapAnalyzer(RustBaseAnalyzer):
+    """Analyzer for detecting unwrap/expect calls in Rust code."""
+
+    def find_unwrap_calls(self, code: str) -> list[UnwrapCall]:
+        """Find all unwrap() and expect() calls in code.
+
+        Args:
+            code: Rust source code to analyze
+
+        Returns:
+            List of detected unwrap/expect calls with location and context
+        """
+        if not self.tree_sitter_available:
+            return []
+
+        root = self.parse_rust(code)
+        if root is None:
+            return []
+
+        calls: list[UnwrapCall] = []
+        self._find_unwrap_recursive(root, code, calls)
+        return calls
+
+    def _find_unwrap_recursive(self, node: "Node", code: str, calls: list[UnwrapCall]) -> None:
+        """Recursively find unwrap/expect method 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 in ("unwrap", "expect"):
+                calls.append(
+                    UnwrapCall(
+                        line=node.start_point[0] + 1,
+                        column=node.start_point[1],
+                        method=method_name,
+                        is_in_test=self.is_inside_test(node),
+                        context=get_line_context(code, node.start_point[0]),
+                    )
+                )
+
+        for child in node.children:
+            self._find_unwrap_recursive(child, code, calls)
+
+    def _get_method_name(self, call_node: "Node") -> str:
+        """Extract method name from a call expression.
+
+        In Rust tree-sitter, method calls have this structure:
+            call_expression -> field_expression -> field_identifier
+
+        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., "unwrap", "expect")
+        """
+        for subchild in field_expr.children:
+            if subchild.type == "field_identifier":
+                return self.extract_node_text(subchild)
+        return ""

src/linters/unwrap_abuse/violation_builder.py

@@ -0,0 +1,89 @@
+"""
+Purpose: Build Violation objects for Rust unwrap/expect abuse patterns
+
+Scope: Creates violations with actionable suggestions for unwrap and expect calls
+
+Overview: Provides module-level functions that create Violation objects for detected
+    .unwrap() and .expect() calls in Rust code. Each violation includes the rule ID,
+    location, descriptive message explaining the risk of panicking, and a suggestion
+    for safer alternatives such as the ? operator, unwrap_or(), unwrap_or_default(),
+    or match/if-let expressions.
+
+Dependencies: src.core.types for Violation dataclass
+
+Exports: build_unwrap_violation, build_expect_violation
+
+Interfaces: Module functions taking file_path, line, column, context and returning Violation
+
+Implementation: Factory functions for unwrap and expect violation types with pattern-specific suggestions
+"""
+
+from src.core.types import Violation
+
+_UNWRAP_SUGGESTION = (
+    "Use the ? operator, .unwrap_or(), .unwrap_or_default(), "
+    "or match/if-let for safe error handling."
+)
+
+_EXPECT_SUGGESTION = (
+    "Use the ? operator with a descriptive error via .context() or .with_context(), "
+    "or use match/if-let for explicit error handling."
+)
+
+
+def build_unwrap_violation(
+    file_path: str,
+    line: int,
+    column: int,
+    context: str,
+) -> Violation:
+    """Build a violation for .unwrap() call.
+
+    Args:
+        file_path: Path to the file containing the violation
+        line: Line number (1-indexed)
+        column: Column number (0-indexed)
+        context: Code context around the violation
+
+    Returns:
+        Violation object with safer alternative suggestion
+    """
+    message = f".unwrap() call may panic at runtime: {context}"
+
+    return Violation(
+        rule_id="unwrap-abuse.unwrap-call",
+        file_path=file_path,
+        line=line,
+        column=column,
+        message=message,
+        suggestion=_UNWRAP_SUGGESTION,
+    )
+
+
+def build_expect_violation(
+    file_path: str,
+    line: int,
+    column: int,
+    context: str,
+) -> Violation:
+    """Build a violation for .expect() call.
+
+    Args:
+        file_path: Path to the file containing the violation
+        line: Line number (1-indexed)
+        column: Column number (0-indexed)
+        context: Code context around the violation
+
+    Returns:
+        Violation object with safer alternative suggestion
+    """
+    message = f".expect() call may panic at runtime: {context}"
+
+    return Violation(
+        rule_id="unwrap-abuse.expect-call",
+        file_path=file_path,
+        line=line,
+        column=column,
+        message=message,
+        suggestion=_EXPECT_SUGGESTION,
+    )