thailint 0.12.0__py3-none-any.whl → 0.14.0__py3-none-any.whl

src/linters/lazy_ignores/rule_id_utils.py

@@ -0,0 +1,180 @@
+"""
+Purpose: Pure utility functions for rule ID parsing and matching
+
+Scope: String parsing utilities for comma-separated rule lists and type:ignore formats
+
+Overview: Provides pure functions for parsing and matching rule IDs in various formats
+    used by the lazy-ignores linter. Handles comma-separated rule lists (e.g.,
+    "too-many-arguments,too-many-positional-arguments") and type:ignore bracket
+    formats (e.g., "type:ignore[arg-type,return-value]"). Functions are stateless
+    and can be easily tested in isolation.
+
+Dependencies: None (pure Python string operations)
+
+Exports: extract_type_ignore_bracket, split_comma_list, rule_in_comma_list,
+    rule_in_type_ignore_bracket, any_part_in_set, comma_list_has_used_rule,
+    type_ignore_bracket_has_used_rule
+
+Interfaces: All functions take strings/sets and return strings/bools
+
+Implementation: String parsing with early returns for invalid formats
+"""
+
+TYPE_IGNORE_PREFIX = "type:ignore["
+
+
+def extract_type_ignore_bracket(suppression_key: str) -> str | None:
+    """Extract content from type:ignore[...] format.
+
+    Args:
+        suppression_key: String that may be in type:ignore[rules] format
+
+    Returns:
+        Content between brackets, or None if not valid format
+    """
+    if not suppression_key.startswith(TYPE_IGNORE_PREFIX):
+        return None
+    if not suppression_key.endswith("]"):
+        return None
+    return suppression_key[len(TYPE_IGNORE_PREFIX) : -1]
+
+
+def split_comma_list(content: str) -> list[str]:
+    """Split comma-separated string into stripped parts.
+
+    Args:
+        content: Comma-separated string
+
+    Returns:
+        List of stripped parts, or empty list if no commas
+    """
+    if "," not in content:
+        return []
+    return [p.strip() for p in content.split(",")]
+
+
+def rule_in_comma_list(rule_id: str, suppression_key: str) -> bool:
+    """Check if rule_id is in a plain comma-separated list.
+
+    Args:
+        rule_id: Normalized rule ID to find
+        suppression_key: String that may contain comma-separated rules
+
+    Returns:
+        True if rule_id is found in the comma-separated parts
+    """
+    parts = split_comma_list(suppression_key)
+    return rule_id in parts
+
+
+def rule_in_type_ignore_bracket(rule_id: str, suppression_key: str) -> bool:
+    """Check if rule_id is in type:ignore[rule1,rule2] format.
+
+    Args:
+        rule_id: Normalized rule ID to find
+        suppression_key: String that may be in type:ignore[rules] format
+
+    Returns:
+        True if rule_id is found in the bracket content
+    """
+    bracket_content = extract_type_ignore_bracket(suppression_key)
+    if bracket_content is None:
+        return False
+    parts = split_comma_list(bracket_content)
+    return rule_id in parts
+
+
+def any_part_in_set(content: str, rule_ids: set[str]) -> bool:
+    """Check if any comma-separated part of content is in rule_ids.
+
+    Args:
+        content: Comma-separated string
+        rule_ids: Set of rule IDs to check against
+
+    Returns:
+        True if any part is in the set
+    """
+    parts = split_comma_list(content)
+    return any(p in rule_ids for p in parts)
+
+
+def comma_list_has_used_rule(suppression_key: str, used_rule_ids: set[str]) -> bool:
+    """Check if any rule in a comma-separated suppression is used.
+
+    Args:
+        suppression_key: Comma-separated suppression key
+        used_rule_ids: Set of rule IDs used in code
+
+    Returns:
+        True if any comma-separated rule is in used_rule_ids
+    """
+    parts = split_comma_list(suppression_key)
+    return any(p in used_rule_ids for p in parts)
+
+
+def type_ignore_bracket_has_used_rule(suppression_key: str, used_rule_ids: set[str]) -> bool:
+    """Check if type:ignore[rules] suppression has any used rule.
+
+    Args:
+        suppression_key: String in type:ignore[rules] format
+        used_rule_ids: Set of rule IDs used in code
+
+    Returns:
+        True if bracket content or any comma part is in used_rule_ids
+    """
+    bracket_content = extract_type_ignore_bracket(suppression_key)
+    if bracket_content is None:
+        return False
+    if bracket_content in used_rule_ids:
+        return True
+    return any_part_in_set(bracket_content, used_rule_ids)
+
+
+def is_type_ignore_format_in_suppressions(normalized: str, suppressions: dict[str, str]) -> bool:
+    """Check if type:ignore[rule] format is in suppressions.
+
+    Args:
+        normalized: Normalized rule ID
+        suppressions: Dict of suppression keys to justifications
+
+    Returns:
+        True if type:ignore[normalized] is in suppressions
+    """
+    return f"type:ignore[{normalized}]" in suppressions
+
+
+def rule_matches_suppression(rule_id: str, suppression_key: str, is_type_ignore: bool) -> bool:
+    """Check if rule_id matches a suppression key (plain or type:ignore format).
+
+    Args:
+        rule_id: Normalized rule ID to find
+        suppression_key: Suppression key to check
+        is_type_ignore: True if this is a type:ignore directive
+
+    Returns:
+        True if rule_id is found in the suppression key
+    """
+    if rule_in_comma_list(rule_id, suppression_key):
+        return True
+    if is_type_ignore:
+        return rule_in_type_ignore_bracket(rule_id, suppression_key)
+    return False
+
+
+def find_rule_in_suppressions(
+    normalized: str, suppressions: dict[str, str], is_type_ignore: bool
+) -> bool:
+    """Check if rule appears in any comma-separated suppression entry.
+
+    Args:
+        normalized: Normalized rule ID to find
+        suppressions: Dict of suppression keys to justifications
+        is_type_ignore: True if this is a type:ignore directive
+
+    Returns:
+        True if rule is found in any suppression's comma list
+    """
+    return any(
+        rule_matches_suppression(normalized, suppression_key, is_type_ignore)
+        for suppression_key in suppressions
+    )

src/linters/lazy_ignores/skip_detector.py

@@ -0,0 +1,298 @@
+"""
+Purpose: Detect test skip patterns without proper justification in source code
+
+Scope: pytest.mark.skip, pytest.skip(), it.skip(), describe.skip(), test.skip() pattern detection
+
+Overview: Provides TestSkipDetector class that scans Python and JavaScript/TypeScript source
+    code for test skip patterns that lack proper justification. For Python, detects bare
+    @pytest.mark.skip and pytest.skip() without reason arguments. For JavaScript/TypeScript,
+    detects it.skip(), describe.skip(), and test.skip() patterns. Returns list of
+    IgnoreDirective objects with line/column positions for violation reporting.
+
+Dependencies: re for pattern matching, pathlib for file paths, types module for dataclasses
+
+Exports: TestSkipDetector
+
+Interfaces: find_skips(code: str, file_path: Path | str | None, language: str) -> list[IgnoreDirective]
+
+Implementation: Regex-based line-by-line scanning with language-specific pattern detection
+"""
+
+import re
+from collections.abc import Callable
+from pathlib import Path
+
+from src.core.constants import Language
+from src.linters.lazy_ignores.directive_utils import (
+    create_directive_no_rules,
+    normalize_path,
+)
+from src.linters.lazy_ignores.types import IgnoreDirective, IgnoreType
+
+
+def _is_comment_line(line: str) -> bool:
+    """Check if a line is a Python comment.
+
+    Args:
+        line: Line of code to check
+
+    Returns:
+        True if the line is a comment (starts with # after whitespace)
+    """
+    return line.strip().startswith("#")
+
+
+def _scan_empty(_line: str, _line_num: int, _file_path: Path) -> list[IgnoreDirective]:
+    """No-op scanner for unsupported languages.
+
+    Args:
+        _line: Unused - required for scanner interface
+        _line_num: Unused - required for scanner interface
+        _file_path: Unused - required for scanner interface
+
+    Returns:
+        Empty list
+    """
+    return []
+
+
+def _count_unescaped_triple_quotes(line: str, quote: str) -> int:
+    """Count unescaped triple-quote occurrences in a line.
+
+    Uses regex to find non-escaped triple quotes.
+
+    Args:
+        line: Line to scan
+        quote: Triple-quote pattern to count (single or double)
+
+    Returns:
+        Number of unescaped triple-quote occurrences
+    """
+    escaped_quote = re.escape(quote)
+    pattern = re.compile(rf"(?<!\\){escaped_quote}")
+    return len(pattern.findall(line))
+
+
+def _update_docstring_state(line: str, quotes: list[str], state: list[bool]) -> None:
+    """Update docstring tracking state based on quotes in line.
+
+    Args:
+        line: Line to analyze
+        quotes: List of quote patterns to check
+        state: Mutable list tracking in-docstring state for each quote type
+    """
+    for i, quote in enumerate(quotes):
+        if _count_unescaped_triple_quotes(line, quote) % 2 == 1:
+            state[i] = not state[i]
+
+
+def _get_python_scannable_lines(code: str) -> list[tuple[int, str]]:
+    """Get Python lines that are not inside docstrings.
+
+    Args:
+        code: Source code to analyze
+
+    Returns:
+        List of (line_number, line_text) tuples for scannable lines
+    """
+    in_docstring = [False, False]  # [triple_double, triple_single]
+    quotes = ['"""', "'''"]
+    scannable: list[tuple[int, str]] = []
+
+    for line_num, line in enumerate(code.splitlines(), start=1):
+        was_in_docstring = in_docstring[0] or in_docstring[1]
+        _update_docstring_state(line, quotes, in_docstring)
+        if not was_in_docstring:
+            scannable.append((line_num, line))
+
+    return scannable
+
+
+class TestSkipDetector:
+    """Detects test skip patterns without proper justification."""
+
+    # Python patterns - violations are skips WITHOUT a reason argument
+    # These patterns match skips that should be flagged
+    # Must appear at start of line (after optional whitespace), not in comments
+    PYTHON_VIOLATION_PATTERNS: dict[IgnoreType, re.Pattern[str]] = {
+        # Matches @pytest.mark.skip or @pytest.mark.skip() without reason=
+        # Requires @ at start of line (after whitespace) to avoid matching in comments
+        IgnoreType.PYTEST_SKIP: re.compile(
+            r"^\s*@pytest\.mark\.skip(?:\s*\(\s*\))?(?!\s*\(.*reason\s*=)",
+        ),
+    }
+
+    # Python patterns that indicate a properly justified skip (no violation)
+    PYTHON_ALLOWED_PATTERNS: list[re.Pattern[str]] = [
+        # @pytest.mark.skip(reason="...")
+        re.compile(r"^\s*@pytest\.mark\.skip\s*\(\s*reason\s*="),
+        # @pytest.mark.skipif(..., reason="...")
+        re.compile(r"^\s*@pytest\.mark\.skipif\s*\(.*reason\s*="),
+        # pytest.skip("reason") - positional reason argument
+        re.compile(r"pytest\.skip\s*\(\s*['\"]"),
+        # pytest.skip(reason="...")
+        re.compile(r"pytest\.skip\s*\(\s*reason\s*="),
+    ]
+
+    # Pattern for bare pytest.skip() - needs special handling
+    PYTEST_SKIP_CALL_PATTERN = re.compile(
+        r"pytest\.skip\s*\(\s*\)",
+    )
+
+    # JavaScript/TypeScript patterns - these are always violations
+    # The proper way is to remove or fix the test, not skip it
+    JS_VIOLATION_PATTERNS: dict[IgnoreType, re.Pattern[str]] = {
+        IgnoreType.JEST_SKIP: re.compile(
+            r"(?:it|test)\.skip\s*\(",
+        ),
+        IgnoreType.MOCHA_SKIP: re.compile(
+            r"describe\.skip\s*\(",
+        ),
+    }
+
+    def find_skips(
+        self,
+        code: str,
+        file_path: Path | str | None = None,
+        language: str | Language = Language.PYTHON,
+    ) -> list[IgnoreDirective]:
+        """Find test skip patterns without justification.
+
+        Tracks docstring state across lines to avoid false positives from
+        patterns mentioned in documentation.
+
+        Args:
+            code: Source code to scan
+            file_path: Optional path to the source file (Path or string)
+            language: Language of source code (Language enum or string)
+
+        Returns:
+            List of IgnoreDirective objects for detected unjustified skips
+        """
+        effective_path = normalize_path(file_path)
+        lang = Language(language) if isinstance(language, str) else language
+        scanner = self._get_line_scanner(lang)
+
+        scannable_lines = self._get_scannable_lines(code, lang)
+        directives: list[IgnoreDirective] = []
+        for line_num, line in scannable_lines:
+            directives.extend(scanner(line, line_num, effective_path))
+        return directives
+
+    def _get_scannable_lines(self, code: str, lang: Language) -> list[tuple[int, str]]:
+        """Get lines that are not inside docstrings (Python) or all lines (other).
+
+        Args:
+            code: Source code to analyze
+            lang: Programming language
+
+        Returns:
+            List of (line_number, line_text) tuples for scannable lines
+        """
+        if lang != Language.PYTHON:
+            return list(enumerate(code.splitlines(), start=1))
+        return _get_python_scannable_lines(code)
+
+    def _get_line_scanner(
+        self, lang: Language
+    ) -> Callable[[str, int, Path], list[IgnoreDirective]]:
+        """Get the appropriate line scanner for a language.
+
+        Args:
+            lang: Programming language
+
+        Returns:
+            Line scanner function for the language
+        """
+        if lang == Language.PYTHON:
+            return self._scan_python_line
+        if lang in (Language.JAVASCRIPT, Language.TYPESCRIPT):
+            return self._scan_js_line
+        return _scan_empty
+
+    def _scan_python_line(self, line: str, line_num: int, file_path: Path) -> list[IgnoreDirective]:
+        """Scan a Python line for unjustified skip patterns.
+
+        Args:
+            line: Line of code to scan
+            line_num: 1-indexed line number
+            file_path: Path to the source file
+
+        Returns:
+            List of IgnoreDirective objects found on this line
+        """
+        if _is_comment_line(line) or self._is_justified_python_skip(line):
+            return []
+
+        found = self._find_decorator_violations(line, line_num, file_path)
+        found.extend(self._find_skip_call_violations(line, line_num, file_path))
+        return found
+
+    def _find_decorator_violations(
+        self, line: str, line_num: int, file_path: Path
+    ) -> list[IgnoreDirective]:
+        """Find @pytest.mark.skip decorator violations.
+
+        Args:
+            line: Line of code to scan
+            line_num: 1-indexed line number
+            file_path: Path to source file
+
+        Returns:
+            List of IgnoreDirective for decorator violations
+        """
+        found: list[IgnoreDirective] = []
+        for ignore_type, pattern in self.PYTHON_VIOLATION_PATTERNS.items():
+            match = pattern.search(line)
+            if match:
+                found.append(create_directive_no_rules(match, ignore_type, line_num, file_path))
+        return found
+
+    def _find_skip_call_violations(
+        self, line: str, line_num: int, file_path: Path
+    ) -> list[IgnoreDirective]:
+        """Find bare pytest.skip() call violations.
+
+        Args:
+            line: Line of code to scan
+            line_num: 1-indexed line number
+            file_path: Path to source file
+
+        Returns:
+            List of IgnoreDirective for skip call violations
+        """
+        match = self.PYTEST_SKIP_CALL_PATTERN.search(line)
+        if match:
+            return [create_directive_no_rules(match, IgnoreType.PYTEST_SKIP, line_num, file_path)]
+        return []
+
+    def _is_justified_python_skip(self, line: str) -> bool:
+        """Check if a Python line contains a justified skip.
+
+        Args:
+            line: Line of code to check
+
+        Returns:
+            True if the line has a skip with proper justification
+        """
+        return any(pattern.search(line) for pattern in self.PYTHON_ALLOWED_PATTERNS)
+
+    def _scan_js_line(self, line: str, line_num: int, file_path: Path) -> list[IgnoreDirective]:
+        """Scan a JavaScript/TypeScript line for skip patterns.
+
+        Args:
+            line: Line of code to scan
+            line_num: 1-indexed line number
+            file_path: Path to the source file
+
+        Returns:
+            List of IgnoreDirective objects found on this line
+        """
+        found: list[IgnoreDirective] = []
+
+        for ignore_type, pattern in self.JS_VIOLATION_PATTERNS.items():
+            match = pattern.search(line)
+            if match:
+                found.append(create_directive_no_rules(match, ignore_type, line_num, file_path))
+
+        return found

src/linters/lazy_ignores/types.py

@@ -0,0 +1,69 @@
+"""
+Purpose: Type definitions for lazy-ignores linter
+
+Scope: Data structures for ignore directives and suppression entries
+
+Overview: Defines core types for the lazy-ignores linter including IgnoreType enum for
+    categorizing different suppression patterns, IgnoreDirective dataclass for representing
+    detected ignores in code, and SuppressionEntry dataclass for representing declared
+    suppressions in file headers. Supports Python (noqa, type:ignore, pylint, nosec),
+    TypeScript (@ts-ignore, eslint-disable), thai-lint (thailint:ignore), and test skip
+    patterns (pytest.mark.skip, it.skip, describe.skip).
+
+Dependencies: dataclasses, enum, pathlib
+
+Exports: IgnoreType, IgnoreDirective, SuppressionEntry
+
+Interfaces: Frozen dataclasses for immutable ignore representation
+
+Implementation: Enum-based categorization with frozen dataclasses for thread safety
+"""
+
+from dataclasses import dataclass
+from enum import Enum
+from pathlib import Path
+
+
+class IgnoreType(Enum):
+    """Type of linting ignore directive."""
+
+    NOQA = "noqa"
+    TYPE_IGNORE = "type:ignore"
+    PYLINT_DISABLE = "pylint:disable"
+    NOSEC = "nosec"
+    TS_IGNORE = "ts-ignore"
+    TS_NOCHECK = "ts-nocheck"
+    TS_EXPECT_ERROR = "ts-expect-error"
+    ESLINT_DISABLE = "eslint-disable"
+    THAILINT_IGNORE = "thailint:ignore"
+    THAILINT_IGNORE_FILE = "thailint:ignore-file"
+    THAILINT_IGNORE_NEXT = "thailint:ignore-next-line"
+    THAILINT_IGNORE_BLOCK = "thailint:ignore-start"
+    # DRY ignore patterns
+    DRY_IGNORE_BLOCK = "dry:ignore-block"
+    # Test skip patterns
+    PYTEST_SKIP = "pytest:skip"
+    PYTEST_SKIPIF = "pytest:skipif"
+    JEST_SKIP = "jest:skip"
+    MOCHA_SKIP = "mocha:skip"
+
+
+@dataclass(frozen=True)
+class IgnoreDirective:
+    """Represents a linting ignore found in code."""
+
+    ignore_type: IgnoreType
+    rule_ids: tuple[str, ...]  # Can have multiple: noqa: PLR0912, PLR0915
+    line: int
+    column: int
+    raw_text: str  # Original comment text
+    file_path: Path
+
+
+@dataclass(frozen=True)
+class SuppressionEntry:
+    """Represents a suppression declared in file header."""
+
+    rule_id: str  # Normalized rule ID
+    justification: str
+    raw_text: str  # Original header line

src/linters/lazy_ignores/typescript_analyzer.py

@@ -0,0 +1,146 @@
+"""
+Purpose: Detect TypeScript/JavaScript linting ignore directives in source code
+
+Scope: @ts-ignore, @ts-nocheck, @ts-expect-error, eslint-disable pattern detection
+
+Overview: Provides TypeScriptIgnoreDetector class that scans TypeScript and JavaScript source
+    code for common linting ignore patterns. Detects TypeScript-specific patterns (@ts-ignore,
+    @ts-nocheck, @ts-expect-error) and ESLint patterns (eslint-disable-next-line, eslint-disable
+    block comments, eslint-disable-line). Handles both single-line (//) and block (/* */)
+    comment styles. Returns list of IgnoreDirective objects with line/column positions for
+    violation reporting.
+
+Dependencies: re for pattern matching, pathlib for file paths, types module for dataclasses
+
+Exports: TypeScriptIgnoreDetector
+
+Interfaces: find_ignores(code: str, file_path: Path | str | None) -> list[IgnoreDirective]
+
+Implementation: Regex-based line-by-line scanning with pattern-specific rule ID extraction
+"""
+
+import re
+from pathlib import Path
+
+from src.linters.lazy_ignores.directive_utils import create_directive, normalize_path
+from src.linters.lazy_ignores.types import IgnoreDirective, IgnoreType
+
+
+class TypeScriptIgnoreDetector:
+    """Detects TypeScript/JavaScript linting ignore directives in source code."""
+
+    # Regex patterns for each ignore type
+    # Single-line comment patterns (//)
+    SINGLE_LINE_PATTERNS: dict[IgnoreType, re.Pattern[str]] = {
+        IgnoreType.TS_IGNORE: re.compile(
+            r"//\s*@ts-ignore(?:\s|$)",
+        ),
+        IgnoreType.TS_NOCHECK: re.compile(
+            r"//\s*@ts-nocheck(?:\s|$)",
+        ),
+        IgnoreType.TS_EXPECT_ERROR: re.compile(
+            r"//\s*@ts-expect-error(?:\s|$)",
+        ),
+        IgnoreType.THAILINT_IGNORE: re.compile(
+            r"//\s*thailint:\s*ignore(?!-)(?:\[([^\]]+)\])?",
+            re.IGNORECASE,
+        ),
+        IgnoreType.THAILINT_IGNORE_FILE: re.compile(
+            r"//\s*thailint:\s*ignore-file(?:\[([^\]]+)\])?",
+            re.IGNORECASE,
+        ),
+    }
+
+    # ESLint patterns (can be single-line or inline)
+    ESLINT_PATTERNS: dict[str, re.Pattern[str]] = {
+        "next-line": re.compile(
+            r"//\s*eslint-disable-next-line(?:\s+([a-zA-Z0-9\-/,\s]+))?(?:\s|$)",
+        ),
+        "inline": re.compile(
+            r"//\s*eslint-disable-line(?:\s+([a-zA-Z0-9\-/,\s]+))?(?:\s|$)",
+        ),
+        "block-start": re.compile(
+            r"/\*\s*eslint-disable(?:\s+([a-zA-Z0-9\-/,\s]+))?\s*\*/",
+        ),
+    }
+
+    def find_ignores(self, code: str, file_path: Path | str | None = None) -> list[IgnoreDirective]:
+        """Find all TypeScript/JavaScript ignore directives in code.
+
+        Args:
+            code: TypeScript/JavaScript source code to scan
+            file_path: Optional path to the source file (Path or string)
+
+        Returns:
+            List of IgnoreDirective objects for each detected ignore pattern
+        """
+        directives: list[IgnoreDirective] = []
+        effective_path = normalize_path(file_path)
+
+        for line_num, line in enumerate(code.splitlines(), start=1):
+            directives.extend(self._scan_line(line, line_num, effective_path))
+
+        return directives
+
+    def _scan_line(self, line: str, line_num: int, file_path: Path) -> list[IgnoreDirective]:
+        """Scan a single line for ignore patterns.
+
+        Args:
+            line: Line of code to scan
+            line_num: 1-indexed line number
+            file_path: Path to the source file
+
+        Returns:
+            List of IgnoreDirective objects found on this line
+        """
+        found: list[IgnoreDirective] = []
+
+        # Check TypeScript-specific patterns
+        found.extend(self._scan_typescript_patterns(line, line_num, file_path))
+
+        # Check ESLint patterns
+        found.extend(self._scan_eslint_patterns(line, line_num, file_path))
+
+        return found
+
+    def _scan_typescript_patterns(
+        self, line: str, line_num: int, file_path: Path
+    ) -> list[IgnoreDirective]:
+        """Scan for TypeScript-specific ignore patterns.
+
+        Args:
+            line: Line of code to scan
+            line_num: 1-indexed line number
+            file_path: Path to the source file
+
+        Returns:
+            List of IgnoreDirective objects for TypeScript patterns
+        """
+        found: list[IgnoreDirective] = []
+        for ignore_type, pattern in self.SINGLE_LINE_PATTERNS.items():
+            match = pattern.search(line)
+            if match:
+                found.append(create_directive(match, ignore_type, line_num, file_path))
+        return found
+
+    def _scan_eslint_patterns(
+        self, line: str, line_num: int, file_path: Path
+    ) -> list[IgnoreDirective]:
+        """Scan for ESLint disable patterns.
+
+        Args:
+            line: Line of code to scan
+            line_num: 1-indexed line number
+            file_path: Path to the source file
+
+        Returns:
+            List of IgnoreDirective objects for ESLint patterns
+        """
+        found: list[IgnoreDirective] = []
+        for pattern in self.ESLINT_PATTERNS.values():
+            match = pattern.search(line)
+            if match:
+                found.append(
+                    create_directive(match, IgnoreType.ESLINT_DISABLE, line_num, file_path)
+                )
+        return found