yuho 5.0.0__py3-none-any.whl

yuho/ast/overlap.py

@@ -0,0 +1,291 @@
+"""
+Overlap detector for match expression patterns.
+
+Detects when match arm patterns overlap, which may indicate legal ambiguity
+in statute definitions. Two patterns overlap when they can both match
+the same value, creating potential interpretation conflicts.
+"""
+
+from dataclasses import dataclass, field
+from typing import List, Optional, Set, Tuple, Any
+
+from yuho.ast import nodes
+from yuho.ast.visitor import Visitor
+from yuho.ast.type_inference import TypeInferenceResult
+from yuho.ast.exhaustiveness import (
+    AbstractPattern,
+    PatternKind,
+    PatternExtractor,
+)
+
+
+@dataclass
+class PatternOverlap:
+    """Information about overlapping patterns."""
+    
+    arm1_index: int
+    arm2_index: int
+    arm1_line: int = 0
+    arm2_line: int = 0
+    description: str = ""
+    
+    def __str__(self) -> str:
+        return (
+            f"Arms #{self.arm1_index + 1} and #{self.arm2_index + 1} overlap: "
+            f"{self.description}"
+        )
+
+
+@dataclass
+class OverlapWarning:
+    """Warning for overlapping patterns."""
+    
+    message: str
+    line: int = 0
+    column: int = 0
+    arm1_index: int = -1
+    arm2_index: int = -1
+    severity: str = "warning"
+    
+    def __str__(self) -> str:
+        loc = f":{self.line}:{self.column}" if self.line else ""
+        return f"{loc} warning: {self.message}"
+
+
+@dataclass
+class OverlapResult:
+    """Result of overlap analysis for a match expression."""
+    
+    match_node: Optional[nodes.MatchExprNode]
+    overlaps: List[PatternOverlap] = field(default_factory=list)
+    
+    @property
+    def has_overlaps(self) -> bool:
+        return len(self.overlaps) > 0
+
+
+class OverlapDetector(Visitor):
+    """
+    Detects overlapping patterns in match expressions.
+    
+    Two patterns overlap if they can match the same value. This is important
+    in legal contexts where overlapping statute elements may create ambiguity
+    about which provision applies.
+    
+    Note: This differs from reachability - overlapping patterns can both be
+    reachable if neither completely covers the other, but they share some
+    common cases.
+    
+    Usage:
+        detector = OverlapDetector()
+        module.accept(detector)
+        
+        for warning in detector.warnings:
+            print(warning)
+    """
+    
+    def __init__(self, type_info: Optional[TypeInferenceResult] = None):
+        self.type_info = type_info or TypeInferenceResult()
+        self.warnings: List[OverlapWarning] = []
+        self.results: List[OverlapResult] = []
+        self._extractor = PatternExtractor(type_info)
+    
+    def check(self, module: nodes.ModuleNode) -> List[OverlapWarning]:
+        """Check all match expressions in module for overlapping patterns."""
+        self.visit(module)
+        return self.warnings
+    
+    def _patterns_overlap(
+        self,
+        p1: AbstractPattern,
+        p2: AbstractPattern,
+    ) -> bool:
+        """
+        Check if two patterns can match the same value.
+        
+        Patterns overlap if there exists some value v such that
+        both p1 and p2 would match v.
+        
+        Cases:
+        - Wildcard overlaps with everything
+        - Same literal values overlap
+        - Different literal values don't overlap
+        - Struct patterns overlap if same constructor and all fields overlap
+        """
+        # Wildcards overlap with everything
+        if p1.is_wildcard() or p2.is_wildcard():
+            return True
+        
+        # Guards make overlap uncertain - assume overlap to be safe
+        if p1.has_guard or p2.has_guard:
+            return True
+        
+        # Different kinds don't overlap (except with wildcards, handled above)
+        if p1.kind != p2.kind:
+            return False
+        
+        if p1.kind == PatternKind.LITERAL:
+            # Literals overlap only if same value
+            return p1.value == p2.value
+        
+        if p1.kind == PatternKind.STRUCT:
+            # Struct patterns overlap if same constructor and fields overlap
+            if p1.value != p2.value:
+                return False
+            
+            # Check field patterns
+            if len(p1.children) != len(p2.children):
+                # Different arities - shouldn't happen for same constructor
+                return False
+            
+            # All corresponding fields must overlap for structs to overlap
+            for c1, c2 in zip(p1.children, p2.children):
+                if not self._patterns_overlap(c1, c2):
+                    return False
+            
+            return True
+        
+        # Unknown pattern kinds - assume overlap to be safe
+        return True
+    
+    def _describe_overlap(
+        self,
+        p1: AbstractPattern,
+        p2: AbstractPattern,
+    ) -> str:
+        """Generate a description of why patterns overlap."""
+        if p1.is_wildcard() and p2.is_wildcard():
+            return "both are catch-all patterns"
+        
+        if p1.is_wildcard():
+            return f"wildcard overlaps with {self._pattern_str(p2)}"
+        
+        if p2.is_wildcard():
+            return f"{self._pattern_str(p1)} overlaps with wildcard"
+        
+        if p1.kind == PatternKind.LITERAL and p2.kind == PatternKind.LITERAL:
+            if p1.value == p2.value:
+                return f"duplicate literal pattern: {p1.value}"
+        
+        if p1.kind == PatternKind.STRUCT and p2.kind == PatternKind.STRUCT:
+            if p1.value == p2.value:
+                return f"both match constructor '{p1.value}'"
+        
+        return "patterns can match the same value"
+    
+    def _pattern_str(self, p: AbstractPattern) -> str:
+        """Convert pattern to string for display."""
+        if p.is_wildcard():
+            return "_"
+        
+        if p.kind == PatternKind.LITERAL:
+            if isinstance(p.value, bool):
+                return "TRUE" if p.value else "FALSE"
+            if isinstance(p.value, str):
+                return f'"{p.value}"'
+            return str(p.value)
+        
+        if p.kind == PatternKind.STRUCT:
+            children_str = ", ".join(self._pattern_str(c) for c in p.children)
+            if children_str:
+                return f"{p.value}({children_str})"
+            return str(p.value)
+        
+        return "?"
+    
+    def _get_arm_location(self, arm: nodes.MatchArm) -> Tuple[int, int]:
+        """Extract source location from match arm."""
+        if arm.source_location:
+            return arm.source_location.start_line, arm.source_location.start_column
+        if arm.pattern.source_location:
+            return arm.pattern.source_location.start_line, arm.pattern.source_location.start_column
+        return 0, 0
+    
+    def _check_match_overlaps(
+        self,
+        node: nodes.MatchExprNode,
+    ) -> OverlapResult:
+        """Check for overlapping patterns in a match expression."""
+        overlaps: List[PatternOverlap] = []
+        
+        # Extract all patterns
+        patterns = []
+        for arm in node.arms:
+            pattern = self._extractor.extract(arm.pattern, has_guard=arm.guard is not None)
+            patterns.append(pattern)
+        
+        # Compare each pair of patterns
+        for i in range(len(patterns)):
+            for j in range(i + 1, len(patterns)):
+                p1, p2 = patterns[i], patterns[j]
+                
+                # Skip if one completely covers the other (handled by reachability)
+                # We only care about partial overlaps
+                if p1.covers(p2) or p2.covers(p1):
+                    continue
+                
+                if self._patterns_overlap(p1, p2):
+                    line1, col1 = self._get_arm_location(node.arms[i])
+                    line2, col2 = self._get_arm_location(node.arms[j])
+                    
+                    overlaps.append(PatternOverlap(
+                        arm1_index=i,
+                        arm2_index=j,
+                        arm1_line=line1,
+                        arm2_line=line2,
+                        description=self._describe_overlap(p1, p2),
+                    ))
+        
+        return OverlapResult(
+            match_node=node,
+            overlaps=overlaps,
+        )
+    
+    def visit_match_expr(self, node: nodes.MatchExprNode) -> Any:
+        """Check for overlapping patterns in match expression."""
+        # Visit children first
+        self.generic_visit(node)
+        
+        result = self._check_match_overlaps(node)
+        self.results.append(result)
+        
+        # Generate warnings for overlaps
+        for overlap in result.overlaps:
+            # Use location of first arm
+            line = overlap.arm1_line
+            column = 0
+            
+            self.warnings.append(OverlapWarning(
+                message=(
+                    f"Match arms #{overlap.arm1_index + 1} and #{overlap.arm2_index + 1} "
+                    f"overlap: {overlap.description}"
+                ),
+                line=line,
+                column=column,
+                arm1_index=overlap.arm1_index,
+                arm2_index=overlap.arm2_index,
+            ))
+        
+        return None
+    
+    def visit_module(self, node: nodes.ModuleNode) -> Any:
+        """Entry point: check all match expressions in module."""
+        return self.generic_visit(node)
+
+
+def check_overlaps(
+    module: nodes.ModuleNode,
+    type_info: Optional[TypeInferenceResult] = None,
+) -> List[OverlapWarning]:
+    """
+    Check for overlapping patterns in all match expressions.
+    
+    Args:
+        module: The module AST to check
+        type_info: Optional type inference result for better analysis
+    
+    Returns:
+        List of warnings for overlapping patterns
+    """
+    detector = OverlapDetector(type_info)
+    return detector.check(module)

yuho/ast/reachability.py

@@ -0,0 +1,293 @@
+"""
+Reachability checker for match expressions.
+
+Detects unreachable match arms (dead code) by analyzing whether
+earlier patterns already cover all cases that a later pattern would match.
+Uses the same pattern matrix techniques as exhaustiveness checking.
+"""
+
+from dataclasses import dataclass, field
+from typing import List, Optional, Set, Dict, Any
+
+from yuho.ast import nodes
+from yuho.ast.visitor import Visitor
+from yuho.ast.type_inference import TypeInferenceResult, UNKNOWN_TYPE
+from yuho.ast.exhaustiveness import (
+    AbstractPattern,
+    PatternKind,
+    PatternMatrix,
+    PatternRow,
+    PatternExtractor,
+)
+
+
+@dataclass
+class UnreachableArm:
+    """Information about an unreachable match arm."""
+    
+    arm_index: int
+    line: int = 0
+    column: int = 0
+    reason: str = "arm is unreachable"
+    
+    def __str__(self) -> str:
+        loc = f":{self.line}:{self.column}" if self.line else ""
+        return f"{loc} {self.reason}"
+
+
+@dataclass
+class ReachabilityError:
+    """Error for unreachable code detection."""
+    
+    message: str
+    line: int = 0
+    column: int = 0
+    arm_index: int = -1
+    severity: str = "warning"  # Unreachable code is typically a warning
+    
+    def __str__(self) -> str:
+        loc = f":{self.line}:{self.column}" if self.line else ""
+        return f"{loc} warning: {self.message}"
+
+
+@dataclass
+class ReachabilityResult:
+    """Result of reachability analysis for a match expression."""
+    
+    match_node: Optional[nodes.MatchExprNode]
+    unreachable_arms: List[UnreachableArm] = field(default_factory=list)
+    
+    @property
+    def all_reachable(self) -> bool:
+        return len(self.unreachable_arms) == 0
+
+
+class ReachabilityChecker(Visitor):
+    """
+    Checks for unreachable match arms (dead code).
+    
+    A match arm is unreachable if all patterns it could match are already
+    covered by earlier arms. This is determined by checking if adding the
+    arm's pattern to the matrix of previous arms would be "useless".
+    
+    Usage:
+        type_visitor = TypeInferenceVisitor()
+        module.accept(type_visitor)
+        
+        checker = ReachabilityChecker(type_visitor.result)
+        module.accept(checker)
+        
+        for error in checker.errors:
+            print(error)
+    """
+    
+    def __init__(self, type_info: Optional[TypeInferenceResult] = None):
+        self.type_info = type_info or TypeInferenceResult()
+        self.errors: List[ReachabilityError] = []
+        self.results: List[ReachabilityResult] = []
+        self._extractor = PatternExtractor(type_info)
+    
+    def check(self, module: nodes.ModuleNode) -> List[ReachabilityError]:
+        """Check all match expressions in module for unreachable arms."""
+        self.visit(module)
+        return self.errors
+    
+    def _is_pattern_useful(
+        self,
+        pattern: AbstractPattern,
+        preceding_patterns: List[AbstractPattern],
+    ) -> bool:
+        """
+        Check if a pattern is useful given preceding patterns.
+        
+        A pattern is useful if it can match some value that is not
+        already matched by any of the preceding patterns.
+        
+        Uses the pattern matrix algorithm: a pattern P is useful w.r.t
+        matrix M if there exists some value v such that P matches v
+        and no row in M matches v.
+        """
+        if not preceding_patterns:
+            # First pattern is always useful
+            return True
+        
+        # If any preceding pattern is a pure wildcard, this pattern is useless
+        for prev in preceding_patterns:
+            if prev.is_wildcard():
+                return False
+        
+        # Build matrix from preceding patterns
+        rows = [PatternRow([p], i) for i, p in enumerate(preceding_patterns)]
+        matrix = PatternMatrix(rows)
+        
+        # Check usefulness of new pattern
+        return self._pattern_useful_in_matrix(pattern, matrix)
+    
+    def _pattern_useful_in_matrix(
+        self,
+        pattern: AbstractPattern,
+        matrix: PatternMatrix,
+    ) -> bool:
+        """
+        Check if pattern is useful against the given matrix.
+        
+        Algorithm:
+        1. If matrix is empty, pattern is useful
+        2. If pattern is wildcard and matrix has wildcard rows, not useful
+        3. Otherwise, specialize by constructors
+        """
+        # Empty matrix - pattern is useful
+        if matrix.is_empty():
+            return True
+        
+        # Check if matrix has any rows
+        if not matrix.rows or not matrix.rows[0].patterns:
+            return True
+        
+        col = 0
+        
+        # If pattern is wildcard, check if all constructors are covered
+        if pattern.is_wildcard():
+            # Pattern can match anything not already matched
+            # Check if there are any wildcards in the matrix at this column
+            for row in matrix.rows:
+                if col < len(row.patterns) and row.patterns[col].is_wildcard():
+                    # Wildcard already covers everything
+                    return False
+            # No wildcard in matrix means this pattern can match something new
+            return True
+        
+        # Non-wildcard pattern: specialize matrix by this constructor
+        specialized = matrix.specialize(col, pattern)
+        
+        # If specialized matrix is empty, pattern matches something new
+        if specialized.is_empty():
+            return True
+        
+        # Check children recursively
+        if pattern.children:
+            child_patterns = list(pattern.children)
+            child_matrix = specialized
+            
+            for i, child in enumerate(child_patterns):
+                if not child_matrix.rows:
+                    return True
+                if not self._child_useful(child, child_matrix, i):
+                    return False
+            return True
+        
+        # No children, check if any row completely covers this
+        for row in specialized.rows:
+            if not row.patterns:
+                # Row with no remaining patterns = complete match
+                return False
+        
+        return True
+    
+    def _child_useful(
+        self,
+        child: AbstractPattern,
+        matrix: PatternMatrix,
+        col: int,
+    ) -> bool:
+        """Check if a child pattern adds useful discrimination."""
+        # Extract column patterns from matrix
+        col_patterns = []
+        for row in matrix.rows:
+            if col < len(row.patterns):
+                col_patterns.append(row.patterns[col])
+        
+        if not col_patterns:
+            return True
+        
+        # Check if any pattern fully covers the child
+        for p in col_patterns:
+            if p.is_wildcard():
+                return not child.is_wildcard()
+            if p.covers(child):
+                return False
+        
+        return True
+    
+    def _check_match_reachability(
+        self,
+        node: nodes.MatchExprNode,
+    ) -> ReachabilityResult:
+        """Check reachability of all arms in a match expression."""
+        unreachable: List[UnreachableArm] = []
+        preceding_patterns: List[AbstractPattern] = []
+        
+        for i, arm in enumerate(node.arms):
+            pattern = self._extractor.extract(arm.pattern, has_guard=arm.guard is not None)
+            
+            # Check if this arm is reachable
+            is_useful = self._is_pattern_useful(pattern, preceding_patterns)
+            
+            if not is_useful:
+                # Extract source location
+                line = 0
+                column = 0
+                if arm.source_location:
+                    line = arm.source_location.start_line
+                    column = arm.source_location.start_column
+                elif arm.pattern.source_location:
+                    line = arm.pattern.source_location.start_line
+                    column = arm.pattern.source_location.start_column
+                
+                unreachable.append(UnreachableArm(
+                    arm_index=i,
+                    line=line,
+                    column=column,
+                    reason=f"match arm #{i + 1} is unreachable (covered by earlier patterns)",
+                ))
+            
+            # Add to preceding patterns only if no guard
+            # (guards make coverage conditional)
+            if arm.guard is None:
+                preceding_patterns.append(pattern)
+        
+        return ReachabilityResult(
+            match_node=node,
+            unreachable_arms=unreachable,
+        )
+    
+    def visit_match_expr(self, node: nodes.MatchExprNode) -> Any:
+        """Check reachability of match expression arms."""
+        # Visit children first
+        self.generic_visit(node)
+        
+        result = self._check_match_reachability(node)
+        self.results.append(result)
+        
+        # Add errors for unreachable arms
+        for arm in result.unreachable_arms:
+            self.errors.append(ReachabilityError(
+                message=arm.reason,
+                line=arm.line,
+                column=arm.column,
+                arm_index=arm.arm_index,
+            ))
+        
+        return None
+    
+    def visit_module(self, node: nodes.ModuleNode) -> Any:
+        """Entry point: check all match expressions in module."""
+        return self.generic_visit(node)
+
+
+def check_reachability(
+    module: nodes.ModuleNode,
+    type_info: Optional[TypeInferenceResult] = None,
+) -> List[ReachabilityError]:
+    """
+    Check for unreachable match arms in all match expressions.
+    
+    Args:
+        module: The module AST to check
+        type_info: Optional type inference result for better analysis
+    
+    Returns:
+        List of warnings for unreachable match arms
+    """
+    checker = ReachabilityChecker(type_info)
+    return checker.check(module)