thailint 0.5.0__py3-none-any.whl → 0.15.3__py3-none-any.whl

src/linters/performance/regex_linter.py

@@ -0,0 +1,139 @@
+"""
+Purpose: Regex compilation in loop linter rule implementation
+
+Scope: RegexInLoopRule class implementing MultiLanguageLintRule interface
+
+Overview: Implements regex-in-loop linter rule following MultiLanguageLintRule interface.
+    Orchestrates configuration loading, Python analysis, and violation building through
+    focused helper classes. Detects repeated regex compilation patterns using re.method()
+    calls in loops instead of pre-compiled patterns. Supports configurable enabled flag
+    and ignore directives. Main rule class acts as coordinator for regex detection workflow.
+
+Dependencies: MultiLanguageLintRule, BaseLintContext, PythonRegexInLoopAnalyzer,
+    PerformanceViolationBuilder
+
+Exports: RegexInLoopRule class
+
+Interfaces: RegexInLoopRule.check(context) -> list[Violation], properties for rule metadata
+
+Implementation: Composition pattern with analyzer classes, AST-based analysis
+
+"""
+
+from typing import Any
+
+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
+from src.linter_config.ignore import get_ignore_parser
+
+from .config import PerformanceConfig
+from .regex_analyzer import PythonRegexInLoopAnalyzer
+from .violation_builder import PerformanceViolationBuilder
+
+
+class RegexInLoopRule(MultiLanguageLintRule):
+    """Detects regex compilation in loops."""
+
+    def __init__(self) -> None:
+        """Initialize the regex in loop rule."""
+        self._ignore_parser = get_ignore_parser()
+        self._violation_builder = PerformanceViolationBuilder(self.rule_id)
+        self._python_analyzer = PythonRegexInLoopAnalyzer()
+
+    @property
+    def rule_id(self) -> str:
+        """Unique identifier for this rule."""
+        return "performance.regex-in-loop"
+
+    @property
+    def rule_name(self) -> str:
+        """Human-readable name for this rule."""
+        return "Regex Compilation in Loop"
+
+    @property
+    def description(self) -> str:
+        """Description of what this rule checks."""
+        return "re.method() in loops recompiles pattern each iteration; use re.compile() instead"
+
+    def _load_config(self, context: BaseLintContext) -> PerformanceConfig:
+        """Load configuration from context.
+
+        Args:
+            context: Lint context
+
+        Returns:
+            PerformanceConfig instance
+        """
+        return load_linter_config(context, "performance", PerformanceConfig)
+
+    def _check_python(self, context: BaseLintContext, config: PerformanceConfig) -> list[Violation]:
+        """Check Python code for regex compilation in loops.
+
+        Args:
+            context: Lint context with Python file information
+            config: Performance configuration
+
+        Returns:
+            List of violations found in Python code
+        """
+        return with_parsed_python(
+            context,
+            self._violation_builder,
+            lambda tree: self._analyze_python_regex(tree, context),
+        )
+
+    def _analyze_python_regex(self, tree: Any, context: BaseLintContext) -> list[Violation]:
+        """Analyze parsed Python AST for regex in loops."""
+        violations_raw = self._python_analyzer.find_violations(tree)
+        return self._build_violations(violations_raw, context)
+
+    def _check_typescript(
+        self, context: BaseLintContext, config: PerformanceConfig
+    ) -> list[Violation]:
+        """Check TypeScript code for regex compilation in loops.
+
+        Args:
+            context: Lint context with TypeScript file information
+            config: Performance configuration
+
+        Returns:
+            Empty list - TypeScript regex handling is different from Python
+        """
+        # TypeScript uses RegExp objects differently, not implemented
+        return []
+
+    def _build_violations(self, raw_violations: list, context: BaseLintContext) -> list[Violation]:
+        """Build Violation objects from analyzer results.
+
+        Args:
+            raw_violations: List of RegexInLoopViolation dataclass instances
+            context: Lint context
+
+        Returns:
+            List of Violation objects
+        """
+        violations = []
+        for v in raw_violations:
+            violation = self._violation_builder.create_regex_in_loop_violation(
+                method_name=v.method_name,
+                line_number=v.line_number,
+                column=v.column,
+                loop_type=v.loop_type,
+                context=context,
+            )
+            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.
+
+        Args:
+            violation: Violation to check
+            context: Lint context with file content
+
+        Returns:
+            True if violation should be ignored
+        """
+        return self._ignore_parser.should_ignore_violation(violation, context.file_content or "")

src/linters/performance/typescript_analyzer.py

@@ -0,0 +1,236 @@
+"""
+Purpose: TypeScript tree-sitter based string concatenation in loop detector
+
+Scope: Detect O(n²) string building patterns using += in TypeScript loops
+
+Overview: Analyzes TypeScript code to detect string concatenation inside loops using tree-sitter.
+    Implements heuristic-based detection using variable naming patterns and initialization values.
+    Detects `result += item` patterns inside for/while/do loops that indicate O(n²) complexity.
+    Provides suggestions for using join() or array-based building instead.
+
+Dependencies: TypeScriptBaseAnalyzer, tree-sitter, tree-sitter-typescript, constants module
+
+Exports: TypeScriptStringConcatAnalyzer class with find_violations method
+
+Interfaces: find_violations(root_node) -> list[dict] with violation info
+
+Implementation: Tree-sitter traversal detecting augmented assignments in loop contexts
+
+Suppressions:
+    - srp.violation: Class uses many small methods to achieve A-grade cyclomatic complexity.
+      This is an intentional tradeoff - low complexity is prioritized over strict SRP adherence.
+"""
+
+from dataclasses import dataclass
+
+from src.analyzers.typescript_base import (
+    TREE_SITTER_AVAILABLE,
+    Node,
+    TypeScriptBaseAnalyzer,
+)
+
+from .constants import LOOP_NODE_TYPES_TS, STRING_VARIABLE_PATTERNS
+
+
+@dataclass
+class StringConcatViolation:
+    """Represents a string concatenation violation found in code."""
+
+    variable_name: str
+    line_number: int
+    column: int
+    loop_type: str  # 'for', 'for_in', 'while', 'do'
+
+
+# thailint: ignore-next-line[srp.violation] Uses small focused methods to reduce complexity
+class TypeScriptStringConcatAnalyzer(TypeScriptBaseAnalyzer):
+    """Detects string concatenation in loops for TypeScript code."""
+
+    def __init__(self) -> None:
+        """Initialize the analyzer."""
+        super().__init__()
+        self._string_variables: set[str] = set()
+
+    def find_violations(self, root_node: Node) -> list[StringConcatViolation]:
+        """Find all string concatenation in loop violations.
+
+        Args:
+            root_node: Tree-sitter AST root node
+
+        Returns:
+            List of violations found
+        """
+        if not TREE_SITTER_AVAILABLE or root_node is None:
+            return []
+
+        violations: list[StringConcatViolation] = []
+        self._string_variables = set()
+
+        # First pass: identify variables initialized as strings
+        self._identify_string_variables(root_node)
+
+        # Second pass: find += in loops
+        self._find_concat_in_loops(root_node, violations, None)
+
+        return violations
+
+    def _identify_string_variables(self, node: Node) -> None:
+        """Identify variables that are initialized as strings.
+
+        Args:
+            node: AST node to analyze
+        """
+        self._check_variable_declarator(node)
+        for child in node.children:
+            self._identify_string_variables(child)
+
+    def _check_variable_declarator(self, node: Node) -> None:
+        """Check if a variable_declarator node initializes a string variable."""
+        if node.type != "variable_declarator":
+            return
+        name_node = self.find_child_by_type(node, "identifier")
+        value_node = self._find_string_value(node)
+        if name_node and value_node:
+            self._string_variables.add(self.extract_node_text(name_node))
+
+    def _find_string_value(self, node: Node) -> Node | None:
+        """Find a string or template_string child node."""
+        for child in node.children:
+            if child.type in ("string", "template_string"):
+                return child
+        return None
+
+    def _find_concat_in_loops(
+        self, node: Node, violations: list[StringConcatViolation], loop_type: str | None
+    ) -> None:
+        """Recursively find string concatenation in loops.
+
+        Args:
+            node: Current AST node
+            violations: List to append violations to
+            loop_type: Type of enclosing loop, None if not in loop
+        """
+        # Track loop entry
+        current_loop = loop_type
+        if node.type in LOOP_NODE_TYPES_TS:
+            current_loop = node.type.replace("_statement", "").replace("_", "_")
+
+        # Check for augmented assignment (+=)
+        if node.type == "augmented_assignment_expression" and current_loop:
+            self._check_augmented_assignment(node, violations, current_loop)
+
+        # Recurse into children
+        for child in node.children:
+            self._find_concat_in_loops(child, violations, current_loop)
+
+    def _check_augmented_assignment(
+        self, node: Node, violations: list[StringConcatViolation], loop_type: str
+    ) -> None:
+        """Check if an augmented assignment is string concatenation.
+
+        Args:
+            node: Augmented assignment node
+            violations: List to append violations to
+            loop_type: Type of enclosing loop
+        """
+        if not self._is_plus_equals(node):
+            return
+        var_name = self._get_var_name(node)
+        if not var_name:
+            return
+        value_node = self._get_value_node(node)
+        if self._is_likely_string_variable(var_name, value_node):
+            self._create_violation(node, var_name, loop_type, violations)
+
+    def _is_plus_equals(self, node: Node) -> bool:
+        """Check if node has a += operator."""
+        return any(child.type == "+=" for child in node.children)
+
+    def _get_var_name(self, node: Node) -> str | None:
+        """Get the variable name from an augmented assignment."""
+        for child in node.children:
+            if child.type == "identifier":
+                return self.extract_node_text(child)
+        return None
+
+    def _get_value_node(self, node: Node) -> Node | None:
+        """Get the value node from an augmented assignment."""
+        children = node.children
+        operator_idx = self._find_plus_equals_index(children)
+        if operator_idx < 0:
+            return None
+        return self._find_value_after_operator(children, operator_idx)
+
+    def _find_plus_equals_index(self, children: list[Node]) -> int:
+        """Find the index of the += operator in children."""
+        for i, child in enumerate(children):
+            if child.type == "+=":
+                return i
+        return -1
+
+    def _find_value_after_operator(self, children: list[Node], operator_idx: int) -> Node | None:
+        """Find the first non-identifier value after the operator."""
+        for child in children[operator_idx + 1 :]:
+            if child.type != "identifier":
+                return child
+        return None
+
+    def _create_violation(
+        self, node: Node, var_name: str, loop_type: str, violations: list[StringConcatViolation]
+    ) -> None:
+        """Create and append a string concat violation."""
+        violations.append(
+            StringConcatViolation(
+                variable_name=var_name,
+                line_number=node.start_point[0] + 1,
+                column=node.start_point[1],
+                loop_type=loop_type,
+            )
+        )
+
+    def _is_likely_string_variable(self, var_name: str, value_node: Node | None) -> bool:
+        """Determine if a variable is likely a string being concatenated.
+
+        Args:
+            var_name: Variable name
+            value_node: Value being added (may be None)
+
+        Returns:
+            True if this is likely string concatenation
+        """
+        return self._is_known_string_var(var_name) or self._is_string_value_node(value_node)
+
+    def _is_known_string_var(self, var_name: str) -> bool:
+        """Check if variable is known or named like a string."""
+        return var_name in self._string_variables or var_name.lower() in STRING_VARIABLE_PATTERNS
+
+    def _is_string_value_node(self, value_node: Node | None) -> bool:
+        """Check if value node is a string or contains a string."""
+        if not value_node:
+            return False
+        if value_node.type in ("string", "template_string"):
+            return True
+        if value_node.type == "binary_expression":
+            return any(child.type in ("string", "template_string") for child in value_node.children)
+        return False
+
+    def deduplicate_violations(
+        self, violations: list[StringConcatViolation]
+    ) -> list[StringConcatViolation]:
+        """Deduplicate violations to report one per variable.
+
+        Args:
+            violations: List of all violations found
+
+        Returns:
+            Deduplicated list with one violation per variable
+        """
+        seen: set[str] = set()
+        result: list[StringConcatViolation] = []
+
+        for v in violations:
+            if v.variable_name not in seen:
+                seen.add(v.variable_name)
+                result.append(v)
+
+        return result

src/linters/performance/violation_builder.py

@@ -0,0 +1,160 @@
+"""
+Purpose: Violation creation for performance linter rules
+
+Scope: Builds Violation objects for string-concat-loop and regex-in-loop rules
+
+Overview: Provides violation building functionality for the performance linter. Creates
+    violations for string concatenation in loops with contextual error messages,
+    variable names, and actionable refactoring suggestions (use join(), list comprehension).
+    Handles syntax errors gracefully. Isolates violation construction from analysis logic.
+
+Dependencies: BaseLintContext, Violation, Severity, PerformanceConfig, src.core.violation_builder
+
+Exports: PerformanceViolationBuilder
+
+Interfaces: create_string_concat_violation, create_syntax_error_violation
+
+Implementation: Formats messages with variable names, provides targeted refactoring suggestions,
+    extends BaseViolationBuilder for consistent violation construction
+
+Suppressions:
+    - too-many-arguments,too-many-positional-arguments: Violation builder methods inherently
+      require multiple parameters (variable_name, line, column, loop_type, context)
+"""
+
+from src.core.base import BaseLintContext
+from src.core.types import Severity, Violation
+from src.core.violation_builder import BaseViolationBuilder
+
+
+class PerformanceViolationBuilder(BaseViolationBuilder):
+    """Builds violations for performance issues."""
+
+    def __init__(self, rule_id: str):
+        """Initialize violation builder.
+
+        Args:
+            rule_id: Rule identifier for violations
+        """
+        self.rule_id = rule_id
+
+    def create_syntax_error_violation(
+        self, error: SyntaxError, context: BaseLintContext
+    ) -> Violation:
+        """Create violation for syntax error.
+
+        Args:
+            error: SyntaxError exception
+            context: Lint context
+
+        Returns:
+            Syntax error violation
+        """
+        return self.build_from_params(
+            rule_id=self.rule_id,
+            file_path=str(context.file_path or ""),
+            line=error.lineno or 0,
+            column=error.offset or 0,
+            message=f"Syntax error: {error.msg}",
+            severity=Severity.ERROR,
+            suggestion="Fix syntax errors before checking for performance issues",
+        )
+
+    def create_string_concat_violation(  # pylint: disable=too-many-arguments,too-many-positional-arguments
+        self,
+        variable_name: str,
+        line_number: int,
+        column: int,
+        loop_type: str,
+        context: BaseLintContext,
+    ) -> Violation:
+        """Create violation for string concatenation in loop.
+
+        Args:
+            variable_name: Name of the variable being concatenated
+            line_number: Line number of the violation
+            column: Column number of the violation
+            loop_type: Type of loop ('for' or 'while')
+            context: Lint context
+
+        Returns:
+            String concat in loop violation
+        """
+        return self.build_from_params(
+            rule_id=self.rule_id,
+            file_path=str(context.file_path or ""),
+            line=line_number,
+            column=column,
+            message=(
+                f"String concatenation in {loop_type} loop: '{variable_name} +=' "
+                f"creates O(n²) complexity"
+            ),
+            severity=Severity.ERROR,
+            suggestion=self._generate_suggestion(variable_name),
+        )
+
+    def _generate_suggestion(self, variable_name: str) -> str:
+        """Generate refactoring suggestion for string concatenation.
+
+        Args:
+            variable_name: Variable being concatenated
+
+        Returns:
+            Suggestion string with refactoring advice
+        """
+        return (
+            f"Use ''.join() with a list comprehension or generator instead of "
+            f"repeatedly concatenating to '{variable_name}'. "
+            f"Example: {variable_name} = ''.join(items) or "
+            f"{variable_name} = ''.join(str(x) for x in items)"
+        )
+
+    def create_regex_in_loop_violation(  # pylint: disable=too-many-arguments,too-many-positional-arguments
+        self,
+        method_name: str,
+        line_number: int,
+        column: int,
+        loop_type: str,
+        context: BaseLintContext,
+    ) -> Violation:
+        """Create violation for regex function call in loop.
+
+        Args:
+            method_name: Name of the regex method (e.g., 're.match', 'search')
+            line_number: Line number of the violation
+            column: Column number of the violation
+            loop_type: Type of loop ('for' or 'while')
+            context: Lint context
+
+        Returns:
+            Regex in loop violation
+        """
+        return self.build_from_params(
+            rule_id=self.rule_id,
+            file_path=str(context.file_path or ""),
+            line=line_number,
+            column=column,
+            message=(
+                f"Regex compilation in {loop_type} loop: '{method_name}()' "
+                f"recompiles pattern on each iteration"
+            ),
+            severity=Severity.ERROR,
+            suggestion=self._generate_regex_suggestion(method_name),
+        )
+
+    def _generate_regex_suggestion(self, method_name: str) -> str:
+        """Generate refactoring suggestion for regex in loop.
+
+        Args:
+            method_name: Regex method being called
+
+        Returns:
+            Suggestion string with refactoring advice
+        """
+        # Extract just the method name if prefixed with 're.'
+        base_method = method_name.split(".")[-1]
+        return (
+            f"Compile the pattern once outside the loop using re.compile(), "
+            f"then use pattern.{base_method}() inside the loop. "
+            f"Example: pattern = re.compile(r'...'); pattern.{base_method}(text)"
+        )

src/linters/print_statements/config.py

@@ -1,16 +1,7 @@
 """
-File: src/linters/print_statements/config.py
-
 Purpose: Configuration schema for print statements linter
 
-Exports: PrintStatementConfig dataclass
-
-Depends: dataclasses, typing
-
-Implements: PrintStatementConfig(enabled, ignore, allow_in_scripts, console_methods),
-    from_dict class method for loading configuration from dictionary
-
-Related: src/linters/magic_numbers/config.py, src/core/types.py
+Scope: Print statements linter configuration for all supported languages
 
 Overview: Defines configuration schema for print statements linter. Provides PrintStatementConfig
     dataclass with enabled flag, ignore patterns list, allow_in_scripts setting (default True to
@@ -19,9 +10,13 @@ Overview: Defines configuration schema for print statements linter. Provides Pri
     per-directory config overrides through from_dict class method. Integrates with orchestrator's
     configuration system to allow users to customize detection via .thailint.yaml configuration.
 
-Usage: config = PrintStatementConfig.from_dict(yaml_config, language="python")
+Dependencies: dataclasses module for configuration structure, typing module for type hints
+
+Exports: PrintStatementConfig dataclass
+
+Interfaces: from_dict(config, language) -> PrintStatementConfig for configuration loading from dictionary
 
-Notes: Dataclass with defaults matching common use cases, language-specific override support
+Implementation: Dataclass with defaults matching common use cases and language-specific override support
 """
 
 from dataclasses import dataclass, field