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

src/cli/linters/__init__.py

@@ -1,7 +1,8 @@
 """
 Purpose: CLI linters package that registers all linter commands to the main CLI group
 
-Scope: Export and registration of all linter CLI commands (nesting, srp, dry, magic-numbers, etc.)
+Scope: Export and registration of all linter CLI commands (nesting, srp, dry, magic-numbers,
+    unwrap-abuse, clone-abuse, blocking-async, etc.)
 
 Overview: Package initialization that imports all linter command modules to trigger their registration
     with the main CLI group via Click decorators. Each submodule defines commands using @cli.command()
@@ -29,6 +30,7 @@ from src.cli.linters import (  # noqa: F401
     code_smells,
     documentation,
     performance,
+    rust,
     structure,
     structure_quality,
 )
@@ -43,6 +45,7 @@ from src.cli.linters.code_patterns import (
 from src.cli.linters.code_smells import dry, magic_numbers
 from src.cli.linters.documentation import file_header
 from src.cli.linters.performance import perf, regex_in_loop, string_concat_loop
+from src.cli.linters.rust import blocking_async, clone_abuse, unwrap_abuse
 from src.cli.linters.structure import file_placement, pipeline
 from src.cli.linters.structure_quality import nesting, srp
 
@@ -67,4 +70,8 @@ __all__ = [
     "perf",
     "string_concat_loop",
     "regex_in_loop",
+    # Rust commands
+    "unwrap_abuse",
+    "clone_abuse",
+    "blocking_async",
 ]

src/cli/linters/rust.py

@@ -0,0 +1,177 @@
+"""
+Purpose: CLI commands for Rust-specific linters (unwrap-abuse, clone-abuse, blocking-async)
+
+Scope: Commands that detect Rust-specific anti-patterns and code smells
+
+Overview: Provides CLI commands for Rust code linting: unwrap-abuse detects .unwrap() and
+    .expect() calls that may panic at runtime and suggests safer alternatives; clone-abuse
+    detects .clone() abuse patterns including clone in loops, chained clones, and unnecessary
+    clones; blocking-async detects blocking operations (std::fs, std::thread::sleep, std::net)
+    inside async functions and suggests tokio equivalents. Each command supports standard
+    options (config, format, recursive) and integrates with the orchestrator for execution.
+
+Dependencies: click for CLI framework, src.cli.main for CLI group, src.cli.utils for shared utilities
+
+Exports: unwrap_abuse command, clone_abuse command, blocking_async command
+
+Interfaces: Click CLI commands registered to main CLI group
+
+Implementation: Click decorators for command definition, orchestrator-based linting execution
+"""
+
+import sys
+from pathlib import Path
+from typing import TYPE_CHECKING, NoReturn
+
+from loguru import logger
+
+from src.cli.linters.shared import ExecuteParams, create_linter_command
+from src.cli.utils import execute_linting_on_paths, setup_base_orchestrator, validate_paths_exist
+from src.core.cli_utils import format_violations
+from src.core.types import Violation
+
+if TYPE_CHECKING:
+    from src.orchestrator.core import Orchestrator
+
+
+# =============================================================================
+# Unwrap Abuse Command
+# =============================================================================
+
+
+def _setup_unwrap_abuse_orchestrator(
+    path_objs: list[Path], config_file: str | None, verbose: bool, project_root: Path | None = None
+) -> "Orchestrator":
+    """Set up orchestrator for unwrap-abuse command."""
+    return setup_base_orchestrator(path_objs, config_file, verbose, project_root)
+
+
+def _run_unwrap_abuse_lint(
+    orchestrator: "Orchestrator", path_objs: list[Path], recursive: bool, parallel: bool = False
+) -> list[Violation]:
+    """Execute unwrap-abuse lint on files or directories."""
+    all_violations = execute_linting_on_paths(orchestrator, path_objs, recursive, parallel)
+    return [v for v in all_violations if v.rule_id.startswith("unwrap-abuse")]
+
+
+def _execute_unwrap_abuse_lint(params: ExecuteParams) -> NoReturn:
+    """Execute unwrap-abuse lint."""
+    validate_paths_exist(params.path_objs)
+    orchestrator = _setup_unwrap_abuse_orchestrator(
+        params.path_objs, params.config_file, params.verbose, params.project_root
+    )
+    unwrap_abuse_violations = _run_unwrap_abuse_lint(
+        orchestrator, params.path_objs, params.recursive, params.parallel
+    )
+
+    logger.debug(f"Found {len(unwrap_abuse_violations)} unwrap abuse violation(s)")
+
+    format_violations(unwrap_abuse_violations, params.format)
+    sys.exit(1 if unwrap_abuse_violations else 0)
+
+
+unwrap_abuse = create_linter_command(
+    "unwrap-abuse",
+    _execute_unwrap_abuse_lint,
+    "Check for .unwrap() and .expect() abuse in Rust code.",
+    "Detects .unwrap() and .expect() calls in Rust code that may panic at runtime.\n"
+    "    Suggests safer alternatives like the ? operator, unwrap_or(),\n"
+    "    unwrap_or_default(), or match/if-let expressions.\n"
+    "    Ignores calls in #[test] functions and #[cfg(test)] modules by default.",
+)
+
+
+# =============================================================================
+# Clone Abuse Command
+# =============================================================================
+
+
+def _setup_clone_abuse_orchestrator(
+    path_objs: list[Path], config_file: str | None, verbose: bool, project_root: Path | None = None
+) -> "Orchestrator":
+    """Set up orchestrator for clone-abuse command."""
+    return setup_base_orchestrator(path_objs, config_file, verbose, project_root)
+
+
+def _run_clone_abuse_lint(
+    orchestrator: "Orchestrator", path_objs: list[Path], recursive: bool, parallel: bool = False
+) -> list[Violation]:
+    """Execute clone-abuse lint on files or directories."""
+    all_violations = execute_linting_on_paths(orchestrator, path_objs, recursive, parallel)
+    return [v for v in all_violations if v.rule_id.startswith("clone-abuse")]
+
+
+def _execute_clone_abuse_lint(params: ExecuteParams) -> NoReturn:
+    """Execute clone-abuse lint."""
+    validate_paths_exist(params.path_objs)
+    orchestrator = _setup_clone_abuse_orchestrator(
+        params.path_objs, params.config_file, params.verbose, params.project_root
+    )
+    clone_abuse_violations = _run_clone_abuse_lint(
+        orchestrator, params.path_objs, params.recursive, params.parallel
+    )
+
+    logger.debug(f"Found {len(clone_abuse_violations)} clone abuse violation(s)")
+
+    format_violations(clone_abuse_violations, params.format)
+    sys.exit(1 if clone_abuse_violations else 0)
+
+
+clone_abuse = create_linter_command(
+    "clone-abuse",
+    _execute_clone_abuse_lint,
+    "Check for .clone() abuse patterns in Rust code.",
+    "Detects .clone() abuse patterns in Rust code: clone in loops,\n"
+    "    chained .clone().clone() calls, and unnecessary clones where\n"
+    "    the original is not used after cloning.\n"
+    "    Suggests borrowing, Rc/Arc, or Cow patterns as alternatives.\n"
+    "    Ignores calls in #[test] functions and #[cfg(test)] modules by default.",
+)
+
+
+# =============================================================================
+# Blocking Async Command
+# =============================================================================
+
+
+def _setup_blocking_async_orchestrator(
+    path_objs: list[Path], config_file: str | None, verbose: bool, project_root: Path | None = None
+) -> "Orchestrator":
+    """Set up orchestrator for blocking-async command."""
+    return setup_base_orchestrator(path_objs, config_file, verbose, project_root)
+
+
+def _run_blocking_async_lint(
+    orchestrator: "Orchestrator", path_objs: list[Path], recursive: bool, parallel: bool = False
+) -> list[Violation]:
+    """Execute blocking-async lint on files or directories."""
+    all_violations = execute_linting_on_paths(orchestrator, path_objs, recursive, parallel)
+    return [v for v in all_violations if v.rule_id.startswith("blocking-async")]
+
+
+def _execute_blocking_async_lint(params: ExecuteParams) -> NoReturn:
+    """Execute blocking-async lint."""
+    validate_paths_exist(params.path_objs)
+    orchestrator = _setup_blocking_async_orchestrator(
+        params.path_objs, params.config_file, params.verbose, params.project_root
+    )
+    blocking_async_violations = _run_blocking_async_lint(
+        orchestrator, params.path_objs, params.recursive, params.parallel
+    )
+
+    logger.debug(f"Found {len(blocking_async_violations)} blocking-async violation(s)")
+
+    format_violations(blocking_async_violations, params.format)
+    sys.exit(1 if blocking_async_violations else 0)
+
+
+blocking_async = create_linter_command(
+    "blocking-async",
+    _execute_blocking_async_lint,
+    "Check for blocking operations in async Rust functions.",
+    "Detects blocking operations inside async functions in Rust code:\n"
+    "    std::fs I/O, std::thread::sleep, and blocking std::net calls.\n"
+    "    Suggests async-compatible alternatives like tokio::fs,\n"
+    "    tokio::time::sleep, and tokio::net equivalents.\n"
+    "    Ignores calls in #[test] functions and #[cfg(test)] modules by default.",
+)

src/core/base.py

@@ -177,12 +177,27 @@ class MultiLanguageLintRule(BaseLintRule):
         if not config.enabled:
             return []
 
+        return self._dispatch_by_language(context, config)
+
+    def _dispatch_by_language(self, context: BaseLintContext, config: Any) -> list[Violation]:
+        """Dispatch to language-specific check method.
+
+        Args:
+            context: Lint context with language information
+            config: Loaded configuration
+
+        Returns:
+            List of violations from language-specific checker
+        """
         if context.language == Language.PYTHON:
             return self._check_python(context, config)
 
         if context.language in (Language.TYPESCRIPT, Language.JAVASCRIPT):
             return self._check_typescript(context, config)
 
+        if context.language == Language.RUST:
+            return self._check_rust(context, config)
+
         return []
 
     @abstractmethod
@@ -222,3 +237,18 @@ class MultiLanguageLintRule(BaseLintRule):
             List of violations found in TypeScript/JavaScript code
         """
         raise NotImplementedError("Subclasses must implement _check_typescript")
+
+    def _check_rust(self, context: BaseLintContext, config: Any) -> list[Violation]:
+        """Check Rust code for violations.
+
+        Override in subclasses to add Rust language support.
+        Returns empty list by default for linters that do not support Rust.
+
+        Args:
+            context: Lint context with Rust file information
+            config: Loaded configuration
+
+        Returns:
+            List of violations found in Rust code
+        """
+        return []

src/core/constants.py

@@ -28,6 +28,7 @@ class Language(str, Enum):
     TYPESCRIPT = "typescript"
     JAVASCRIPT = "javascript"
     MARKDOWN = "markdown"
+    RUST = "rust"
 
 
 class StorageMode(str, Enum):

src/core/linter_utils.py

@@ -13,7 +13,7 @@ Overview: Provides reusable helper functions to eliminate duplication across lin
 Dependencies: BaseLintContext from src.core.base, ast for Python parsing
 
 Exports: get_metadata, get_metadata_value, load_linter_config, has_file_content, parse_python_ast,
-    with_parsed_python
+    with_parsed_python, resolve_file_path, is_ignored_path, get_line_context
 
 Interfaces: All functions take BaseLintContext and return typed values (dict, str, bool, Any)
 
@@ -255,3 +255,44 @@ def with_parsed_python(
     # tree is guaranteed non-None when errors is empty (parse_python_ast contract)
     assert tree is not None  # nosec B101
     return on_success(tree)
+
+
+def resolve_file_path(context: BaseLintContext) -> str:
+    """Resolve file path from context.
+
+    Args:
+        context: Lint context
+
+    Returns:
+        File path string, or "unknown" if not available
+    """
+    return str(context.file_path) if context.file_path else "unknown"
+
+
+def is_ignored_path(file_path: str, ignore_patterns: list[str]) -> bool:
+    """Check if file path matches any ignore pattern.
+
+    Args:
+        file_path: Path to check
+        ignore_patterns: List of patterns to match against
+
+    Returns:
+        True if the path should be ignored
+    """
+    return any(ignored in file_path for ignored in ignore_patterns)
+
+
+def get_line_context(code: str, line_index: int) -> str:
+    """Get the code line at the given index for context.
+
+    Args:
+        code: Full source code
+        line_index: Zero-indexed line number
+
+    Returns:
+        Stripped line content, or empty string if index out of range
+    """
+    lines = code.split("\n")
+    if 0 <= line_index < len(lines):
+        return lines[line_index].strip()
+    return ""

src/linters/blocking_async/__init__.py

@@ -0,0 +1,31 @@
+"""
+Purpose: Rust blocking-in-async detector package exports
+
+Scope: Detect blocking operations inside async functions in Rust code and suggest alternatives
+
+Overview: Package providing blocking-in-async detection for Rust code. Identifies std::fs I/O
+    operations, std::thread::sleep calls, and blocking std::net operations inside async functions.
+    Suggests async-compatible alternatives including tokio::fs, tokio::time::sleep, and tokio::net
+    equivalents. Supports configuration for allowing calls in test code, toggling individual
+    pattern detection, and ignoring specific directories. Uses tree-sitter for accurate
+    AST-based detection of async function contexts.
+
+Dependencies: tree-sitter-rust (optional) for AST parsing, src.core for base classes
+
+Exports: BlockingAsyncConfig, BlockingAsyncRule, RustBlockingAsyncAnalyzer, BlockingCall
+
+Interfaces: BlockingAsyncConfig.from_dict() for YAML configuration loading
+
+Implementation: Tree-sitter AST-based async context detection with blocking API pattern matching
+"""
+
+from .config import BlockingAsyncConfig
+from .linter import BlockingAsyncRule
+from .rust_analyzer import BlockingCall, RustBlockingAsyncAnalyzer
+
+__all__ = [
+    "BlockingAsyncConfig",
+    "BlockingAsyncRule",
+    "RustBlockingAsyncAnalyzer",
+    "BlockingCall",
+]

src/linters/blocking_async/config.py

@@ -0,0 +1,67 @@
+"""
+Purpose: Configuration dataclass for Rust blocking-in-async detector
+
+Scope: Pattern toggles, ignore patterns, and configuration for blocking-in-async detection
+
+Overview: Provides BlockingAsyncConfig dataclass with toggles for controlling detection of
+    blocking operations inside async functions in Rust code. Supports toggling detection of
+    std::fs operations, std::thread::sleep, and blocking network calls independently. Includes
+    configuration for allowing calls in test code, ignoring example and benchmark directories.
+    Configuration loads from YAML with sensible defaults via from_dict() class method.
+
+Dependencies: dataclasses, typing
+
+Exports: BlockingAsyncConfig
+
+Interfaces: BlockingAsyncConfig.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 BlockingAsyncConfig:
+    """Configuration for blocking-in-async detection."""
+
+    enabled: bool = True
+
+    # Allow blocking calls in test functions and #[cfg(test)] modules
+    allow_in_tests: bool = True
+
+    # Toggle detection of std::fs operations in async functions
+    detect_fs_in_async: bool = True
+
+    # Toggle detection of std::thread::sleep in async functions
+    detect_sleep_in_async: bool = True
+
+    # Toggle detection of std::net blocking calls in async functions
+    detect_net_in_async: 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
+    ) -> "BlockingAsyncConfig":
+        """Load configuration from dictionary.
+
+        Args:
+            config: Configuration dictionary from YAML
+            language: Language parameter (reserved for future use)
+
+        Returns:
+            Configured BlockingAsyncConfig instance
+        """
+        _ = language
+        return cls(
+            enabled=config.get("enabled", True),
+            allow_in_tests=config.get("allow_in_tests", True),
+            detect_fs_in_async=config.get("detect_fs_in_async", True),
+            detect_sleep_in_async=config.get("detect_sleep_in_async", True),
+            detect_net_in_async=config.get("detect_net_in_async", True),
+            ignore=config.get("ignore", ["examples/", "benches/", "tests/"]),
+        )

src/linters/blocking_async/linter.py

@@ -0,0 +1,183 @@
+"""
+Purpose: Main linter rule for detecting blocking operations in async Rust code
+
+Scope: Entry point for blocking-in-async detection implementing BaseLintRule interface
+
+Overview: Provides BlockingAsyncRule class that implements the BaseLintRule interface for
+    detecting blocking API calls inside async functions in Rust code. Validates that files
+    are Rust with content, loads configuration, checks ignored paths, and delegates analysis
+    to RustBlockingAsyncAnalyzer. 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, RustBlockingAsyncAnalyzer, BlockingAsyncConfig, violation_builder
+
+Exports: BlockingAsyncRule
+
+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 BlockingAsyncConfig
+from .rust_analyzer import BlockingCall, RustBlockingAsyncAnalyzer
+from .violation_builder import (
+    build_fs_in_async_violation,
+    build_net_in_async_violation,
+    build_sleep_in_async_violation,
+)
+
+_PATTERN_BUILDERS = {
+    "fs-in-async": build_fs_in_async_violation,
+    "sleep-in-async": build_sleep_in_async_violation,
+    "net-in-async": build_net_in_async_violation,
+}
+
+_PATTERN_CONFIG_KEYS = {
+    "fs-in-async": "detect_fs_in_async",
+    "sleep-in-async": "detect_sleep_in_async",
+    "net-in-async": "detect_net_in_async",
+}
+
+
+class BlockingAsyncRule(BaseLintRule):
+    """Detects blocking operations inside async functions in Rust code."""
+
+    def __init__(self, config: BlockingAsyncConfig | None = None) -> None:
+        """Initialize blocking-in-async rule.
+
+        Args:
+            config: Optional configuration override for testing
+        """
+        self._config_override = config
+        self._analyzer = RustBlockingAsyncAnalyzer()
+
+    @property
+    def rule_id(self) -> str:
+        """Unique identifier for this rule."""
+        return "blocking-async"
+
+    @property
+    def rule_name(self) -> str:
+        """Human-readable name for this rule."""
+        return "Rust Blocking in Async"
+
+    @property
+    def description(self) -> str:
+        """Description of what this rule checks."""
+        return (
+            "Detects blocking operations inside async functions in Rust code including "
+            "std::fs I/O, std::thread::sleep, and blocking std::net calls. Suggests "
+            "async-compatible alternatives like tokio::fs, tokio::time::sleep, and tokio::net."
+        )
+
+    def check(self, context: BaseLintContext) -> list[Violation]:
+        """Check for blocking-in-async 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_blocking_calls(context.file_content or "")
+        return self._build_violations(calls, config, file_path)
+
+    def _should_analyze(self, context: BaseLintContext, config: BlockingAsyncConfig) -> bool:
+        """Determine if the file should be analyzed.
+
+        Args:
+            context: Lint context to check
+            config: Blocking-in-async 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) -> BlockingAsyncConfig:
+        """Load configuration from override or context metadata.
+
+        Args:
+            context: Lint context with metadata
+
+        Returns:
+            BlockingAsyncConfig instance
+        """
+        if self._config_override is not None:
+            return self._config_override
+        return load_linter_config(context, "blocking-async", BlockingAsyncConfig)
+
+    def _build_violations(
+        self,
+        calls: list[BlockingCall],
+        config: BlockingAsyncConfig,
+        file_path: str,
+    ) -> list[Violation]:
+        """Convert blocking calls to violations with config filtering.
+
+        Args:
+            calls: Detected blocking 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: BlockingCall, config: BlockingAsyncConfig) -> bool:
+    """Determine if a blocking call should be skipped based on config.
+
+    Args:
+        call: Detected blocking 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: BlockingCall, file_path: str) -> Violation:
+    """Build a violation for a specific blocking call.
+
+    Args:
+        call: Detected blocking call with pattern info
+        file_path: Path of the analyzed file
+
+    Returns:
+        Violation instance
+    """
+    builder = _PATTERN_BUILDERS.get(call.pattern, build_fs_in_async_violation)
+    return builder(file_path, call.line, call.column, call.context)