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

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)

src/linters/blocking_async/rust_analyzer.py

@@ -0,0 +1,419 @@
+"""
+Purpose: Analyzer for detecting blocking operations inside async functions in Rust code
+
+Scope: Pattern detection for std::fs, std::thread::sleep, and std::net calls in async contexts
+
+Overview: Provides RustBlockingAsyncAnalyzer that extends RustBaseAnalyzer to detect blocking
+    API calls inside async functions in Rust code. Detects three categories: filesystem operations
+    (std::fs::read_to_string, std::fs::write, etc.), thread sleep (std::thread::sleep), and
+    blocking network calls (std::net::TcpStream::connect, etc.). Supports both fully-qualified
+    paths (std::fs::read_to_string) and short paths (fs::read_to_string after use std::fs).
+    Excludes blocking calls wrapped in async-safe wrappers (asyncify, spawn_blocking,
+    block_in_place) which correctly offload work to a thread pool. Uses tree-sitter AST to
+    find function_item nodes, filter to async functions, walk bodies for call_expression nodes
+    with scoped_identifier paths, and match against known blocking API patterns. Returns
+    structured BlockingCall 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: RustBlockingAsyncAnalyzer, BlockingCall
+
+Interfaces: find_blocking_calls(code: str) -> list[BlockingCall]
+
+Implementation: AST-based async function detection with scoped_identifier path extraction
+    and pattern matching against known blocking APIs
+"""
+
+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
+
+# Blocking std::fs function names
+_BLOCKING_FS_FUNCTIONS = frozenset(
+    {
+        "read_to_string",
+        "read",
+        "write",
+        "create_dir",
+        "create_dir_all",
+        "remove_file",
+        "remove_dir",
+        "remove_dir_all",
+        "rename",
+        "copy",
+        "metadata",
+        "read_dir",
+        "canonicalize",
+        "read_link",
+    }
+)
+
+# Blocking std::net type names that have blocking methods
+_BLOCKING_NET_TYPES = frozenset(
+    {
+        "TcpStream",
+        "TcpListener",
+        "UdpSocket",
+    }
+)
+
+
+@dataclass
+class BlockingCall:
+    """Represents a detected blocking call inside an async function."""
+
+    line: int
+    column: int
+    pattern: str  # "fs-in-async", "sleep-in-async", "net-in-async"
+    is_in_test: bool
+    context: str  # Surrounding code snippet
+    blocking_api: str  # e.g., "std::fs::read_to_string"
+
+
+class RustBlockingAsyncAnalyzer(RustBaseAnalyzer):
+    """Analyzer for detecting blocking operations inside async functions."""
+
+    def find_blocking_calls(self, code: str) -> list[BlockingCall]:
+        """Find all blocking calls inside async functions.
+
+        Args:
+            code: Rust source code to analyze
+
+        Returns:
+            List of detected blocking calls with pattern classification
+        """
+        if not self.tree_sitter_available:
+            return []
+
+        root = self.parse_rust(code)
+        if root is None:
+            return []
+
+        calls: list[BlockingCall] = []
+        self._scan_for_blocking_calls(root, code, calls)
+        return calls
+
+    def _scan_for_blocking_calls(self, node: Node, code: str, calls: list[BlockingCall]) -> None:
+        """Recursively scan AST for blocking calls in async contexts.
+
+        Finds call_expression nodes inside async functions and checks if they
+        invoke known blocking APIs.
+
+        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" and self._is_in_async_context(node):
+            blocking_call = self._check_blocking_call(node, code)
+            if blocking_call is not None:
+                calls.append(blocking_call)
+
+        for child in node.children:
+            self._scan_for_blocking_calls(child, code, calls)
+
+    def _is_in_async_context(self, node: Node) -> bool:
+        """Check if node is inside an async function body.
+
+        Walks up the parent chain looking for function_item nodes that
+        are async functions.
+
+        Args:
+            node: Node to check
+
+        Returns:
+            True if inside an async function
+        """
+        current: Node | None = node.parent
+        while current is not None:
+            if current.type == "function_item" and self.is_async_function(current):
+                return True
+            current = current.parent
+        return False
+
+    def _check_blocking_call(self, call_node: Node, code: str) -> BlockingCall | None:
+        """Check if a call expression is a blocking API call.
+
+        Extracts the call path from the scoped_identifier child and matches
+        it against known blocking API patterns. Skips calls wrapped in
+        spawn_blocking/asyncify which are correctly offloaded to a thread pool.
+
+        Args:
+            call_node: A call_expression node
+            code: Original source code for context extraction
+
+        Returns:
+            BlockingCall if blocking API detected, None otherwise
+        """
+        path = self._extract_call_path(call_node)
+        if not path:
+            return None
+
+        pattern = _classify_blocking_pattern(path)
+        if pattern is None:
+            return None
+
+        if _is_inside_blocking_wrapper(call_node):
+            return None
+
+        return BlockingCall(
+            line=call_node.start_point[0] + 1,
+            column=call_node.start_point[1],
+            pattern=pattern,
+            is_in_test=self.is_inside_test(call_node),
+            context=get_line_context(code, call_node.start_point[0]),
+            blocking_api=path,
+        )
+
+    def _extract_call_path(self, call_node: Node) -> str:
+        """Extract the full call path from a call_expression.
+
+        Handles both direct scoped calls (std::fs::read_to_string(...))
+        and method-style calls that chain on scoped calls.
+
+        Args:
+            call_node: A call_expression node
+
+        Returns:
+            Full path string (e.g., "std::fs::read_to_string"), or empty string
+        """
+        for child in call_node.children:
+            if child.type == "scoped_identifier":
+                return self.extract_node_text(child)
+        return ""
+
+
+def _classify_blocking_pattern(path: str) -> str | None:
+    """Classify a call path into a blocking pattern category.
+
+    Checks the path against known blocking API patterns for filesystem,
+    thread sleep, and network operations.
+
+    Args:
+        path: Full or short call path (e.g., "std::fs::read_to_string")
+
+    Returns:
+        Pattern string or None if not a blocking pattern
+    """
+    if _is_blocking_fs(path):
+        return "fs-in-async"
+    if _is_blocking_sleep(path):
+        return "sleep-in-async"
+    if _is_blocking_net(path):
+        return "net-in-async"
+    return None
+
+
+def _is_blocking_fs(path: str) -> bool:
+    """Check if path matches a blocking filesystem operation.
+
+    Matches both fully-qualified (std::fs::read_to_string) and
+    short paths (fs::read_to_string).
+
+    Args:
+        path: Call path to check
+
+    Returns:
+        True if path is a blocking fs operation
+    """
+    parts = path.split("::")
+    return _matches_std_fs_pattern(parts) or _matches_short_fs_pattern(parts)
+
+
+def _matches_std_fs_pattern(parts: list[str]) -> bool:
+    """Check for fully-qualified std::fs::function pattern.
+
+    Args:
+        parts: Path components split by ::
+
+    Returns:
+        True if matches std::fs::function_name
+    """
+    if len(parts) < 3:
+        return False
+    return parts[0] == "std" and parts[1] == "fs" and parts[2] in _BLOCKING_FS_FUNCTIONS
+
+
+def _matches_short_fs_pattern(parts: list[str]) -> bool:
+    """Check for short fs::function pattern.
+
+    Args:
+        parts: Path components split by ::
+
+    Returns:
+        True if matches fs::function_name
+    """
+    if len(parts) < 2:
+        return False
+    return parts[0] == "fs" and parts[1] in _BLOCKING_FS_FUNCTIONS
+
+
+def _is_blocking_sleep(path: str) -> bool:
+    """Check if path matches std::thread::sleep.
+
+    Matches both std::thread::sleep and thread::sleep.
+
+    Args:
+        path: Call path to check
+
+    Returns:
+        True if path is a blocking sleep call
+    """
+    parts = path.split("::")
+    return _matches_std_sleep_pattern(parts) or _matches_short_sleep_pattern(parts)
+
+
+def _matches_std_sleep_pattern(parts: list[str]) -> bool:
+    """Check for fully-qualified std::thread::sleep pattern.
+
+    Args:
+        parts: Path components split by ::
+
+    Returns:
+        True if matches std::thread::sleep
+    """
+    if len(parts) < 3:
+        return False
+    return parts[0] == "std" and parts[1] == "thread" and parts[2] == "sleep"
+
+
+def _matches_short_sleep_pattern(parts: list[str]) -> bool:
+    """Check for short thread::sleep pattern.
+
+    Args:
+        parts: Path components split by ::
+
+    Returns:
+        True if matches thread::sleep
+    """
+    if len(parts) < 2:
+        return False
+    return parts[0] == "thread" and parts[1] == "sleep"
+
+
+def _is_blocking_net(path: str) -> bool:
+    """Check if path matches a blocking network operation.
+
+    Matches both fully-qualified (std::net::TcpStream::connect) and
+    short paths (net::TcpStream::connect, TcpStream::connect).
+
+    Args:
+        path: Call path to check
+
+    Returns:
+        True if path is a blocking net operation
+    """
+    parts = path.split("::")
+    return _matches_std_net_pattern(parts) or _matches_short_net_pattern(parts)
+
+
+def _matches_std_net_pattern(parts: list[str]) -> bool:
+    """Check for fully-qualified std::net::Type::method pattern.
+
+    Args:
+        parts: Path components split by ::
+
+    Returns:
+        True if matches std::net::TcpStream/TcpListener/UdpSocket pattern
+    """
+    if len(parts) < 3:
+        return False
+    return parts[0] == "std" and parts[1] == "net" and parts[2] in _BLOCKING_NET_TYPES
+
+
+def _matches_short_net_pattern(parts: list[str]) -> bool:
+    """Check for short net::Type::method or Type::method pattern.
+
+    Args:
+        parts: Path components split by ::
+
+    Returns:
+        True if matches short net pattern
+    """
+    if len(parts) >= 2 and parts[0] == "net" and parts[1] in _BLOCKING_NET_TYPES:
+        return True
+    return False
+
+
+# Function names that safely wrap blocking operations for async execution
+_ASYNC_WRAPPER_FUNCTIONS = frozenset(
+    {
+        "asyncify",
+        "spawn_blocking",
+        "block_in_place",
+    }
+)
+
+
+def _is_inside_blocking_wrapper(node: Node) -> bool:
+    """Check if a blocking call is wrapped in an async-safe wrapper function.
+
+    Detects patterns like asyncify(move || std::fs::read(...)) or
+    spawn_blocking(move || { std::fs::write(...) }) where blocking calls
+    are correctly offloaded to a thread pool.
+
+    Args:
+        node: The blocking call_expression node
+
+    Returns:
+        True if the call is inside a known async wrapper function
+    """
+    current: Node | None = node.parent
+    while current is not None:
+        if _is_wrapper_call(current):
+            return True
+        current = current.parent
+    return False
+
+
+def _is_wrapper_call(node: Node) -> bool:
+    """Check if a node is a call to a known async wrapper function.
+
+    Args:
+        node: Node to check
+
+    Returns:
+        True if node is a call_expression to asyncify/spawn_blocking/block_in_place
+    """
+    if node.type != "call_expression":
+        return False
+    return any(_child_is_wrapper_name(child) for child in node.children)
+
+
+def _child_is_wrapper_name(child: Node) -> bool:
+    """Check if a child node is a wrapper function name.
+
+    Args:
+        child: Child node of a call_expression
+
+    Returns:
+        True if the child is an identifier or scoped_identifier matching a wrapper name
+    """
+    if child.type == "identifier":
+        return _node_text_matches_wrapper(child)
+    if child.type == "scoped_identifier":
+        return _scoped_name_matches_wrapper(child)
+    return False
+
+
+def _node_text_matches_wrapper(node: Node) -> bool:
+    """Check if a node's text matches a wrapper function name."""
+    text = node.text
+    return text is not None and text.decode() in _ASYNC_WRAPPER_FUNCTIONS
+
+
+def _scoped_name_matches_wrapper(node: Node) -> bool:
+    """Check if a scoped identifier's final segment matches a wrapper function name."""
+    text = node.text
+    if text is None:
+        return False
+    func_name = text.decode().split("::")[-1]
+    return func_name in _ASYNC_WRAPPER_FUNCTIONS

src/linters/blocking_async/violation_builder.py

@@ -0,0 +1,97 @@
+"""
+Purpose: Build Violation objects for Rust blocking-in-async patterns
+
+Scope: Creates violations with actionable suggestions for fs-in-async, sleep-in-async,
+    and net-in-async patterns
+
+Overview: Provides module-level functions that create Violation objects for detected
+    blocking operations inside async functions in Rust code. Each violation includes the
+    rule ID, location, descriptive message explaining the concurrency impact, and a
+    suggestion for async-compatible alternatives such as tokio::fs, tokio::time::sleep,
+    or tokio::net equivalents.
+
+Dependencies: src.core.types for Violation dataclass
+
+Exports: build_fs_in_async_violation, build_sleep_in_async_violation, build_net_in_async_violation
+
+Interfaces: Module functions taking file_path, line, column, context and returning Violation
+
+Implementation: Factory functions for each blocking-in-async pattern with pattern-specific suggestions
+"""
+
+from src.core.types import Violation
+
+_FS_IN_ASYNC_SUGGESTION = (
+    "Use tokio::fs equivalents (e.g., tokio::fs::read_to_string) for async-compatible "
+    "file I/O operations. Blocking std::fs calls in async functions can cause thread "
+    "starvation and deadlocks."
+)
+
+_SLEEP_IN_ASYNC_SUGGESTION = (
+    "Use tokio::time::sleep instead of std::thread::sleep in async functions. "
+    "Blocking the thread with std::thread::sleep prevents the async runtime from "
+    "processing other tasks on the same thread."
+)
+
+_NET_IN_ASYNC_SUGGESTION = (
+    "Use tokio::net equivalents (e.g., tokio::net::TcpStream) for async-compatible "
+    "networking. Blocking std::net calls in async functions can cause thread starvation "
+    "and deadlocks in the async runtime."
+)
+
+
+def build_fs_in_async_violation(
+    file_path: str,
+    line: int,
+    column: int,
+    context: str,
+) -> Violation:
+    """Build a violation for std::fs operation inside an async function."""
+    message = f"Blocking std::fs operation inside async function: {context}"
+
+    return Violation(
+        rule_id="blocking-async.fs-in-async",
+        file_path=file_path,
+        line=line,
+        column=column,
+        message=message,
+        suggestion=_FS_IN_ASYNC_SUGGESTION,
+    )
+
+
+def build_sleep_in_async_violation(
+    file_path: str,
+    line: int,
+    column: int,
+    context: str,
+) -> Violation:
+    """Build a violation for std::thread::sleep inside an async function."""
+    message = f"Blocking std::thread::sleep inside async function: {context}"
+
+    return Violation(
+        rule_id="blocking-async.sleep-in-async",
+        file_path=file_path,
+        line=line,
+        column=column,
+        message=message,
+        suggestion=_SLEEP_IN_ASYNC_SUGGESTION,
+    )
+
+
+def build_net_in_async_violation(
+    file_path: str,
+    line: int,
+    column: int,
+    context: str,
+) -> Violation:
+    """Build a violation for blocking std::net operation inside an async function."""
+    message = f"Blocking std::net operation inside async function: {context}"
+
+    return Violation(
+        rule_id="blocking-async.net-in-async",
+        file_path=file_path,
+        line=line,
+        column=column,
+        message=message,
+        suggestion=_NET_IN_ASYNC_SUGGESTION,
+    )