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

src/linters/cqs/violation_builder.py

@@ -0,0 +1,94 @@
+"""
+Purpose: Builds Violation objects from CQSPattern instances
+
+Scope: Violation message formatting and suggestion generation for CQS violations
+
+Overview: Provides build_cqs_violation function that converts a CQSPattern with a detected
+    CQS violation into a Violation object with properly formatted message. Message includes
+    function name (with class prefix for methods), lists INPUT operations with line numbers,
+    lists OUTPUT operations with line numbers, and provides actionable suggestion to split
+    the function into separate query and command functions.
+
+Dependencies: CQSPattern, InputOperation, OutputOperation, Violation, Severity
+
+Exports: build_cqs_violation
+
+Interfaces: build_cqs_violation(pattern: CQSPattern) -> Violation
+
+Implementation: String formatting with INPUT/OUTPUT line number aggregation
+"""
+
+from src.core.types import Severity, Violation
+
+from .types import CQSPattern
+
+
+def _format_inputs(pattern: CQSPattern) -> str:
+    """Format INPUT operations for violation message.
+
+    Args:
+        pattern: CQSPattern containing inputs
+
+    Returns:
+        Formatted string listing INPUTs with line numbers
+    """
+    if not pattern.inputs:
+        return ""
+
+    parts = [f"Line {inp.line}: {inp.target} = {inp.expression}" for inp in pattern.inputs]
+    return "; ".join(parts)
+
+
+def _format_outputs(pattern: CQSPattern) -> str:
+    """Format OUTPUT operations for violation message.
+
+    Args:
+        pattern: CQSPattern containing outputs
+
+    Returns:
+        Formatted string listing OUTPUTs with line numbers
+    """
+    if not pattern.outputs:
+        return ""
+
+    parts = [f"Line {out.line}: {out.expression}" for out in pattern.outputs]
+    return "; ".join(parts)
+
+
+def build_cqs_violation(pattern: CQSPattern) -> Violation:
+    """Build a Violation object from a CQSPattern.
+
+    Creates a violation message that includes:
+    - Function name (with class prefix for methods)
+    - List of INPUT operations with line numbers
+    - List of OUTPUT operations with line numbers
+    - Suggestion to split into query and command functions
+
+    Args:
+        pattern: CQSPattern representing a function that violates CQS
+
+    Returns:
+        Violation object with formatted message and suggestion
+    """
+    full_name = pattern.get_full_name()
+
+    # Build detailed message
+    inputs_str = _format_inputs(pattern)
+    outputs_str = _format_outputs(pattern)
+
+    message = (
+        f"Function '{full_name}' violates CQS: mixes queries and commands. "
+        f"INPUTs: {inputs_str}. OUTPUTs: {outputs_str}."
+    )
+
+    suggestion = "Split into separate query and command functions."
+
+    return Violation(
+        rule_id="cqs",
+        file_path=pattern.file_path,
+        line=pattern.line,
+        column=pattern.column,
+        message=message,
+        severity=Severity.ERROR,
+        suggestion=suggestion,
+    )

src/linters/dry/typescript_value_extractor.py

@@ -19,6 +19,7 @@ Suppressions:
     - type:ignore[assignment,misc]: Tree-sitter Node type alias (optional dependency fallback)
 """
 
+from contextlib import suppress
 from typing import Any
 
 from src.analyzers.typescript_base import TREE_SITTER_AVAILABLE
@@ -46,7 +47,7 @@ class TypeScriptValueExtractor:
         """Get string representation of a value node."""
         if node.type in self.LITERAL_TYPES:
             return self.get_node_text(node, content)
-        if node.type in self.FIXED_REPRESENTATIONS:
+        with suppress(KeyError):
             return self.FIXED_REPRESENTATIONS[node.type]
         if node.type == "call_expression":
             return self._get_call_string(node, content)

src/linters/file_header/linter.py

@@ -27,6 +27,7 @@ Suppressions:
         languages. Methods support single responsibility of file header validation.
 """
 
+from contextlib import suppress
 from pathlib import Path
 from typing import Protocol
 
@@ -302,7 +303,7 @@ class FileHeaderRule(BaseLintRule):  # thailint: ignore[srp]
         prose_parts = []
 
         for field_name in prose_fields:
-            if field_name in fields:
+            with suppress(KeyError):
                 prose_parts.append(f"{field_name}: {fields[field_name]}")
 
         return "\n".join(prose_parts)

src/linters/file_placement/linter.py

@@ -27,6 +27,7 @@ Suppressions:
 """
 
 import json
+from contextlib import suppress
 from pathlib import Path
 from typing import Any
 
@@ -327,10 +328,10 @@ class FilePlacementRule(BaseLintRule):  # thailint: ignore[srp.violation]
         if not hasattr(context, "metadata"):
             return None
         # Try hyphenated format first (original format)
-        if "file-placement" in context.metadata:
+        with suppress(KeyError):
             return context.metadata["file-placement"]
         # Try underscored format (normalized format)
-        if "file_placement" in context.metadata:
+        with suppress(KeyError):
             return context.metadata["file_placement"]
         return None
 
@@ -364,7 +365,7 @@ class FilePlacementRule(BaseLintRule):  # thailint: ignore[srp.violation]
             FilePlacementLinter instance
         """
         # Check if cached linter exists for this project root
-        if project_root in self._linter_cache:
+        with suppress(KeyError):
             return self._linter_cache[project_root]
 
         # Try to get config from context metadata (orchestrator passes config here)
@@ -420,11 +421,10 @@ class FilePlacementRule(BaseLintRule):  # thailint: ignore[srp.violation]
             config = self._parse_layout_file(layout_path)
 
             # Unwrap file-placement key if present (try both formats for backward compatibility)
-            if "file-placement" in config:
+            with suppress(KeyError):
                 return config["file-placement"]
-            if "file_placement" in config:
+            with suppress(KeyError):
                 return config["file_placement"]
-
             return config
         except Exception:
             return {}

src/linters/file_placement/pattern_validator.py

@@ -18,6 +18,7 @@ Implementation: Uses re.compile() to test pattern validity, provides detailed er
 """
 
 import re
+from contextlib import suppress
 from typing import Any
 
 
@@ -76,7 +77,7 @@ class PatternValidator:
         Args:
             rules: Rules dictionary containing allow patterns
         """
-        if "allow" in rules:
+        with suppress(KeyError):
             for pattern in rules["allow"]:
                 self._validate_pattern(pattern)
 
@@ -86,7 +87,7 @@ class PatternValidator:
         Args:
             rules: Rules dictionary containing deny patterns
         """
-        if "deny" in rules:
+        with suppress(KeyError):
             for deny_item in rules["deny"]:
                 pattern = _extract_pattern(deny_item)
                 self._validate_pattern(pattern)
@@ -97,7 +98,7 @@ class PatternValidator:
         Args:
             fp_config: File placement configuration section
         """
-        if "directories" in fp_config:
+        with suppress(KeyError):
             for _dir_path, rules in fp_config["directories"].items():
                 self._validate_allow_patterns(rules)
                 self._validate_deny_patterns(rules)
@@ -108,7 +109,7 @@ class PatternValidator:
         Args:
             fp_config: File placement configuration section
         """
-        if "global_patterns" in fp_config:
+        with suppress(KeyError):
             self._validate_allow_patterns(fp_config["global_patterns"])
             self._validate_deny_patterns(fp_config["global_patterns"])
 
@@ -118,7 +119,7 @@ class PatternValidator:
         Args:
             fp_config: File placement configuration section
         """
-        if "global_deny" in fp_config:
+        with suppress(KeyError):
             for deny_item in fp_config["global_deny"]:
                 pattern = _extract_pattern(deny_item)
                 self._validate_pattern(pattern)

src/linters/file_placement/rule_checker.py

@@ -19,6 +19,7 @@ Implementation: Checks deny before allow, delegates directory matching to Direct
     uses RuleCheckContext dataclass to reduce parameter duplication
 """
 
+from contextlib import suppress
 from dataclasses import dataclass
 from pathlib import Path
 from typing import Any
@@ -76,17 +77,17 @@ class RuleChecker:
         """
         violations: list[Violation] = []
 
-        if "directories" in fp_config:
+        with suppress(KeyError):
             dir_violations = self._check_directory_rules(
                 path_str, rel_path, fp_config["directories"]
             )
             violations.extend(dir_violations)
 
-        if "global_deny" in fp_config:
+        with suppress(KeyError):
             deny_violations = self._check_global_deny(path_str, rel_path, fp_config["global_deny"])
             violations.extend(deny_violations)
 
-        if "global_patterns" in fp_config:
+        with suppress(KeyError):
             global_violations = self._check_global_patterns(
                 path_str, rel_path, fp_config["global_patterns"]
             )
@@ -209,21 +210,25 @@ class RuleChecker:
             List of violations
         """
         # Check deny patterns first
-        if "deny" in global_patterns:
+        try:
             is_denied, reason = self.pattern_matcher.match_deny_patterns(
                 path_str, global_patterns["deny"]
             )
             if is_denied:
                 violation = self.violation_factory.create_global_deny_violation(rel_path, reason)
                 return self._wrap_violation(violation)
+        except KeyError:
+            pass  # No deny patterns
 
         # Check allow patterns
-        if "allow" in global_patterns:
+        try:
             is_allowed = self.pattern_matcher.match_allow_patterns(
                 path_str, global_patterns["allow"]
             )
             if not is_allowed:
                 violation = self.violation_factory.create_global_allow_violation(rel_path)
                 return self._wrap_violation(violation)
+        except KeyError:
+            pass  # No allow patterns
 
         return []

src/linters/lazy_ignores/config.py

@@ -4,9 +4,9 @@ Purpose: Configuration for lazy-ignores linter
 Scope: All configurable options for ignore detection
 
 Overview: Provides LazyIgnoresConfig dataclass with pattern-specific toggles for each
-    ignore type (noqa, type:ignore, pylint, nosec, typescript, eslint, thailint). Includes
-    orphaned detection toggle and file pattern ignores. Configuration can be loaded from
-    dictionary (YAML) with sensible defaults for all options.
+    ignore type (noqa, type:ignore, pylint, nosec, pyright, typescript, eslint, thailint).
+    Includes orphaned detection toggle and file pattern ignores. Configuration can be
+    loaded from dictionary (YAML) with sensible defaults for all options.
 
 Dependencies: dataclasses, typing
 
@@ -33,6 +33,7 @@ class LazyIgnoresConfig:  # pylint: disable=too-many-instance-attributes
     check_type_ignore: bool = True
     check_pylint_disable: bool = True
     check_nosec: bool = True
+    check_pyright_ignore: bool = True
     check_ts_ignore: bool = True
     check_eslint_disable: bool = True
     check_thailint_ignore: bool = True
@@ -57,6 +58,7 @@ class LazyIgnoresConfig:  # pylint: disable=too-many-instance-attributes
             check_type_ignore=config_dict.get("check_type_ignore", True),
             check_pylint_disable=config_dict.get("check_pylint_disable", True),
             check_nosec=config_dict.get("check_nosec", True),
+            check_pyright_ignore=config_dict.get("check_pyright_ignore", True),
             check_ts_ignore=config_dict.get("check_ts_ignore", True),
             check_eslint_disable=config_dict.get("check_eslint_disable", True),
             check_thailint_ignore=config_dict.get("check_thailint_ignore", True),

src/linters/lazy_ignores/python_analyzer.py

@@ -1,7 +1,7 @@
 """
 Purpose: Detect Python linting ignore directives in source code
 
-Scope: noqa, type:ignore, pylint:disable, nosec, dry:ignore-block pattern detection
+Scope: noqa, type:ignore, pylint:disable, nosec, pyright:ignore, dry:ignore-block pattern detection
 
 Overview: Provides PythonIgnoreDetector class that scans Python source code for common
     linting ignore patterns. Detects bare patterns (e.g., # noqa) and rule-specific
@@ -106,6 +106,10 @@ class PythonIgnoreDetector:
             r"#\s*nosec(?:\s+([A-Z0-9,\s]+))?(?:\s|$)",
             re.IGNORECASE,
         ),
+        IgnoreType.PYRIGHT_IGNORE: re.compile(
+            r"#\s*pyright:\s*ignore(?:\[([^\]]+)\])?",
+            re.IGNORECASE,
+        ),
         IgnoreType.THAILINT_IGNORE: re.compile(
             r"#\s*thailint:\s*ignore(?!-)(?:\[([^\]]+)\])?",
             re.IGNORECASE,

src/linters/lazy_ignores/types.py

@@ -6,7 +6,7 @@ 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),
+    suppressions in file headers. Supports Python (noqa, type:ignore, pylint, nosec, pyright),
     TypeScript (@ts-ignore, eslint-disable), thai-lint (thailint:ignore), and test skip
     patterns (pytest.mark.skip, it.skip, describe.skip).
 
@@ -31,6 +31,7 @@ class IgnoreType(Enum):
     TYPE_IGNORE = "type:ignore"
     PYLINT_DISABLE = "pylint:disable"
     NOSEC = "nosec"
+    PYRIGHT_IGNORE = "pyright:ignore"
     TS_IGNORE = "ts-ignore"
     TS_NOCHECK = "ts-nocheck"
     TS_EXPECT_ERROR = "ts-expect-error"

src/linters/lbyl/__init__.py

@@ -12,7 +12,7 @@ Overview: Package providing LBYL pattern detection for Python code. Identifies c
 
 Dependencies: ast module for Python parsing, src.core for base classes
 
-Exports: LBYLConfig, LBYLPattern, BaseLBYLDetector
+Exports: LBYLConfig, LBYLPattern, BaseLBYLDetector, LBYLRule
 
 Interfaces: LBYLConfig.from_dict() for YAML configuration loading
 
@@ -20,10 +20,12 @@ Implementation: AST-based pattern detection with configurable pattern toggles
 """
 
 from .config import LBYLConfig
+from .linter import LBYLRule
 from .pattern_detectors.base import BaseLBYLDetector, LBYLPattern
 
 __all__ = [
     "LBYLConfig",
     "LBYLPattern",
     "BaseLBYLDetector",
+    "LBYLRule",
 ]

src/linters/lbyl/linter.py

@@ -0,0 +1,67 @@
+"""
+Purpose: Main LBYL linter rule implementing PythonOnlyLintRule interface
+
+Scope: Entry point for LBYL anti-pattern detection in Python code
+
+Overview: Provides LBYLRule class that implements the PythonOnlyLintRule interface for
+    detecting Look Before You Leap anti-patterns in Python code. Validates that files
+    are Python with content, loads configuration, and delegates analysis to
+    PythonLBYLAnalyzer. Returns violations with EAFP suggestions for detected patterns.
+    Supports disabling via configuration and pattern-specific toggles.
+
+Dependencies: PythonOnlyLintRule, PythonLBYLAnalyzer, LBYLConfig
+
+Exports: LBYLRule
+
+Interfaces: check(context: BaseLintContext) -> list[Violation]
+
+Implementation: Single-file analysis with config-driven pattern detection
+"""
+
+from src.core.python_lint_rule import PythonOnlyLintRule
+from src.core.types import Violation
+
+from .config import LBYLConfig
+from .python_analyzer import PythonLBYLAnalyzer
+
+
+class LBYLRule(PythonOnlyLintRule[LBYLConfig]):
+    """Detects Look Before You Leap anti-patterns in Python code."""
+
+    def __init__(self, config: LBYLConfig | None = None) -> None:
+        """Initialize the LBYL rule."""
+        super().__init__(config)
+        self._analyzer = PythonLBYLAnalyzer()
+
+    @property
+    def rule_id(self) -> str:
+        """Unique identifier for this rule."""
+        return "lbyl"
+
+    @property
+    def rule_name(self) -> str:
+        """Human-readable name for this rule."""
+        return "Look Before You Leap"
+
+    @property
+    def description(self) -> str:
+        """Description of what this rule checks."""
+        return (
+            "Detects LBYL (Look Before You Leap) anti-patterns that should be "
+            "refactored to EAFP (Easier to Ask Forgiveness than Permission) style "
+            "using try/except blocks."
+        )
+
+    @property
+    def _config_key(self) -> str:
+        """Configuration key in metadata."""
+        return "lbyl"
+
+    @property
+    def _config_class(self) -> type[LBYLConfig]:
+        """Configuration class type."""
+        return LBYLConfig
+
+    def _analyze(self, code: str, file_path: str, config: LBYLConfig) -> list[Violation]:
+        """Analyze code for LBYL violations."""
+        return self._analyzer.analyze(code, file_path, config)

src/linters/lbyl/pattern_detectors/__init__.py

@@ -6,11 +6,15 @@ Scope: All AST-based pattern detectors for LBYL anti-pattern detection
 Overview: Exports pattern detector classes for the LBYL linter. Each detector is an
     AST NodeVisitor that identifies specific LBYL anti-patterns. Detectors include
     dict key checking, hasattr, isinstance, file exists, length checks, None checks,
-    string validation, and division safety checks.
+    string validators, and division zero-checks.
 
 Dependencies: ast module, base detector class
 
-Exports: BaseLBYLDetector, LBYLPattern
+Exports: BaseLBYLDetector, LBYLPattern, DictKeyDetector, DictKeyPattern, HasattrDetector,
+    HasattrPattern, IsinstanceDetector, IsinstancePattern, FileExistsDetector,
+    FileExistsPattern, LenCheckDetector, LenCheckPattern, NoneCheckDetector,
+    NoneCheckPattern, StringValidatorDetector, StringValidatorPattern,
+    DivisionCheckDetector, DivisionCheckPattern
 
 Interfaces: find_patterns(tree: ast.AST) -> list[LBYLPattern]
 
@@ -18,8 +22,32 @@ Implementation: Modular detector pattern for extensible LBYL detection
 """
 
 from .base import BaseLBYLDetector, LBYLPattern
+from .dict_key_detector import DictKeyDetector, DictKeyPattern
+from .division_check_detector import DivisionCheckDetector, DivisionCheckPattern
+from .file_exists_detector import FileExistsDetector, FileExistsPattern
+from .hasattr_detector import HasattrDetector, HasattrPattern
+from .isinstance_detector import IsinstanceDetector, IsinstancePattern
+from .len_check_detector import LenCheckDetector, LenCheckPattern
+from .none_check_detector import NoneCheckDetector, NoneCheckPattern
+from .string_validator_detector import StringValidatorDetector, StringValidatorPattern
 
 __all__ = [
     "BaseLBYLDetector",
     "LBYLPattern",
+    "DictKeyDetector",
+    "DictKeyPattern",
+    "DivisionCheckDetector",
+    "DivisionCheckPattern",
+    "FileExistsDetector",
+    "FileExistsPattern",
+    "HasattrDetector",
+    "HasattrPattern",
+    "IsinstanceDetector",
+    "IsinstancePattern",
+    "LenCheckDetector",
+    "LenCheckPattern",
+    "NoneCheckDetector",
+    "NoneCheckPattern",
+    "StringValidatorDetector",
+    "StringValidatorPattern",
 ]

src/linters/lbyl/pattern_detectors/base.py

@@ -7,19 +7,21 @@ Overview: Defines BaseLBYLDetector abstract class that all pattern detectors ext
     Inherits from ast.NodeVisitor for AST traversal. Defines LBYLPattern base dataclass
     for representing detected patterns with line number and column information. Each
     concrete detector implements find_patterns() to identify specific LBYL anti-patterns.
+    Uses Generic TypeVar for type-safe subclass pattern storage.
 
-Dependencies: abc, ast, dataclasses
+Dependencies: abc, ast, dataclasses, typing
 
 Exports: BaseLBYLDetector, LBYLPattern
 
 Interfaces: find_patterns(tree: ast.AST) -> list[LBYLPattern]
 
-Implementation: Abstract base with NodeVisitor pattern for extensibility
+Implementation: Abstract base with NodeVisitor pattern for extensibility, Generic for type safety
 """
 
 import ast
-from abc import ABC, abstractmethod
+from abc import ABC
 from dataclasses import dataclass
+from typing import Generic, TypeVar
 
 
 @dataclass
@@ -30,10 +32,23 @@ class LBYLPattern:
     column: int
 
 
-class BaseLBYLDetector(ast.NodeVisitor, ABC):
-    """Base class for LBYL pattern detectors."""
+PatternT = TypeVar("PatternT", bound=LBYLPattern)
+
+
+class BaseLBYLDetector(ast.NodeVisitor, ABC, Generic[PatternT]):
+    """Base class for LBYL pattern detectors.
+
+    Subclasses must initialize self._patterns as an empty list in __init__
+    and populate it in visit methods. The _patterns attribute stores subclass-
+    specific pattern types (DictKeyPattern, HasattrPattern, etc.) which all
+    inherit from LBYLPattern.
+
+    Type Parameters:
+        PatternT: The specific pattern type used by this detector
+    """
+
+    _patterns: list[PatternT]
 
-    @abstractmethod
     def find_patterns(self, tree: ast.AST) -> list[LBYLPattern]:
         """Find LBYL patterns in AST.
 
@@ -43,4 +58,6 @@ class BaseLBYLDetector(ast.NodeVisitor, ABC):
         Returns:
             List of detected LBYL patterns
         """
-        raise NotImplementedError
+        self._patterns = []
+        self.visit(tree)
+        return list(self._patterns)

src/linters/lbyl/pattern_detectors/dict_key_detector.py

@@ -0,0 +1,107 @@
+"""
+Purpose: AST-based detector for dict key LBYL patterns
+
+Scope: Detects 'if key in dict: dict[key]' patterns in Python code
+
+Overview: Provides DictKeyDetector class that uses AST traversal to find LBYL anti-patterns
+    involving dict key checking. Identifies patterns where code checks if a key exists in a
+    dict before accessing it (e.g., 'if key in d: d[key]'). Returns DictKeyPattern objects
+    containing the dict name, key expression, and location. Avoids false positives for
+    different dict/key combinations, walrus operator patterns, and dict.get() usage.
+
+Dependencies: ast module, base detector classes from pattern_detectors.base
+
+Exports: DictKeyPattern, DictKeyDetector
+
+Interfaces: DictKeyDetector.find_patterns(tree: ast.AST) -> list[DictKeyPattern]
+
+Implementation: AST NodeVisitor pattern with visit_If to detect in-check followed by subscript
+
+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 DictKeyPattern(LBYLPattern):
+    """Pattern data for dict key LBYL anti-pattern."""
+
+    dict_name: str
+    key_expression: str
+
+
+def _is_walrus_get_pattern(test: ast.Compare) -> bool:
+    """Check if test is '(val := d.get(k)) is not None' pattern."""
+    if not isinstance(test.left, ast.NamedExpr):
+        return False
+    if not isinstance(test.left.value, ast.Call):
+        return False
+    call = test.left.value
+    return isinstance(call.func, ast.Attribute) and call.func.attr == "get"
+
+
+def _is_simple_in_compare(test: ast.Compare) -> bool:
+    """Check if Compare has single In operator and one comparator."""
+    return len(test.ops) == 1 and isinstance(test.ops[0], ast.In) and len(test.comparators) == 1
+
+
+def _extract_in_check(test: ast.expr) -> tuple[ast.expr | None, ast.expr | None]:
+    """Extract dict and key from 'key in dict' comparison."""
+    if isinstance(test, ast.NamedExpr):
+        return None, None
+    if not isinstance(test, ast.Compare):
+        return None, None
+    if not _is_simple_in_compare(test) or _is_walrus_get_pattern(test):
+        return None, None
+    return test.comparators[0], test.left
+
+
+class DictKeyDetector(BaseLBYLDetector[DictKeyPattern]):
+    """Detects 'if key in dict: dict[key]' LBYL patterns."""
+
+    def __init__(self) -> None:
+        """Initialize the detector."""
+        self._patterns: list[DictKeyPattern] = []
+
+    def visit_If(self, node: ast.If) -> None:  # noqa: N802  # pylint: disable=invalid-name
+        """Visit if statement to check for dict key LBYL pattern.
+
+        Args:
+            node: AST If node to analyze
+        """
+        dict_expr, key_expr = _extract_in_check(node.test)
+
+        if dict_expr is not None and key_expr is not None:
+            if self._body_has_subscript_match(node.body, dict_expr, key_expr):
+                self._patterns.append(self._create_pattern(node, dict_expr, key_expr))
+
+        self.generic_visit(node)
+
+    def _body_has_subscript_match(
+        self, body: list[ast.stmt], dict_expr: ast.expr, key_expr: ast.expr
+    ) -> bool:
+        """Check if body contains dict[key] access matching the in-check."""
+        expected = (ast.dump(dict_expr), ast.dump(key_expr))
+        return any(
+            (ast.dump(node.value), ast.dump(node.slice)) == expected
+            for stmt in body
+            for node in ast.walk(stmt)
+            if isinstance(node, ast.Subscript)
+        )
+
+    def _create_pattern(
+        self, node: ast.If, dict_expr: ast.expr, key_expr: ast.expr
+    ) -> DictKeyPattern:
+        """Create DictKeyPattern from detected pattern."""
+        return DictKeyPattern(
+            line_number=node.lineno,
+            column=node.col_offset,
+            dict_name=ast.unparse(dict_expr),
+            key_expression=ast.unparse(key_expr),
+        )