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

src/linters/lbyl/pattern_detectors/isinstance_detector.py

@@ -0,0 +1,119 @@
+"""
+Purpose: AST-based detector for isinstance LBYL patterns
+
+Scope: Detects 'if isinstance(x, Type): x.method()' patterns in Python code
+
+Overview: Provides IsinstanceDetector class that uses AST traversal to find LBYL anti-patterns
+    involving isinstance checking. Identifies patterns where code checks if an object is an
+    instance of a type before performing type-specific operations. Returns IsinstancePattern
+    objects containing the object name, type name, and location. This detector is disabled by
+    default in config because many isinstance checks are valid type narrowing.
+
+Dependencies: ast module, base detector classes from pattern_detectors.base
+
+Exports: IsinstancePattern, IsinstanceDetector
+
+Interfaces: IsinstanceDetector.find_patterns(tree: ast.AST) -> list[IsinstancePattern]
+
+Implementation: AST NodeVisitor pattern with visit_If to detect isinstance check followed by
+    operations on the checked object
+
+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 IsinstancePattern(LBYLPattern):
+    """Pattern data for isinstance LBYL anti-pattern."""
+
+    object_name: str
+    type_name: str
+
+
+def _try_extract_isinstance_call(node: ast.expr) -> tuple[ast.expr | None, str | None]:
+    """Try to extract isinstance call arguments.
+
+    Returns:
+        Tuple of (object_expr, type_name) or (None, None) if not a valid isinstance call.
+    """
+    if not isinstance(node, ast.Call):
+        return None, None
+    if not isinstance(node.func, ast.Name) or node.func.id != "isinstance":
+        return None, None
+    return _extract_isinstance_args(node)
+
+
+def _extract_isinstance_args(call: ast.Call) -> tuple[ast.expr | None, str | None]:
+    """Extract object and type name from isinstance call args.
+
+    Returns:
+        Tuple of (object_expr, type_name_str) or (None, None) if not valid.
+    """
+    if len(call.args) != 2:
+        return None, None
+    return call.args[0], ast.unparse(call.args[1])
+
+
+class IsinstanceDetector(BaseLBYLDetector[IsinstancePattern]):
+    """Detects 'if isinstance(x, Type): x.method()' LBYL patterns."""
+
+    def __init__(self) -> None:
+        """Initialize the detector."""
+        self._patterns: list[IsinstancePattern] = []
+
+    def visit_If(self, node: ast.If) -> None:  # noqa: N802  # pylint: disable=invalid-name
+        """Visit if statement to check for isinstance LBYL pattern.
+
+        Args:
+            node: AST If node to analyze
+        """
+        self._check_isinstance_pattern(node)
+        self.generic_visit(node)
+
+    def _check_isinstance_pattern(self, node: ast.If) -> None:
+        """Check if node is an isinstance LBYL pattern and record it."""
+        obj_expr, type_name = _try_extract_isinstance_call(node.test)
+        if obj_expr is None or type_name is None:
+            return
+
+        if self._body_has_object_operation(node.body, obj_expr):
+            self._patterns.append(self._create_pattern(node, obj_expr, type_name))
+
+    def _body_has_object_operation(self, body: list[ast.stmt], obj_expr: ast.expr) -> bool:
+        """Check if body contains operations on the isinstance-checked object."""
+        expected_obj = ast.dump(obj_expr)
+        return any(
+            self._node_uses_object(node, expected_obj) for stmt in body for node in ast.walk(stmt)
+        )
+
+    def _node_uses_object(self, node: ast.AST, expected_obj: str) -> bool:
+        """Check if AST node uses the expected object."""
+        if isinstance(node, ast.Attribute):
+            return ast.dump(node.value) == expected_obj
+        if isinstance(node, ast.Subscript):
+            return ast.dump(node.value) == expected_obj
+        if isinstance(node, ast.BinOp):
+            return self._binop_uses_object(node, expected_obj)
+        return False
+
+    def _binop_uses_object(self, node: ast.BinOp, expected_obj: str) -> bool:
+        """Check if binary operation uses the checked object."""
+        return ast.dump(node.left) == expected_obj or ast.dump(node.right) == expected_obj
+
+    def _create_pattern(
+        self, node: ast.If, obj_expr: ast.expr, type_name: str
+    ) -> IsinstancePattern:
+        """Create IsinstancePattern from detected pattern."""
+        return IsinstancePattern(
+            line_number=node.lineno,
+            column=node.col_offset,
+            object_name=ast.unparse(obj_expr),
+            type_name=type_name,
+        )

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,
+        )