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

src/linters/lbyl/pattern_detectors/division_check_detector.py

@@ -0,0 +1,232 @@
+"""
+Purpose: AST-based detector for division zero-check LBYL patterns
+
+Scope: Detects 'if x != 0: a / x' patterns in Python code
+
+Overview: Provides DivisionCheckDetector class that uses AST traversal to find LBYL
+    anti-patterns involving zero-checks before division. Identifies patterns where code
+    checks if a divisor is non-zero before dividing (e.g., 'if x != 0: a / x'). Also
+    detects inverse patterns with else branches and truthy checks. Covers division (/),
+    integer division (//), modulo (%), and augmented operators (/=, //=, %=).
+
+Dependencies: ast module, base detector classes from pattern_detectors.base
+
+Exports: DivisionCheckPattern, DivisionCheckDetector
+
+Interfaces: DivisionCheckDetector.find_patterns(tree: ast.AST) -> list[DivisionCheckPattern]
+
+Implementation: AST NodeVisitor pattern with visit_If to detect zero comparison followed
+    by division using the checked variable
+
+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
+
+
+@dataclass
+class DivisionCheckPattern(LBYLPattern):
+    """Pattern data for division check LBYL anti-pattern."""
+
+    divisor_name: str
+    operation: str
+
+
+def _is_zero_constant(node: ast.expr) -> bool:
+    """Check if node is a zero constant."""
+    return isinstance(node, ast.Constant) and node.value == 0
+
+
+def _try_extract_zero_check(node: ast.expr) -> tuple[ast.expr | None, bool]:
+    """Try to extract variable from zero comparison.
+
+    Returns:
+        Tuple of (variable_expr, is_non_zero_check) or (None, False) if not valid.
+        is_non_zero_check is True for '!= 0', False for '== 0'.
+    """
+    if isinstance(node, ast.Compare):
+        return _extract_zero_comparison(node)
+    # Handle truthy check: if x: (implicit != 0)
+    if isinstance(node, ast.Name):
+        return node, True
+    if isinstance(node, ast.Attribute):
+        return node, True
+    if isinstance(node, ast.Subscript):
+        return node, True
+    return None, False
+
+
+def _is_equality_op(node: ast.Compare) -> ast.cmpop | None:
+    """Return equality operator if it's a single eq/noteq comparison, else None."""
+    if len(node.ops) != 1 or len(node.comparators) != 1:
+        return None
+    op = node.ops[0]
+    return op if isinstance(op, (ast.Eq, ast.NotEq)) else None
+
+
+def _extract_zero_comparison(node: ast.Compare) -> tuple[ast.expr | None, bool]:
+    """Extract variable from 'x != 0' or 'x == 0' comparison.
+
+    Returns:
+        Tuple of (variable_expr, is_non_zero) or (None, False) if not valid.
+    """
+    op = _is_equality_op(node)
+    if op is None:
+        return None, False
+
+    left, right = node.left, node.comparators[0]
+    is_not_eq = isinstance(op, ast.NotEq)
+
+    # Check for 'x != 0', 'x == 0', '0 != x', '0 == x'
+    if _is_zero_constant(right):
+        return left, is_not_eq
+    if _is_zero_constant(left):
+        return right, is_not_eq
+
+    return None, False
+
+
+def _get_expression_key(expr: ast.expr) -> str:
+    """Get a normalized key for comparing expressions."""
+    return ast.dump(expr)
+
+
+# Maps BinOp operator types to their string representation
+DIVISION_BINOP_MAP = {
+    ast.Div: "/",
+    ast.FloorDiv: "//",
+    ast.Mod: "%",
+}
+
+# Maps AugAssign operator types to their string representation
+DIVISION_AUGOP_MAP = {
+    ast.Div: "/=",
+    ast.FloorDiv: "//=",
+    ast.Mod: "%=",
+}
+
+# Keywords suggesting path-related variables (likely pathlib, not numeric division)
+PATH_KEYWORDS = frozenset({"path", "file", "dir", "folder", "root", "name", "directory"})
+
+
+def _get_variable_name(expr: ast.expr) -> str:
+    """Extract variable name from expression for heuristic checks."""
+    if isinstance(expr, ast.Name):
+        return expr.id.lower()
+    if isinstance(expr, ast.Attribute):
+        return expr.attr.lower()
+    return ""
+
+
+def _looks_like_path_variable(expr: ast.expr) -> bool:
+    """Check if expression name suggests it's a path-related variable."""
+    name = _get_variable_name(expr)
+    return any(keyword in name for keyword in PATH_KEYWORDS)
+
+
+def _is_likely_pathlib_division(node: ast.BinOp) -> bool:
+    """Check if BinOp is likely pathlib path joining, not numeric division.
+
+    Heuristics:
+    - If left operand has path-related name (e.g., project_root, base_path)
+    - If right operand has path-related name (e.g., file_name, sub_dir)
+    - Only applies to single `/`, not `//` or `%`
+    """
+    if not isinstance(node.op, ast.Div):
+        return False
+    return _looks_like_path_variable(node.left) or _looks_like_path_variable(node.right)
+
+
+def _check_binop(node: ast.BinOp, expected_key: str) -> str | None:
+    """Check if BinOp is division with expected divisor."""
+    op_str = DIVISION_BINOP_MAP.get(type(node.op))
+    if not op_str:
+        return None
+    if _get_expression_key(node.right) != expected_key:
+        return None
+    # Skip likely pathlib operations (false positive avoidance)
+    if _is_likely_pathlib_division(node):
+        return None
+    return op_str
+
+
+def _check_augassign(node: ast.AugAssign, expected_key: str) -> str | None:
+    """Check if AugAssign is division with expected divisor."""
+    op_str = DIVISION_AUGOP_MAP.get(type(node.op))
+    if op_str and _get_expression_key(node.value) == expected_key:
+        return op_str
+    return None
+
+
+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 _check_division_node(node: ast.AST, expected_key: str) -> str | None:
+    """Check if AST node is a division using expected divisor."""
+    if isinstance(node, ast.BinOp):
+        return _check_binop(node, expected_key)
+    if isinstance(node, ast.AugAssign):
+        return _check_augassign(node, expected_key)
+    return None
+
+
+def _find_division(body: list[ast.stmt], expected_key: str) -> str | None:
+    """Find first division operation using expected divisor in body."""
+    for node in _iter_ast_nodes(body):
+        result = _check_division_node(node, expected_key)
+        if result:
+            return result
+    return None
+
+
+class DivisionCheckDetector(BaseLBYLDetector[DivisionCheckPattern]):
+    """Detects 'if x != 0: a / x' LBYL patterns."""
+
+    def __init__(self) -> None:
+        """Initialize the detector."""
+        self._patterns: list[DivisionCheckPattern] = []
+
+    def visit_If(self, node: ast.If) -> None:  # noqa: N802  # pylint: disable=invalid-name
+        """Visit if statement to check for division zero-check LBYL pattern.
+
+        Args:
+            node: AST If node to analyze
+        """
+        self._check_division_pattern(node)
+        self.generic_visit(node)
+
+    def _check_division_pattern(self, node: ast.If) -> None:
+        """Check if node is a division zero-check LBYL pattern and record it."""
+        var_expr, is_non_zero = _try_extract_zero_check(node.test)
+        if var_expr is None:
+            return
+
+        # For '!= 0' or truthy, check body; for '== 0', check else branch
+        body_to_check = node.body if is_non_zero else node.orelse
+        if not body_to_check:
+            return
+
+        expected_key = _get_expression_key(var_expr)
+        operation = _find_division(body_to_check, expected_key)
+        if operation:
+            self._patterns.append(self._create_pattern(node, var_expr, operation))
+
+    def _create_pattern(
+        self, node: ast.If, var_expr: ast.expr, operation: str
+    ) -> DivisionCheckPattern:
+        """Create DivisionCheckPattern from detected pattern."""
+        return DivisionCheckPattern(
+            line_number=node.lineno,
+            column=node.col_offset,
+            divisor_name=ast.unparse(var_expr),
+            operation=operation,
+        )

src/linters/lbyl/pattern_detectors/file_exists_detector.py

@@ -0,0 +1,220 @@
+"""
+Purpose: AST-based detector for file exists LBYL patterns
+
+Scope: Detects 'if os.path.exists(f): open(f)' and 'if Path(f).exists(): open(f)' patterns
+
+Overview: Provides FileExistsDetector class that uses AST traversal to find LBYL anti-patterns
+    involving file existence checking. Identifies patterns where code checks if a file exists
+    before opening it. Handles both os.path.exists and pathlib.Path.exists patterns, including
+    import aliases. Returns FileExistsPattern objects containing the file path expression and
+    location. Avoids false positives for directory checks and different file paths.
+
+Dependencies: ast module, base detector classes from pattern_detectors.base
+
+Exports: FileExistsPattern, FileExistsDetector
+
+Interfaces: FileExistsDetector.find_patterns(tree: ast.AST) -> list[FileExistsPattern]
+
+Implementation: AST NodeVisitor pattern with visit_If to detect exists check followed by
+    file operation (open, read_text, write_text)
+
+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 FileExistsPattern(LBYLPattern):
+    """Pattern data for file exists LBYL anti-pattern."""
+
+    file_path_expression: str
+    check_type: str  # "os.path.exists", "Path.exists", "exists"
+
+
+# File operation methods on Path objects
+_PATH_FILE_METHODS = frozenset(("read_text", "write_text", "read_bytes", "write_bytes"))
+
+
+def _is_exists_attribute_call(node: ast.Call) -> bool:
+    """Check if node is a method call to .exists() with one argument."""
+    if not isinstance(node.func, ast.Attribute):
+        return False
+    return node.func.attr == "exists" and len(node.args) == 1
+
+
+def _get_os_path_check_type(
+    func_value: ast.expr, path_arg: ast.expr
+) -> tuple[ast.expr | None, str | None]:
+    """Get check type for os.path.exists or alias.exists pattern."""
+    if isinstance(func_value, ast.Attribute) and func_value.attr == "path":
+        return path_arg, "os.path.exists"
+    if isinstance(func_value, ast.Name):
+        return path_arg, f"{func_value.id}.exists"
+    return None, None
+
+
+def _check_os_path_exists_attribute(node: ast.Call) -> tuple[ast.expr | None, str | None]:
+    """Check for os.path.exists(f) or alias.exists(f) pattern."""
+    if not _is_exists_attribute_call(node):
+        return None, None
+    func = node.func
+    if not isinstance(func, ast.Attribute):
+        return None, None
+    return _get_os_path_check_type(func.value, node.args[0])
+
+
+def _check_exists_name_call(node: ast.Call) -> tuple[ast.expr | None, str | None]:
+    """Check for exists(f) pattern from 'from os.path import exists'."""
+    if isinstance(node.func, ast.Name) and node.func.id == "exists" and len(node.args) == 1:
+        return node.args[0], "exists"
+    return None, None
+
+
+def _is_os_path_exists_call(node: ast.expr) -> tuple[ast.expr | None, str | None]:
+    """Check if node is os.path.exists(f) or exists(f) call."""
+    if not isinstance(node, ast.Call):
+        return None, None
+
+    result = _check_os_path_exists_attribute(node)
+    if result[0] is not None:
+        return result
+    return _check_exists_name_call(node)
+
+
+def _is_os_path_attribute(node: ast.expr) -> bool:
+    """Check if node is an os.path attribute access."""
+    return isinstance(node, ast.Attribute) and node.attr == "path"
+
+
+def _check_path_constructor_exists(func_value: ast.expr) -> tuple[ast.expr | None, str | None]:
+    """Check for Path(f).exists() pattern."""
+    if not isinstance(func_value, ast.Call):
+        return None, None
+    if not isinstance(func_value.func, ast.Name) or func_value.func.id != "Path":
+        return None, None
+    if len(func_value.args) == 1:
+        return func_value.args[0], "Path.exists"
+    return None, None
+
+
+def _check_variable_exists(func_value: ast.expr) -> tuple[ast.expr | None, str | None]:
+    """Check for p.exists() or self.path.exists() pattern."""
+    if isinstance(func_value, (ast.Name, ast.Attribute)):
+        return func_value, "Path.exists"
+    return None, None
+
+
+def _is_pathlib_exists_method(node: ast.expr) -> bool:
+    """Check if node is a .exists() method call (not os.path.exists)."""
+    if not isinstance(node, ast.Call):
+        return False
+    if not isinstance(node.func, ast.Attribute) or node.func.attr != "exists":
+        return False
+    return not _is_os_path_attribute(node.func.value)
+
+
+def _extract_pathlib_func_value(node: ast.expr) -> ast.expr | None:
+    """Extract func value from pathlib .exists() call, or None."""
+    if not _is_pathlib_exists_method(node):
+        return None
+    # After _is_pathlib_exists_method, we know node is Call with Attribute func
+    if not isinstance(node, ast.Call) or not isinstance(node.func, ast.Attribute):
+        return None
+    return node.func.value
+
+
+def _is_pathlib_exists_call(node: ast.expr) -> tuple[ast.expr | None, str | None]:
+    """Check if node is Path(f).exists() or p.exists() call."""
+    func_value = _extract_pathlib_func_value(node)
+    if func_value is None:
+        return None, None
+
+    result = _check_path_constructor_exists(func_value)
+    if result[0] is not None:
+        return result
+    return _check_variable_exists(func_value)
+
+
+def _try_extract_exists_call(node: ast.expr) -> tuple[ast.expr | None, str | None]:
+    """Try to extract file exists call arguments."""
+    result = _is_os_path_exists_call(node)
+    if result[0] is not None:
+        return result
+    return _is_pathlib_exists_call(node)
+
+
+def _is_open_call(node: ast.Call, expected_path: str) -> bool:
+    """Check if node is open(path) call."""
+    if not isinstance(node.func, ast.Name) or node.func.id != "open":
+        return False
+    return len(node.args) >= 1 and ast.dump(node.args[0]) == expected_path
+
+
+def _is_path_method_call(node: ast.Call, expected_path: str) -> bool:
+    """Check if node is path.read_text() or similar method call."""
+    if not isinstance(node.func, ast.Attribute):
+        return False
+    if node.func.attr not in _PATH_FILE_METHODS:
+        return False
+    return ast.dump(node.func.value) == expected_path
+
+
+def _is_file_operation(node: ast.AST, expected_path: str) -> bool:
+    """Check if node is a file operation on the expected path."""
+    if not isinstance(node, ast.Call):
+        return False
+    return _is_open_call(node, expected_path) or _is_path_method_call(node, expected_path)
+
+
+def _is_inverted_check(test: ast.expr) -> bool:
+    """Check if test is 'not exists(f)' pattern."""
+    return isinstance(test, ast.UnaryOp) and isinstance(test.op, ast.Not)
+
+
+class FileExistsDetector(BaseLBYLDetector[FileExistsPattern]):
+    """Detects 'if exists(f): open(f)' LBYL patterns."""
+
+    def __init__(self) -> None:
+        """Initialize the detector."""
+        self._patterns: list[FileExistsPattern] = []
+
+    def visit_If(self, node: ast.If) -> None:  # noqa: N802  # pylint: disable=invalid-name
+        """Visit if statement to check for file exists LBYL pattern."""
+        self._check_file_exists_pattern(node)
+        self.generic_visit(node)
+
+    def _check_file_exists_pattern(self, node: ast.If) -> None:
+        """Check if node matches file exists LBYL pattern."""
+        if _is_inverted_check(node.test):
+            return
+
+        path_expr, check_type = _try_extract_exists_call(node.test)
+        if path_expr is None or check_type is None:
+            return
+
+        if self._body_has_file_operation(node.body, path_expr):
+            self._patterns.append(self._create_pattern(node, path_expr, check_type))
+
+    def _body_has_file_operation(self, body: list[ast.stmt], path_expr: ast.expr) -> bool:
+        """Check if body contains file operation on the same path."""
+        expected_path = ast.dump(path_expr)
+        return any(
+            _is_file_operation(node, expected_path) for stmt in body for node in ast.walk(stmt)
+        )
+
+    def _create_pattern(
+        self, node: ast.If, path_expr: ast.expr, check_type: str
+    ) -> FileExistsPattern:
+        """Create FileExistsPattern from detected pattern."""
+        return FileExistsPattern(
+            line_number=node.lineno,
+            column=node.col_offset,
+            file_path_expression=ast.unparse(path_expr),
+            check_type=check_type,
+        )

src/linters/lbyl/pattern_detectors/hasattr_detector.py

@@ -0,0 +1,119 @@
+"""
+Purpose: AST-based detector for hasattr LBYL patterns
+
+Scope: Detects 'if hasattr(obj, attr): obj.attr' patterns in Python code
+
+Overview: Provides HasattrDetector class that uses AST traversal to find LBYL anti-patterns
+    involving hasattr checking. Identifies patterns where code checks if an object has an
+    attribute before accessing it (e.g., 'if hasattr(obj, "attr"): obj.attr'). Returns
+    HasattrPattern objects containing the object name, attribute name, and location. Avoids
+    false positives for different object/attribute combinations, variable attributes, and
+    getattr usage.
+
+Dependencies: ast module, base detector classes from pattern_detectors.base
+
+Exports: HasattrPattern, HasattrDetector
+
+Interfaces: HasattrDetector.find_patterns(tree: ast.AST) -> list[HasattrPattern]
+
+Implementation: AST NodeVisitor pattern with visit_If to detect hasattr check followed by
+    attribute 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 HasattrPattern(LBYLPattern):
+    """Pattern data for hasattr LBYL anti-pattern."""
+
+    object_name: str
+    attribute_name: str
+
+
+def _try_extract_hasattr_call(node: ast.expr) -> tuple[ast.expr | None, str | None]:
+    """Try to extract hasattr call arguments.
+
+    Returns:
+        Tuple of (object_expr, attribute_name) or (None, None) if not a valid hasattr call.
+    """
+    if not isinstance(node, ast.Call):
+        return None, None
+    if not isinstance(node.func, ast.Name) or node.func.id != "hasattr":
+        return None, None
+    return _extract_hasattr_args(node)
+
+
+def _extract_hasattr_args(call: ast.Call) -> tuple[ast.expr | None, str | None]:
+    """Extract object and attribute name from hasattr call args.
+
+    Returns:
+        Tuple of (object_expr, attribute_name) or (None, None) if not valid.
+    """
+    if len(call.args) != 2:
+        return None, None
+
+    attr_arg = call.args[1]
+    if not isinstance(attr_arg, ast.Constant) or not isinstance(attr_arg.value, str):
+        return None, None
+
+    return call.args[0], attr_arg.value
+
+
+class HasattrDetector(BaseLBYLDetector[HasattrPattern]):
+    """Detects 'if hasattr(obj, attr): obj.attr' LBYL patterns."""
+
+    def __init__(self) -> None:
+        """Initialize the detector."""
+        self._patterns: list[HasattrPattern] = []
+
+    def visit_If(self, node: ast.If) -> None:  # noqa: N802  # pylint: disable=invalid-name
+        """Visit if statement to check for hasattr LBYL pattern.
+
+        Args:
+            node: AST If node to analyze
+        """
+        self._check_hasattr_pattern(node)
+        self.generic_visit(node)
+
+    def _check_hasattr_pattern(self, node: ast.If) -> None:
+        """Check if node is a hasattr LBYL pattern and record it."""
+        obj_expr, attr_name = _try_extract_hasattr_call(node.test)
+        if obj_expr is None or attr_name is None:
+            return
+
+        if self._body_has_attribute_access(node.body, obj_expr, attr_name):
+            self._patterns.append(self._create_pattern(node, obj_expr, attr_name))
+
+    def _body_has_attribute_access(
+        self, body: list[ast.stmt], obj_expr: ast.expr, attr_name: str
+    ) -> bool:
+        """Check if body contains obj.attr access matching the hasattr check."""
+        expected_obj = ast.dump(obj_expr)
+        return any(
+            self._is_matching_attribute(node, expected_obj, attr_name)
+            for stmt in body
+            for node in ast.walk(stmt)
+        )
+
+    def _is_matching_attribute(self, node: ast.AST, expected_obj: str, attr_name: str) -> bool:
+        """Check if node is an attribute access matching expected object and name."""
+        if not isinstance(node, ast.Attribute):
+            return False
+        return node.attr == attr_name and ast.dump(node.value) == expected_obj
+
+    def _create_pattern(self, node: ast.If, obj_expr: ast.expr, attr_name: str) -> HasattrPattern:
+        """Create HasattrPattern from detected pattern."""
+        return HasattrPattern(
+            line_number=node.lineno,
+            column=node.col_offset,
+            object_name=ast.unparse(obj_expr),
+            attribute_name=attr_name,
+        )

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