thailint 0.15.0__py3-none-any.whl → 0.15.1__py3-none-any.whl

src/linters/lbyl/pattern_detectors/len_check_detector.py

@@ -0,0 +1,173 @@
+"""
+Purpose: AST-based detector for len check LBYL patterns
+
+Scope: Detects 'if len(lst) > i: lst[i]' patterns in Python code
+
+Overview: Provides LenCheckDetector class that uses AST traversal to find LBYL anti-patterns
+    involving length checking before index access. Identifies patterns where code checks if
+    a collection's length is sufficient before accessing an element by index. Handles various
+    comparison operators (>, >=, <, <=) and operand orderings. Returns LenCheckPattern objects
+    containing the collection name, index expression, and location. Avoids false positives
+    for different collection/index combinations.
+
+Dependencies: ast module, base detector classes from pattern_detectors.base
+
+Exports: LenCheckPattern, LenCheckDetector
+
+Interfaces: LenCheckDetector.find_patterns(tree: ast.AST) -> list[LenCheckPattern]
+
+Implementation: AST NodeVisitor pattern with visit_If to detect len check followed by
+    subscript access
+
+Suppressions:
+    - N802: visit_If follows Python AST visitor naming convention (camelCase required)
+    - invalid-name: visit_If follows Python AST visitor naming convention (camelCase required)
+"""
+
+import ast
+from dataclasses import dataclass
+
+from .base import BaseLBYLDetector, LBYLPattern
+
+
+@dataclass
+class LenCheckPattern(LBYLPattern):
+    """Pattern data for len check LBYL anti-pattern."""
+
+    collection_name: str
+    index_expression: str
+
+
+def _extract_len_call_collection(node: ast.expr) -> ast.expr | None:
+    """Extract collection from len(collection) call, or None if not len call."""
+    if not isinstance(node, ast.Call):
+        return None
+    if not isinstance(node.func, ast.Name) or node.func.id != "len":
+        return None
+    if len(node.args) != 1:
+        return None
+    return node.args[0]
+
+
+def _extract_len_from_binop(node: ast.expr) -> ast.expr | None:
+    """Extract collection from len(lst) - 1 or similar BinOp."""
+    if isinstance(node, ast.BinOp):
+        # len(lst) - 1 or 1 + len(lst)
+        collection = _extract_len_call_collection(node.left)
+        if collection is not None:
+            return collection
+        return _extract_len_call_collection(node.right)
+    return _extract_len_call_collection(node)
+
+
+def _is_valid_compare(test: ast.expr) -> bool:
+    """Check if test is a simple comparison with one operator."""
+    if not isinstance(test, ast.Compare):
+        return False
+    return len(test.ops) == 1 and len(test.comparators) == 1
+
+
+def _is_unary_constant(node: ast.expr) -> bool:
+    """Check if node is unary minus on constant (e.g., -1)."""
+    return isinstance(node, ast.UnaryOp) and isinstance(node.operand, ast.Constant)
+
+
+def _is_constant_index(node: ast.expr) -> bool:
+    """Check if node is a constant (literal number or simple expression).
+
+    We don't flag len checks with constant indices as LBYL because they're
+    typically local validation patterns (e.g., if len(lst) >= 2: lst[0], lst[1])
+    rather than race-condition-prone LBYL anti-patterns.
+    """
+    if isinstance(node, ast.Constant) or _is_unary_constant(node):
+        return True
+    if isinstance(node, ast.BinOp):
+        return _is_constant_index(node.left) and _is_constant_index(node.right)
+    return False
+
+
+def _check_len_greater_than(
+    op: ast.cmpop, left: ast.expr, right: ast.expr
+) -> tuple[ast.expr | None, ast.expr | None]:
+    """Check for len(lst) > i or len(lst) >= i pattern."""
+    if not isinstance(op, (ast.Gt, ast.GtE)):
+        return None, None
+    collection = _extract_len_from_binop(left)
+    if collection is not None:
+        return collection, right
+    return None, None
+
+
+def _check_index_less_than(
+    op: ast.cmpop, left: ast.expr, right: ast.expr
+) -> tuple[ast.expr | None, ast.expr | None]:
+    """Check for i < len(lst) or i <= len(lst) pattern."""
+    if not isinstance(op, (ast.Lt, ast.LtE)):
+        return None, None
+    collection = _extract_len_from_binop(right)
+    if collection is not None:
+        return collection, left
+    return None, None
+
+
+def _extract_len_check(test: ast.expr) -> tuple[ast.expr | None, ast.expr | None]:
+    """Extract (collection, index) from len comparison, or (None, None)."""
+    if not isinstance(test, ast.Compare):
+        return None, None
+    if not _is_valid_compare(test):
+        return None, None
+
+    op = test.ops[0]
+    left = test.left
+    right = test.comparators[0]
+
+    result = _check_len_greater_than(op, left, right)
+    if result[0] is not None:
+        return result
+    return _check_index_less_than(op, left, right)
+
+
+class LenCheckDetector(BaseLBYLDetector[LenCheckPattern]):
+    """Detects 'if len(lst) > i: lst[i]' LBYL patterns."""
+
+    def __init__(self) -> None:
+        """Initialize the detector."""
+        self._patterns: list[LenCheckPattern] = []
+
+    def visit_If(self, node: ast.If) -> None:  # noqa: N802  # pylint: disable=invalid-name
+        """Visit if statement to check for len check LBYL pattern."""
+        self._check_len_pattern(node)
+        self.generic_visit(node)
+
+    def _check_len_pattern(self, node: ast.If) -> None:
+        """Check if node matches len check LBYL pattern."""
+        collection_expr, index_expr = _extract_len_check(node.test)
+        if collection_expr is None or index_expr is None:
+            return
+
+        # Skip constant index checks - they're local validation, not LBYL
+        if _is_constant_index(index_expr):
+            return
+
+        if self._body_has_subscript_match(node.body, collection_expr):
+            self._patterns.append(self._create_pattern(node, collection_expr, index_expr))
+
+    def _body_has_subscript_match(self, body: list[ast.stmt], collection_expr: ast.expr) -> bool:
+        """Check if body contains collection[index] access matching the len check."""
+        expected_collection = ast.dump(collection_expr)
+        return any(
+            isinstance(node, ast.Subscript) and ast.dump(node.value) == expected_collection
+            for stmt in body
+            for node in ast.walk(stmt)
+        )
+
+    def _create_pattern(
+        self, node: ast.If, collection_expr: ast.expr, index_expr: ast.expr
+    ) -> LenCheckPattern:
+        """Create LenCheckPattern from detected pattern."""
+        return LenCheckPattern(
+            line_number=node.lineno,
+            column=node.col_offset,
+            collection_name=ast.unparse(collection_expr),
+            index_expression=ast.unparse(index_expr),
+        )

src/linters/lbyl/pattern_detectors/none_check_detector.py

@@ -0,0 +1,146 @@
+"""
+Purpose: AST-based detector for None check LBYL patterns
+
+Scope: Detects 'if x is not None: x.method()' patterns in Python code
+
+Overview: Provides NoneCheckDetector class that uses AST traversal to find LBYL anti-patterns
+    involving None checking. Identifies patterns where code checks if a variable is not None
+    before using it (e.g., 'if x is not None: x.method()'). Also detects inverse patterns
+    with else branches. Returns NoneCheckPattern objects containing the variable name and
+    location. Avoids false positives for different variables, walrus operator assignments.
+
+Dependencies: ast module, base detector classes from pattern_detectors.base
+
+Exports: NoneCheckPattern, NoneCheckDetector
+
+Interfaces: NoneCheckDetector.find_patterns(tree: ast.AST) -> list[NoneCheckPattern]
+
+Implementation: AST NodeVisitor pattern with visit_If to detect None comparison followed by
+    variable usage
+
+Suppressions:
+    - N802: visit_If follows Python AST visitor naming convention (camelCase required)
+    - invalid-name: visit_If follows Python AST visitor naming convention (camelCase required)
+"""
+
+import ast
+from dataclasses import dataclass
+
+from .base import BaseLBYLDetector, LBYLPattern
+
+
+@dataclass
+class NoneCheckPattern(LBYLPattern):
+    """Pattern data for None check LBYL anti-pattern."""
+
+    variable_name: str
+
+
+def _try_extract_none_check(node: ast.expr) -> tuple[ast.expr | None, bool]:
+    """Try to extract variable from None comparison.
+
+    Returns:
+        Tuple of (variable_expr, is_not_none_check) or (None, False) if not valid.
+        is_not_none_check is True for 'is not None', False for 'is None'.
+    """
+    if not isinstance(node, ast.Compare):
+        return None, False
+    if len(node.ops) != 1 or len(node.comparators) != 1:
+        return None, False
+    return _extract_none_comparison(node)
+
+
+def _is_none_constant(node: ast.expr) -> bool:
+    """Check if node is a None constant."""
+    return isinstance(node, ast.Constant) and node.value is None
+
+
+def _extract_var_from_none_check(var_side: ast.expr, op: ast.cmpop) -> tuple[ast.expr | None, bool]:
+    """Extract variable from None comparison if valid."""
+    if _is_walrus_expression(var_side):
+        return None, False
+    return var_side, isinstance(op, ast.IsNot)
+
+
+def _extract_none_comparison(node: ast.Compare) -> tuple[ast.expr | None, bool]:
+    """Extract variable from 'x is None' or 'x is not None' comparison.
+
+    Returns:
+        Tuple of (variable_expr, is_not_none) or (None, False) if not valid.
+    """
+    op = node.ops[0]
+    if not isinstance(op, (ast.Is, ast.IsNot)):
+        return None, False
+
+    left, right = node.left, node.comparators[0]
+
+    # Check for 'x is None', 'x is not None'
+    if _is_none_constant(right):
+        return _extract_var_from_none_check(left, op)
+    # Check for 'None is x', 'None is not x'
+    if _is_none_constant(left):
+        return _extract_var_from_none_check(right, op)
+
+    return None, False
+
+
+def _is_walrus_expression(node: ast.expr) -> bool:
+    """Check if expression contains walrus operator (assignment expression)."""
+    return isinstance(node, ast.NamedExpr)
+
+
+class NoneCheckDetector(BaseLBYLDetector[NoneCheckPattern]):
+    """Detects 'if x is not None: x.method()' LBYL patterns."""
+
+    def __init__(self) -> None:
+        """Initialize the detector."""
+        self._patterns: list[NoneCheckPattern] = []
+
+    def visit_If(self, node: ast.If) -> None:  # noqa: N802  # pylint: disable=invalid-name
+        """Visit if statement to check for None check LBYL pattern.
+
+        Args:
+            node: AST If node to analyze
+        """
+        self._check_none_pattern(node)
+        self.generic_visit(node)
+
+    def _check_none_pattern(self, node: ast.If) -> None:
+        """Check if node is a None check LBYL pattern and record it."""
+        var_expr, is_not_none = _try_extract_none_check(node.test)
+        if var_expr is None:
+            return
+
+        # For 'is not None', check body for variable usage
+        # For 'is None', check else branch for variable usage
+        body_to_check = node.body if is_not_none else node.orelse
+        if not body_to_check:
+            return
+
+        if self._body_has_variable_usage(body_to_check, var_expr):
+            self._patterns.append(self._create_pattern(node, var_expr))
+
+    def _body_has_variable_usage(self, body: list[ast.stmt], var_expr: ast.expr) -> bool:
+        """Check if body contains usage of the None-checked variable."""
+        expected_var = ast.dump(var_expr)
+        return any(
+            self._is_variable_usage(node, expected_var) for stmt in body for node in ast.walk(stmt)
+        )
+
+    def _is_variable_usage(self, node: ast.AST, expected_var: str) -> bool:
+        """Check if node represents usage of the expected variable."""
+        if isinstance(node, ast.Attribute):
+            return ast.dump(node.value) == expected_var
+        if isinstance(node, ast.Subscript):
+            return ast.dump(node.value) == expected_var
+        if isinstance(node, ast.Call):
+            return ast.dump(node.func) == expected_var
+        return False
+
+    def _create_pattern(self, node: ast.If, var_expr: ast.expr) -> NoneCheckPattern:
+        """Create NoneCheckPattern from detected pattern."""
+        return NoneCheckPattern(
+            line_number=node.lineno,
+            column=node.col_offset,
+            variable_name=ast.unparse(var_expr),
+        )

src/linters/lbyl/pattern_detectors/string_validator_detector.py

@@ -0,0 +1,145 @@
+"""
+Purpose: AST-based detector for string validator LBYL patterns
+
+Scope: Detects 'if s.isnumeric(): int(s)' patterns in Python code
+
+Overview: Provides StringValidatorDetector class that uses AST traversal to find LBYL
+    anti-patterns involving string validation before conversion. Identifies patterns where
+    code checks string content (isnumeric, isdigit, isdecimal) before calling conversion
+    functions (int, float). Returns StringValidatorPattern objects containing the string
+    name, validator method, conversion function, and location.
+
+Dependencies: ast module, base detector classes from pattern_detectors.base
+
+Exports: StringValidatorPattern, StringValidatorDetector
+
+Interfaces: StringValidatorDetector.find_patterns(tree: ast.AST) -> list[StringValidatorPattern]
+
+Implementation: AST NodeVisitor pattern with visit_If to detect string validation followed
+    by conversion call
+
+Suppressions:
+    - N802: visit_If follows Python AST visitor naming convention (camelCase required)
+    - invalid-name: visit_If follows Python AST visitor naming convention (camelCase required)
+"""
+
+import ast
+from collections.abc import Iterator
+from dataclasses import dataclass
+
+from .base import BaseLBYLDetector, LBYLPattern
+
+# Validator methods that check numeric content
+NUMERIC_VALIDATORS = frozenset({"isnumeric", "isdigit", "isdecimal"})
+
+# Conversion functions that convert strings to numbers
+NUMERIC_CONVERSIONS = frozenset({"int", "float"})
+
+
+@dataclass
+class StringValidatorPattern(LBYLPattern):
+    """Pattern data for string validator LBYL anti-pattern."""
+
+    string_name: str
+    validator_method: str
+    conversion_func: str
+
+
+def _try_extract_validator_call(node: ast.expr) -> tuple[ast.expr | None, str | None]:
+    """Try to extract string validator call.
+
+    Returns:
+        Tuple of (string_expr, validator_method) or (None, None) if not valid.
+    """
+    if not isinstance(node, ast.Call):
+        return None, None
+    if not isinstance(node.func, ast.Attribute):
+        return None, None
+    if node.func.attr not in NUMERIC_VALIDATORS:
+        return None, None
+    return node.func.value, node.func.attr
+
+
+def _get_string_expression_key(expr: ast.expr) -> str:
+    """Get a normalized key for comparing string expressions."""
+    return ast.dump(expr)
+
+
+def _get_conversion_func_name(node: ast.AST) -> str | None:
+    """Get conversion function name if node is a numeric conversion call."""
+    if not isinstance(node, ast.Call):
+        return None
+    if not isinstance(node.func, ast.Name):
+        return None
+    if node.func.id not in NUMERIC_CONVERSIONS:
+        return None
+    return node.func.id
+
+
+def _iter_ast_nodes(body: list[ast.stmt]) -> Iterator[ast.AST]:
+    """Iterate over all AST nodes in a list of statements."""
+    for stmt in body:
+        yield from ast.walk(stmt)
+
+
+def _is_matching_call(node: ast.AST, expected_key: str) -> str | None:
+    """Check if node is a matching conversion call."""
+    if not isinstance(node, ast.Call):
+        return None
+    func_name = _get_conversion_func_name(node)
+    if func_name and node.args and ast.dump(node.args[0]) == expected_key:
+        return func_name
+    return None
+
+
+def _find_conversion(body: list[ast.stmt], expected_key: str) -> str | None:
+    """Find first matching conversion in body."""
+    for node in _iter_ast_nodes(body):
+        result = _is_matching_call(node, expected_key)
+        if result:
+            return result
+    return None
+
+
+class StringValidatorDetector(BaseLBYLDetector[StringValidatorPattern]):
+    """Detects 'if s.isnumeric(): int(s)' LBYL patterns."""
+
+    def __init__(self) -> None:
+        """Initialize the detector."""
+        self._patterns: list[StringValidatorPattern] = []
+
+    def visit_If(self, node: ast.If) -> None:  # noqa: N802  # pylint: disable=invalid-name
+        """Visit if statement to check for string validator LBYL pattern.
+
+        Args:
+            node: AST If node to analyze
+        """
+        self._check_validator_pattern(node)
+        self.generic_visit(node)
+
+    def _check_validator_pattern(self, node: ast.If) -> None:
+        """Check if node is a string validator LBYL pattern and record it."""
+        string_expr, validator = _try_extract_validator_call(node.test)
+        if string_expr is None or validator is None:
+            return
+
+        expected_key = _get_string_expression_key(string_expr)
+        conversion = _find_conversion(node.body, expected_key)
+        if conversion:
+            self._patterns.append(self._create_pattern(node, string_expr, validator, conversion))
+
+    def _create_pattern(
+        self,
+        node: ast.If,
+        string_expr: ast.expr,
+        validator: str,
+        conversion: str,
+    ) -> StringValidatorPattern:
+        """Create StringValidatorPattern from detected pattern."""
+        return StringValidatorPattern(
+            line_number=node.lineno,
+            column=node.col_offset,
+            string_name=ast.unparse(string_expr),
+            validator_method=validator,
+            conversion_func=conversion,
+        )

src/linters/lbyl/python_analyzer.py

@@ -0,0 +1,215 @@
+"""
+Purpose: Coordinate LBYL pattern detection and violation generation
+
+Scope: Orchestrates multiple pattern detectors and converts results to violations
+
+Overview: Provides PythonLBYLAnalyzer class that coordinates all LBYL pattern detectors
+    and converts detected patterns into Violation objects. Handles AST parsing with
+    graceful syntax error handling, runs enabled detectors based on configuration toggles,
+    and aggregates violations from all detectors. Serves as the main analysis engine
+    called by LBYLRule.
+
+Dependencies: ast module, LBYLConfig, pattern detectors, violation_builder functions
+
+Exports: PythonLBYLAnalyzer
+
+Interfaces: analyze(code: str, file_path: str, config: LBYLConfig) -> list[Violation]
+
+Implementation: Detector coordination with config-driven pattern selection using
+    generic detector runner for code reuse
+"""
+
+import ast
+from collections.abc import Callable
+from typing import Any, TypeVar
+
+from src.core.types import Violation
+
+from .config import LBYLConfig
+from .pattern_detectors.base import BaseLBYLDetector, LBYLPattern
+from .pattern_detectors.dict_key_detector import DictKeyDetector, DictKeyPattern
+from .pattern_detectors.division_check_detector import (
+    DivisionCheckDetector,
+    DivisionCheckPattern,
+)
+from .pattern_detectors.file_exists_detector import FileExistsDetector, FileExistsPattern
+from .pattern_detectors.hasattr_detector import HasattrDetector, HasattrPattern
+from .pattern_detectors.isinstance_detector import IsinstanceDetector, IsinstancePattern
+from .pattern_detectors.len_check_detector import LenCheckDetector, LenCheckPattern
+from .pattern_detectors.none_check_detector import NoneCheckDetector, NoneCheckPattern
+from .pattern_detectors.string_validator_detector import (
+    StringValidatorDetector,
+    StringValidatorPattern,
+)
+from .violation_builder import (
+    build_dict_key_violation,
+    build_division_check_violation,
+    build_file_exists_violation,
+    build_hasattr_violation,
+    build_isinstance_violation,
+    build_len_check_violation,
+    build_none_check_violation,
+    build_string_validator_violation,
+)
+
+PatternT = TypeVar("PatternT", bound=LBYLPattern)
+
+
+def _parse_python_code(code: str) -> ast.Module | None:
+    """Parse Python code into AST, returning None if empty or invalid."""
+    if not code or not code.strip():
+        return None
+    try:
+        return ast.parse(code)
+    except SyntaxError:
+        return None
+
+
+def _run_detector(
+    detector: BaseLBYLDetector[PatternT],
+    tree: ast.Module,
+    file_path: str,
+    converter: Callable[[PatternT, str], Violation],
+    pattern_type: type[PatternT],
+) -> list[Violation]:
+    """Run a detector and convert patterns to violations."""
+    return [
+        converter(p, file_path) for p in detector.find_patterns(tree) if isinstance(p, pattern_type)
+    ]
+
+
+def _build_dict_key(pattern: DictKeyPattern, file_path: str) -> Violation:
+    """Convert DictKeyPattern to Violation."""
+    return build_dict_key_violation(
+        file_path=file_path,
+        line=pattern.line_number,
+        column=pattern.column,
+        dict_name=pattern.dict_name,
+        key_expression=pattern.key_expression,
+    )
+
+
+def _build_division_check(pattern: DivisionCheckPattern, file_path: str) -> Violation:
+    """Convert DivisionCheckPattern to Violation."""
+    return build_division_check_violation(
+        file_path=file_path,
+        line=pattern.line_number,
+        column=pattern.column,
+        divisor_name=pattern.divisor_name,
+        operation=pattern.operation,
+    )
+
+
+def _build_file_exists(pattern: FileExistsPattern, file_path: str) -> Violation:
+    """Convert FileExistsPattern to Violation."""
+    return build_file_exists_violation(
+        file_path=file_path,
+        line=pattern.line_number,
+        column=pattern.column,
+        path_expression=pattern.file_path_expression,
+        check_type=pattern.check_type,
+    )
+
+
+def _build_hasattr(pattern: HasattrPattern, file_path: str) -> Violation:
+    """Convert HasattrPattern to Violation."""
+    return build_hasattr_violation(
+        file_path=file_path,
+        line=pattern.line_number,
+        column=pattern.column,
+        object_name=pattern.object_name,
+        attribute_name=pattern.attribute_name,
+    )
+
+
+def _build_isinstance(pattern: IsinstancePattern, file_path: str) -> Violation:
+    """Convert IsinstancePattern to Violation."""
+    return build_isinstance_violation(
+        file_path=file_path,
+        line=pattern.line_number,
+        column=pattern.column,
+        object_name=pattern.object_name,
+        type_name=pattern.type_name,
+    )
+
+
+def _build_len_check(pattern: LenCheckPattern, file_path: str) -> Violation:
+    """Convert LenCheckPattern to Violation."""
+    return build_len_check_violation(
+        file_path=file_path,
+        line=pattern.line_number,
+        column=pattern.column,
+        collection_name=pattern.collection_name,
+        index_expression=pattern.index_expression,
+    )
+
+
+def _build_none_check(pattern: NoneCheckPattern, file_path: str) -> Violation:
+    """Convert NoneCheckPattern to Violation."""
+    return build_none_check_violation(
+        file_path=file_path,
+        line=pattern.line_number,
+        column=pattern.column,
+        variable_name=pattern.variable_name,
+    )
+
+
+def _build_string_validator(pattern: StringValidatorPattern, file_path: str) -> Violation:
+    """Convert StringValidatorPattern to Violation."""
+    return build_string_validator_violation(
+        file_path=file_path,
+        line=pattern.line_number,
+        column=pattern.column,
+        string_name=pattern.string_name,
+        validator_method=pattern.validator_method,
+        conversion_func=pattern.conversion_func,
+    )
+
+
+class PythonLBYLAnalyzer:
+    """Coordinates LBYL pattern detection for Python code."""
+
+    def __init__(self) -> None:
+        """Initialize the analyzer with pattern detectors."""
+        # Each tuple: (detector, converter, pattern_type)
+        self._detector_configs: list[
+            tuple[BaseLBYLDetector[Any], Callable[..., Violation], type]
+        ] = [
+            (DictKeyDetector(), _build_dict_key, DictKeyPattern),
+            (DivisionCheckDetector(), _build_division_check, DivisionCheckPattern),
+            (FileExistsDetector(), _build_file_exists, FileExistsPattern),
+            (HasattrDetector(), _build_hasattr, HasattrPattern),
+            (IsinstanceDetector(), _build_isinstance, IsinstancePattern),
+            (LenCheckDetector(), _build_len_check, LenCheckPattern),
+            (NoneCheckDetector(), _build_none_check, NoneCheckPattern),
+            (StringValidatorDetector(), _build_string_validator, StringValidatorPattern),
+        ]
+
+    def analyze(self, code: str, file_path: str, config: LBYLConfig) -> list[Violation]:
+        """Analyze Python code for LBYL patterns."""
+        tree = _parse_python_code(code)
+        if tree is None:
+            return []
+        return self._run_enabled_detectors(tree, file_path, config)
+
+    def _run_enabled_detectors(
+        self, tree: ast.Module, file_path: str, config: LBYLConfig
+    ) -> list[Violation]:
+        """Run all enabled pattern detectors and collect violations."""
+        # Map detector types to their config flags
+        enabled_flags = {
+            DictKeyDetector: config.detect_dict_key,
+            DivisionCheckDetector: config.detect_division_check,
+            FileExistsDetector: config.detect_file_exists,
+            HasattrDetector: config.detect_hasattr,
+            IsinstanceDetector: config.detect_isinstance,
+            LenCheckDetector: config.detect_len_check,
+            NoneCheckDetector: config.detect_none_check,
+            StringValidatorDetector: config.detect_string_validation,
+        }
+
+        violations: list[Violation] = []
+        for detector, converter, pattern_type in self._detector_configs:
+            if enabled_flags.get(type(detector), False):
+                violations.extend(_run_detector(detector, tree, file_path, converter, pattern_type))
+        return violations