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

src/linters/dry/typescript_analyzer.py

@@ -19,6 +19,11 @@ Interfaces: TypeScriptDuplicateAnalyzer.analyze(file_path: Path, content: str, c
 Implementation: Inherits analyze() workflow from BaseTokenAnalyzer, adds JSDoc comment extraction,
     single statement detection using tree-sitter AST patterns, and interface filtering logic
 
+Suppressions:
+    - type:ignore[assignment,misc]: Tree-sitter Node type alias (optional dependency fallback)
+    - invalid-name: Node type alias follows tree-sitter naming convention
+    - srp.violation: Complex tree-sitter AST analysis algorithm. See SRP Exception below.
+
 SRP Exception: TypeScriptDuplicateAnalyzer has 20 methods and 324 lines (exceeds max 8 methods/200 lines)
     Justification: Complex tree-sitter AST analysis algorithm for duplicate code detection with sophisticated
     false positive filtering. Mirrors Python analyzer structure. Methods form tightly coupled algorithm
@@ -30,15 +35,17 @@ SRP Exception: TypeScriptDuplicateAnalyzer has 20 methods and 324 lines (exceeds
     responsibility: accurately detecting duplicate TypeScript/JavaScript code while minimizing false positives.
 """
 
-from collections.abc import Generator
+from collections.abc import Iterable
 from pathlib import Path
 
 from src.analyzers.typescript_base import TREE_SITTER_AVAILABLE
 
+from . import token_hasher
 from .base_token_analyzer import BaseTokenAnalyzer
 from .block_filter import BlockFilterRegistry, create_default_registry
 from .cache import CodeBlock
 from .config import DRYConfig
+from .typescript_statement_detector import is_single_statement, should_include_block
 
 if TREE_SITTER_AVAILABLE:
     from tree_sitter import Node
@@ -84,16 +91,33 @@ class TypeScriptDuplicateAnalyzer(BaseTokenAnalyzer):  # thailint: ignore[srp.vi
         # Generate rolling hash windows
         windows = self._rolling_hash_with_tracking(lines_with_numbers, config.min_duplicate_lines)
 
-        blocks = []
-        for hash_val, start_line, end_line, snippet in windows:
-            # Filter interface/type definitions
-            if not self._should_include_block(content, start_line, end_line):
-                continue
+        # Filter out interface/type definitions and single statement patterns
+        valid_windows = (
+            (hash_val, start_line, end_line, snippet)
+            for hash_val, start_line, end_line, snippet in windows
+            if should_include_block(content, start_line, end_line)
+            and not is_single_statement(content, start_line, end_line)
+        )
+        return self._build_blocks(valid_windows, file_path, content)
+
+    def _build_blocks(
+        self,
+        windows: Iterable[tuple[int, int, int, str]],
+        file_path: Path,
+        content: str,
+    ) -> list[CodeBlock]:
+        """Build CodeBlock objects from valid windows, applying filters.
 
-            # Filter single statement patterns
-            if self._is_single_statement_in_source(content, start_line, end_line):
-                continue
+        Args:
+            windows: Iterable of (hash_val, start_line, end_line, snippet) tuples
+            file_path: Path to source file
+            content: File content
 
+        Returns:
+            List of CodeBlock instances that pass all filters
+        """
+        blocks = []
+        for hash_val, start_line, end_line, snippet in windows:
             block = CodeBlock(
                 file_path=file_path,
                 start_line=start_line,
@@ -101,13 +125,8 @@ class TypeScriptDuplicateAnalyzer(BaseTokenAnalyzer):  # thailint: ignore[srp.vi
                 snippet=snippet,
                 hash_value=hash_val,
             )
-
-            # Apply extensible filters (keyword arguments, imports, etc.)
-            if self._filter_registry.should_filter_block(block, content):
-                continue
-
-            blocks.append(block)
-
+            if not self._filter_registry.should_filter_block(block, content):
+                blocks.append(block)
         return blocks
 
     def _get_jsdoc_ranges_from_content(self, content: str) -> set[int]:
@@ -186,25 +205,45 @@ class TypeScriptDuplicateAnalyzer(BaseTokenAnalyzer):  # thailint: ignore[srp.vi
             List of (original_line_number, normalized_code) tuples
         """
         lines_with_numbers = []
+        in_multiline_import = False
 
-        for line_num, line in enumerate(content.split("\n"), start=1):
-            # Skip JSDoc comment lines
-            if line_num in jsdoc_lines:
-                continue
+        # Skip JSDoc comment lines
+        non_jsdoc_lines = (
+            (line_num, line)
+            for line_num, line in enumerate(content.split("\n"), start=1)
+            if line_num not in jsdoc_lines
+        )
+        for line_num, line in non_jsdoc_lines:
+            in_multiline_import, normalized = self._normalize_and_filter_line(
+                line, in_multiline_import
+            )
+            if normalized is not None:
+                lines_with_numbers.append((line_num, normalized))
 
-            # Use hasher's existing tokenization logic
-            line = self._hasher._strip_comments(line)  # pylint: disable=protected-access
-            line = " ".join(line.split())
+        return lines_with_numbers
 
-            if not line:
-                continue
+    def _normalize_and_filter_line(
+        self, line: str, in_multiline_import: bool
+    ) -> tuple[bool, str | None]:
+        """Normalize line and check if it should be included.
 
-            if self._hasher._is_import_statement(line):  # pylint: disable=protected-access
-                continue
+        Args:
+            line: Raw source line
+            in_multiline_import: Current multi-line import state
 
-            lines_with_numbers.append((line_num, line))
+        Returns:
+            Tuple of (new_import_state, normalized_line or None if should skip)
+        """
+        normalized = token_hasher.normalize_line(line)
+        if not normalized:
+            return in_multiline_import, None
 
-        return lines_with_numbers
+        new_state, should_skip = token_hasher.should_skip_import_line(
+            normalized, in_multiline_import
+        )
+        if should_skip:
+            return new_state, None
+        return new_state, normalized
 
     def _rolling_hash_with_tracking(
         self, lines_with_numbers: list[tuple[int, str]], window_size: int
@@ -237,354 +276,3 @@ class TypeScriptDuplicateAnalyzer(BaseTokenAnalyzer):  # thailint: ignore[srp.vi
             hashes.append((hash_val, start_line, end_line, snippet))
 
         return hashes
-
-    def _should_include_block(self, content: str, start_line: int, end_line: int) -> bool:
-        """Filter out blocks that overlap with interface/type definitions.
-
-        Args:
-            content: File content
-            start_line: Block start line
-            end_line: Block end line
-
-        Returns:
-            False if block overlaps interface definition, True otherwise
-        """
-        interface_ranges = self._find_interface_ranges(content)
-        return not self._overlaps_interface(start_line, end_line, interface_ranges)
-
-    def _is_single_statement_in_source(self, content: str, start_line: int, end_line: int) -> bool:
-        """Check if a line range in the original source is a single logical statement.
-
-        Uses tree-sitter AST analysis to detect patterns like:
-        - Decorators (@Component(...))
-        - Function call arguments
-        - Object literal properties
-        - Class field definitions
-        - Type assertions
-        - Chained method calls (single expression)
-
-        Args:
-            content: TypeScript source code
-            start_line: Starting line number (1-indexed)
-            end_line: Ending line number (1-indexed)
-
-        Returns:
-            True if this range represents a single logical statement/expression
-        """
-        if not TREE_SITTER_AVAILABLE:
-            return False
-
-        from src.analyzers.typescript_base import TypeScriptBaseAnalyzer
-
-        analyzer = TypeScriptBaseAnalyzer()
-        root = analyzer.parse_typescript(content)
-        if not root:
-            return False
-
-        return self._check_overlapping_nodes(root, start_line, end_line)
-
-    def _check_overlapping_nodes(self, root: Node, start_line: int, end_line: int) -> bool:
-        """Check if any AST node overlaps and matches single-statement pattern.
-
-        Args:
-            root: Root tree-sitter node
-            start_line: Starting line number (1-indexed)
-            end_line: Ending line number (1-indexed)
-
-        Returns:
-            True if any node matches single-statement pattern
-        """
-        # Convert to 0-indexed for tree-sitter
-        ts_start = start_line - 1
-        ts_end = end_line - 1
-
-        for node in self._walk_nodes(root):
-            if self._node_overlaps_and_matches(node, ts_start, ts_end):
-                return True
-        return False
-
-    def _walk_nodes(self, node: Node) -> Generator[Node, None, None]:
-        """Generator to walk all nodes in tree.
-
-        Args:
-            node: Starting node
-
-        Yields:
-            All nodes in tree
-        """
-        yield node
-        for child in node.children:
-            yield from self._walk_nodes(child)
-
-    def _node_overlaps_and_matches(self, node: Node, ts_start: int, ts_end: int) -> bool:
-        """Check if node overlaps with range and matches single-statement pattern.
-
-        Args:
-            node: Tree-sitter node
-            ts_start: Starting line (0-indexed)
-            ts_end: Ending line (0-indexed)
-
-        Returns:
-            True if node overlaps and matches pattern
-        """
-        node_start = node.start_point[0]
-        node_end = node.end_point[0]
-
-        # Check if ranges overlap
-        overlaps = not (node_end < ts_start or node_start > ts_end)
-        if not overlaps:
-            return False
-
-        return self._is_single_statement_pattern(node, ts_start, ts_end)
-
-    def _matches_simple_container_pattern(self, node: Node, contains: bool) -> bool:
-        """Check if node is a simple container pattern (decorator, object, etc.).
-
-        Args:
-            node: AST node to check
-            contains: Whether node contains the range
-
-        Returns:
-            True if node matches simple container pattern
-        """
-        simple_types = (
-            "decorator",
-            "object",
-            "member_expression",
-            "as_expression",
-            "array_pattern",
-        )
-        return node.type in simple_types and contains
-
-    def _matches_call_expression_pattern(
-        self, node: Node, ts_start: int, ts_end: int, contains: bool
-    ) -> bool:
-        """Check if node is a call expression pattern.
-
-        Args:
-            node: AST node to check
-            ts_start: Starting line (0-indexed)
-            ts_end: Ending line (0-indexed)
-            contains: Whether node contains the range
-
-        Returns:
-            True if node matches call expression pattern
-        """
-        if node.type != "call_expression":
-            return False
-
-        # Check if this is a multi-line call containing the range
-        node_start = node.start_point[0]
-        node_end = node.end_point[0]
-        is_multiline = node_start < node_end
-        if is_multiline and node_start <= ts_start <= node_end:
-            return True
-
-        return contains
-
-    def _matches_declaration_pattern(self, node: Node, contains: bool) -> bool:
-        """Check if node is a lexical declaration pattern.
-
-        Args:
-            node: AST node to check
-            contains: Whether node contains the range
-
-        Returns:
-            True if node matches declaration pattern (excluding function bodies)
-        """
-        if node.type != "lexical_declaration" or not contains:
-            return False
-
-        # Only filter if simple value assignment, NOT a function body
-        if self._contains_function_body(node):
-            return False
-
-        return True
-
-    def _matches_jsx_pattern(self, node: Node, contains: bool) -> bool:
-        """Check if node is a JSX element pattern.
-
-        Args:
-            node: AST node to check
-            contains: Whether node contains the range
-
-        Returns:
-            True if node matches JSX pattern
-        """
-        jsx_types = ("jsx_opening_element", "jsx_self_closing_element")
-        return node.type in jsx_types and contains
-
-    def _matches_class_body_pattern(self, node: Node, ts_start: int, ts_end: int) -> bool:
-        """Check if node is a class body field definition pattern.
-
-        Args:
-            node: AST node to check
-            ts_start: Starting line (0-indexed)
-            ts_end: Ending line (0-indexed)
-
-        Returns:
-            True if node is class body with field definitions
-        """
-        if node.type != "class_body":
-            return False
-
-        return self._is_in_class_field_area(node, ts_start, ts_end)
-
-    def _is_single_statement_pattern(self, node: Node, ts_start: int, ts_end: int) -> bool:
-        """Check if an AST node represents a single-statement pattern to filter.
-
-        Delegates to specialized pattern matchers for different AST node categories.
-
-        Args:
-            node: AST node that overlaps with the line range
-            ts_start: Starting line number (0-indexed)
-            ts_end: Ending line number (0-indexed)
-
-        Returns:
-            True if this node represents a single logical statement pattern
-        """
-        node_start = node.start_point[0]
-        node_end = node.end_point[0]
-        contains = (node_start <= ts_start) and (node_end >= ts_end)
-
-        # Check pattern categories using specialized helpers - use list for any()
-        matchers = [
-            self._matches_simple_container_pattern(node, contains),
-            self._matches_call_expression_pattern(node, ts_start, ts_end, contains),
-            self._matches_declaration_pattern(node, contains),
-            self._matches_jsx_pattern(node, contains),
-            self._matches_class_body_pattern(node, ts_start, ts_end),
-        ]
-        return any(matchers)
-
-    def _contains_function_body(self, node: Node) -> bool:
-        """Check if node contains an arrow function or function expression.
-
-        Args:
-            node: Node to check
-
-        Returns:
-            True if node contains a function with a body
-        """
-        for child in node.children:
-            if child.type in ("arrow_function", "function", "function_expression"):
-                return True
-            if self._contains_function_body(child):
-                return True
-        return False
-
-    def _find_first_method_line(self, class_body: Node) -> int | None:
-        """Find line number of first method in class body.
-
-        Args:
-            class_body: Class body node
-
-        Returns:
-            Line number of first method or None if no methods
-        """
-        for child in class_body.children:
-            if child.type in ("method_definition", "function_declaration"):
-                return child.start_point[0]
-        return None
-
-    def _is_in_class_field_area(self, class_body: Node, ts_start: int, ts_end: int) -> bool:
-        """Check if range is in class field definition area (before methods).
-
-        Args:
-            class_body: Class body node
-            ts_start: Starting line (0-indexed)
-            ts_end: Ending line (0-indexed)
-
-        Returns:
-            True if range is in field area
-        """
-        first_method_line = self._find_first_method_line(class_body)
-        class_start = class_body.start_point[0]
-        class_end = class_body.end_point[0]
-
-        # No methods: check if range is in class body
-        if first_method_line is None:
-            return class_start <= ts_start and class_end >= ts_end
-
-        # Has methods: check if range is before first method
-        return class_start <= ts_start and ts_end < first_method_line
-
-    def _find_interface_ranges(self, content: str) -> list[tuple[int, int]]:
-        """Find line ranges of interface/type definitions.
-
-        Args:
-            content: File content
-
-        Returns:
-            List of (start_line, end_line) tuples for interface blocks
-        """
-        ranges: list[tuple[int, int]] = []
-        lines = content.split("\n")
-        state = {"in_interface": False, "start_line": 0, "brace_count": 0}
-
-        for i, line in enumerate(lines, start=1):
-            stripped = line.strip()
-            self._process_line_for_interface(stripped, i, state, ranges)
-
-        return ranges
-
-    def _process_line_for_interface(
-        self, stripped: str, line_num: int, state: dict, ranges: list[tuple[int, int]]
-    ) -> None:
-        """Process single line for interface detection.
-
-        Args:
-            stripped: Stripped line content
-            line_num: Line number
-            state: Tracking state (in_interface, start_line, brace_count)
-            ranges: Accumulated interface ranges
-        """
-        if self._is_interface_start(stripped):
-            self._handle_interface_start(stripped, line_num, state, ranges)
-            return
-
-        if state["in_interface"]:
-            self._handle_interface_continuation(stripped, line_num, state, ranges)
-
-    def _is_interface_start(self, stripped: str) -> bool:
-        """Check if line starts interface/type definition."""
-        return stripped.startswith(("interface ", "type ")) and "{" in stripped
-
-    def _handle_interface_start(
-        self, stripped: str, line_num: int, state: dict, ranges: list[tuple[int, int]]
-    ) -> None:
-        """Handle start of interface definition."""
-        state["in_interface"] = True
-        state["start_line"] = line_num
-        state["brace_count"] = stripped.count("{") - stripped.count("}")
-
-        if state["brace_count"] == 0:  # Single-line interface
-            ranges.append((line_num, line_num))
-            state["in_interface"] = False
-
-    def _handle_interface_continuation(
-        self, stripped: str, line_num: int, state: dict, ranges: list[tuple[int, int]]
-    ) -> None:
-        """Handle continuation of interface definition."""
-        state["brace_count"] += stripped.count("{") - stripped.count("}")
-        if state["brace_count"] == 0:
-            ranges.append((state["start_line"], line_num))
-            state["in_interface"] = False
-
-    def _overlaps_interface(
-        self, start: int, end: int, interface_ranges: list[tuple[int, int]]
-    ) -> bool:
-        """Check if block overlaps with any interface range.
-
-        Args:
-            start: Block start line
-            end: Block end line
-            interface_ranges: List of interface definition ranges
-
-        Returns:
-            True if block overlaps with an interface
-        """
-        for if_start, if_end in interface_ranges:
-            if start <= if_end and end >= if_start:
-                return True
-        return False

src/linters/dry/typescript_constant_extractor.py

@@ -0,0 +1,138 @@
+"""
+Purpose: Extract TypeScript module-level constants using tree-sitter parsing
+
+Scope: TypeScript constant extraction for duplicate constants detection
+
+Overview: Extracts module-level constant definitions from TypeScript source code using tree-sitter.
+    Identifies constants as top-level `const` declarations where the variable name matches the
+    UPPER_SNAKE_CASE naming convention (e.g., const API_TIMEOUT = 30). Excludes non-const
+    declarations (let, var), class-level constants, and function-level constants to focus on
+    public module constants that should be consolidated across files.
+
+Dependencies: tree-sitter, tree-sitter-typescript, re for pattern matching, ConstantInfo,
+    TypeScriptValueExtractor
+
+Exports: TypeScriptConstantExtractor class
+
+Interfaces: TypeScriptConstantExtractor.extract(content: str) -> list[ConstantInfo]
+
+Implementation: Tree-sitter-based parsing with const declaration filtering and ALL_CAPS regex matching
+
+Suppressions:
+    - type:ignore[assignment,misc]: Tree-sitter Node type alias (optional dependency fallback)
+    - broad-exception-caught: Defensive parsing for malformed TypeScript code
+"""
+
+from typing import Any
+
+from src.analyzers.typescript_base import TREE_SITTER_AVAILABLE, TS_PARSER
+
+from .constant import CONSTANT_NAME_PATTERN, ConstantInfo
+from .typescript_value_extractor import TypeScriptValueExtractor
+
+if TREE_SITTER_AVAILABLE:
+    from tree_sitter import Node
+else:
+    Node = Any  # type: ignore[assignment,misc]
+
+# Node types that represent values
+VALUE_TYPES = frozenset(
+    (
+        "number",
+        "string",
+        "true",
+        "false",
+        "null",
+        "identifier",
+        "array",
+        "object",
+        "call_expression",
+    )
+)
+
+
+class TypeScriptConstantExtractor:
+    """Extracts module-level constants from TypeScript source code."""
+
+    def __init__(self) -> None:
+        """Initialize the TypeScript constant extractor."""
+        self.tree_sitter_available = TREE_SITTER_AVAILABLE
+        self._value_extractor = TypeScriptValueExtractor()
+
+    def extract(self, content: str) -> list[ConstantInfo]:
+        """Extract constants from TypeScript source code."""
+        root = _parse_content(content)
+        if root is None:
+            return []
+        constants: list[ConstantInfo] = []
+        for child in root.children:
+            constants.extend(self._extract_from_node(child, content))
+        return constants
+
+    def _extract_from_node(self, node: Node, content: str) -> list[ConstantInfo]:
+        """Extract constants from a single AST node."""
+        if node.type == "lexical_declaration":
+            return self._extract_from_lexical_declaration(node, content)
+        if node.type == "export_statement":
+            return self._extract_from_export(node, content)
+        return []
+
+    def _extract_from_lexical_declaration(self, node: Node, content: str) -> list[ConstantInfo]:
+        """Extract constants from a lexical declaration."""
+        if not _is_const_declaration(node):
+            return []
+        return [
+            info
+            for c in node.children
+            if c.type == "variable_declarator"
+            and (info := self._extract_from_declarator(c, content))
+        ]
+
+    def _extract_from_export(self, node: Node, content: str) -> list[ConstantInfo]:
+        """Extract constants from an export statement."""
+        for child in node.children:
+            if child.type == "lexical_declaration":
+                return self._extract_from_lexical_declaration(child, content)
+        return []
+
+    def _extract_from_declarator(self, node: Node, content: str) -> ConstantInfo | None:
+        """Extract constant info from a variable declarator."""
+        name, value = _get_name_and_value(node, content, self._value_extractor)
+        if not name or not _is_constant_name(name):
+            return None
+        return ConstantInfo(name=name, line_number=node.start_point[0] + 1, value=value)
+
+
+def _parse_content(content: str) -> Node | None:
+    """Parse content and return root node, or None on failure."""
+    if not TREE_SITTER_AVAILABLE or TS_PARSER is None:
+        return None
+    try:
+        return TS_PARSER.parse(bytes(content, "utf8")).root_node
+    except Exception:  # pylint: disable=broad-exception-caught
+        return None
+
+
+def _is_const_declaration(node: Node) -> bool:
+    """Check if lexical declaration is a const."""
+    return any(child.type == "const" for child in node.children)
+
+
+def _get_name_and_value(
+    node: Node, content: str, extractor: TypeScriptValueExtractor
+) -> tuple[str | None, str | None]:
+    """Extract name and value from declarator node."""
+    name = next(
+        (extractor.get_node_text(c, content) for c in node.children if c.type == "identifier"),
+        None,
+    )
+    value = next(
+        (extractor.get_value_string(c, content) for c in node.children if c.type in VALUE_TYPES),
+        None,
+    )
+    return name, value
+
+
+def _is_constant_name(name: str) -> bool:
+    """Check if name matches constant naming convention."""
+    return not name.startswith("_") and bool(CONSTANT_NAME_PATTERN.match(name))