invar-tools 1.0.0__py3-none-any.whl

invar/core/suggestions.py

@@ -0,0 +1,324 @@
+"""
+Fix suggestion generation for Guard (Phase 7.3, 11 P27).
+
+Generates concrete, usable fix code for violations.
+Agents need exact code, not vague descriptions.
+
+P27: Enhanced Context for Agent Decision
+- Show multiple pattern options for constraints
+- Guard provides options, Agent decides
+
+No I/O operations - receives parsed data only.
+"""
+
+from __future__ import annotations
+
+import re
+
+from deal import post, pre
+
+from invar.core.models import Symbol, SymbolKind
+
+# P27: Common constraint patterns by type (ordered by commonality)
+CONSTRAINT_PATTERNS: dict[str, list[str]] = {
+    "int": ["{name} >= 0", "{name} > 0", "{name} != 0"],
+    "float": ["{name} >= 0", "{name} > 0", "{name} != 0"],
+    "str": ["len({name}) > 0", "{name}", "{name}.strip()"],
+    "list": ["len({name}) > 0", "{name}"],
+    "dict": ["len({name}) > 0", "{name}"],
+    "set": ["len({name}) > 0", "{name}"],
+    "tuple": ["len({name}) > 0", "{name}"],
+    "bytes": ["len({name}) > 0", "{name}"],
+    "Optional": ["{name} is not None", "{name}"],
+}
+
+
+@pre(lambda signature: signature.startswith("(") or signature == "")
+def generate_contract_suggestion(signature: str) -> str:
+    """
+    Generate a suggested @pre contract based on function signature.
+
+    Uses common patterns:
+    - int/float: param >= 0
+    - str/list/dict/set/tuple: len(param) > 0
+    - Optional/None union: param is not None
+
+    Examples:
+        >>> generate_contract_suggestion("(x: int, y: int) -> int")
+        '@pre(lambda x, y: x >= 0 and y >= 0)'
+        >>> generate_contract_suggestion("(name: str) -> bool")
+        '@pre(lambda name: len(name) > 0)'
+        >>> generate_contract_suggestion("(items: list[int]) -> int")
+        '@pre(lambda items: len(items) > 0)'
+        >>> generate_contract_suggestion("(x, y)")
+        ''
+        >>> generate_contract_suggestion("(value: Optional[str]) -> str")
+        '@pre(lambda value: value is not None)'
+    """
+    params = _extract_params(signature)
+    if not params:
+        return ""
+
+    constraints = []
+    param_names = []
+
+    for name, type_hint in params:
+        if not name:  # Skip empty names from malformed signatures
+            continue
+        param_names.append(name)
+        if not type_hint:
+            continue
+
+        constraint = _suggest_constraint(name, type_hint)
+        if constraint:
+            constraints.append(constraint)
+
+    if not constraints:
+        return ""
+
+    params_str = ", ".join(param_names)
+    constraints_str = " and ".join(constraints)
+    return f"@pre(lambda {params_str}: {constraints_str})"
+
+
+@pre(lambda signature: signature.startswith("(") or signature == "")
+def _extract_params(signature: str) -> list[tuple[str, str | None]]:
+    """
+    Extract parameters and their types from a signature.
+
+    Examples:
+        >>> _extract_params("(x: int, y: str) -> bool")
+        [('x', 'int'), ('y', 'str')]
+        >>> _extract_params("(x, y)")
+        [('x', None), ('y', None)]
+        >>> _extract_params("(items: list[int], n: int = 10) -> list")
+        [('items', 'list[int]'), ('n', 'int')]
+    """
+    if not signature:
+        return []
+
+    match = re.match(r"\(([^)]*)\)", signature)
+    if not match:
+        return []
+
+    params = []
+    for param in match.group(1).split(","):
+        param = param.strip()
+        if not param:
+            continue
+
+        if ": " in param:
+            name, type_hint = param.split(": ", 1)
+            # Handle default values
+            if "=" in type_hint:
+                type_hint = type_hint.split("=")[0].strip()
+            params.append((name.strip(), type_hint.strip()))
+        else:
+            # No type annotation
+            if "=" in param:
+                param = param.split("=")[0].strip()
+            params.append((param, None))
+
+    return params
+
+
+@pre(lambda name, type_hint: len(name) > 0 and len(type_hint) > 0)
+def _suggest_constraint(name: str, type_hint: str) -> str | None:
+    """
+    Suggest a constraint for a parameter based on its type.
+
+    Examples:
+        >>> _suggest_constraint("x", "int")
+        'x >= 0'
+        >>> _suggest_constraint("name", "str")
+        'len(name) > 0'
+        >>> _suggest_constraint("items", "list[str]")
+        'len(items) > 0'
+        >>> _suggest_constraint("value", "Optional[int]")
+        'value is not None'
+        >>> _suggest_constraint("x", "SomeCustomType")
+    """
+    # Numeric types: suggest non-negative
+    if type_hint in ("int", "float"):
+        return f"{name} >= 0"
+
+    # Collection types: suggest non-empty
+    if type_hint in ("str", "list", "dict", "set", "tuple", "bytes"):
+        return f"len({name}) > 0"
+
+    # Generic collections: list[X], dict[K, V], etc.
+    base_match = re.match(r"^(list|dict|set|tuple)\[", type_hint)
+    if base_match:
+        return f"len({name}) > 0"
+
+    # Optional types: suggest not None
+    if type_hint.startswith("Optional[") or " | None" in type_hint or "None |" in type_hint:
+        return f"{name} is not None"
+
+    return None
+
+
+@pre(lambda name, type_hint: len(name) > 0 and len(type_hint) > 0)
+def _get_pattern_alternatives(name: str, type_hint: str) -> list[str]:
+    """
+    Get multiple constraint pattern alternatives for a parameter (P27).
+
+    Returns up to 3 common patterns for the type.
+
+    Examples:
+        >>> _get_pattern_alternatives("x", "int")
+        ['x >= 0', 'x > 0', 'x != 0']
+        >>> _get_pattern_alternatives("name", "str")
+        ['len(name) > 0', 'name', 'name.strip()']
+        >>> _get_pattern_alternatives("value", "Optional[int]")
+        ['value is not None', 'value']
+        >>> _get_pattern_alternatives("x", "CustomType")
+        []
+    """
+    # Check exact type matches
+    if type_hint in CONSTRAINT_PATTERNS:
+        return [p.format(name=name) for p in CONSTRAINT_PATTERNS[type_hint]]
+
+    # Generic collections: list[X], dict[K, V], etc.
+    base_match = re.match(r"^(list|dict|set|tuple)\[", type_hint)
+    if base_match:
+        base_type = base_match.group(1)
+        if base_type in CONSTRAINT_PATTERNS:
+            return [p.format(name=name) for p in CONSTRAINT_PATTERNS[base_type]]
+
+    # Optional types
+    if type_hint.startswith("Optional[") or " | None" in type_hint or "None |" in type_hint:
+        return [p.format(name=name) for p in CONSTRAINT_PATTERNS["Optional"]]
+
+    return []
+
+
+@pre(lambda signature: signature.startswith("(") or signature == "")
+def generate_pattern_options(signature: str) -> str:
+    """
+    Generate multiple constraint pattern options for each parameter (P27).
+
+    Returns a formatted string showing alternatives for each typed parameter.
+
+    Examples:
+        >>> generate_pattern_options("(x: int, y: str) -> int")
+        'Patterns: x >= 0 | x > 0 | x != 0, len(y) > 0 | y | y.strip()'
+        >>> generate_pattern_options("(data, config)")
+        ''
+    """
+    params = _extract_params(signature)
+    if not params:
+        return ""
+
+    all_patterns: list[str] = []
+    for name, type_hint in params:
+        if not name or not type_hint:  # Skip empty names from malformed signatures
+            continue
+        patterns = _get_pattern_alternatives(name, type_hint)
+        if patterns:
+            all_patterns.append(" | ".join(patterns))
+
+    if not all_patterns:
+        return ""
+
+    return f"Patterns: {', '.join(all_patterns)}"
+
+
+@pre(lambda signature: signature.startswith("(") or signature == "")
+@post(lambda result: isinstance(result, str))
+def _generate_lambda_skeleton(signature: str) -> str:
+    """
+    Generate a lambda skeleton from function signature (P4).
+
+    Returns skeleton with parameters extracted, condition placeholder.
+
+    Examples:
+        >>> _generate_lambda_skeleton("(x: int, y: int) -> int")
+        '@pre(lambda x, y: <condition>) or @post(lambda result: <condition>)'
+        >>> _generate_lambda_skeleton("(items: list) -> None")
+        '@pre(lambda items: <condition>) or @post(lambda result: <condition>)'
+        >>> _generate_lambda_skeleton("() -> int")
+        '@post(lambda result: <condition>)'
+    """
+    params = _extract_params(signature)
+    param_names = [name for name, _ in params]
+
+    if not param_names:
+        return "@post(lambda result: <condition>)"
+
+    params_str = ", ".join(param_names)
+    return f"@pre(lambda {params_str}: <condition>) or @post(lambda result: <condition>)"
+
+
+# Prefixes for violation type suggestions
+_VIOLATION_PREFIXES = {
+    "missing_contract": ("Add: ", "Add: "),
+    "empty_contract": ("Replace with: ", "Replace with: "),
+    "redundant_type_contract": ("Replace with business logic: ", "Replace with: "),
+    "semantic_tautology": ("Replace tautology with meaningful constraint: ", "Replace tautology with: "),
+}
+
+
+@pre(lambda prefix, suggestion, patterns: bool(prefix) and bool(suggestion))
+@post(lambda result: isinstance(result, str) and len(result) > 0)
+def _format_with_patterns(prefix: str, suggestion: str, patterns: str) -> str:
+    """Format suggestion with optional patterns.
+
+    >>> _format_with_patterns("Add: ", "check(x)", "Patterns: x > 0")
+    'Add: check(x)\\nPatterns: x > 0'
+    """
+    result = f"{prefix}{suggestion}"
+    if patterns:
+        result += f"\n{patterns}"
+    return result
+
+
+@pre(
+    lambda symbol, violation_type: violation_type
+    in ("missing_contract", "empty_contract", "redundant_type_contract", "semantic_tautology", "")
+)
+def format_suggestion_for_violation(symbol: Symbol, violation_type: str) -> str:
+    """
+    Format a complete suggestion message for a violation.
+
+    Phase 9.2 P4: Generate lambda skeletons when no type-based suggestion available.
+    P7: Added semantic_tautology support.
+    P27: Show pattern alternatives (Guard provides options, Agent decides).
+
+    Examples:
+        >>> from invar.core.models import Symbol, SymbolKind
+        >>> sym = Symbol(name="calc", kind=SymbolKind.FUNCTION, line=1, end_line=5,
+        ...     signature="(x: int, y: int) -> int")
+        >>> msg = format_suggestion_for_violation(sym, "missing_contract")
+        >>> "@pre(lambda x, y: x >= 0 and y >= 0)" in msg
+        True
+        >>> "Patterns:" in msg  # P27: shows alternatives
+        True
+        >>> # P4: skeleton when no type-based suggestion
+        >>> sym2 = Symbol(name="process", kind=SymbolKind.FUNCTION, line=1, end_line=5,
+        ...     signature="(data, config)")
+        >>> msg2 = format_suggestion_for_violation(sym2, "missing_contract")
+        >>> "@pre(lambda data, config: <condition>)" in msg2
+        True
+    """
+    if symbol.kind not in (SymbolKind.FUNCTION, SymbolKind.METHOD):
+        return ""
+
+    if violation_type not in _VIOLATION_PREFIXES:
+        return ""
+
+    # Guard against malformed signatures
+    sig = symbol.signature
+    if not (sig.startswith("(") or sig == ""):
+        return ""
+
+    suggestion_prefix, skeleton_prefix = _VIOLATION_PREFIXES[violation_type]
+    patterns = generate_pattern_options(sig)
+    suggestion = generate_contract_suggestion(sig)
+
+    if suggestion:
+        return _format_with_patterns(suggestion_prefix, suggestion, patterns)
+
+    # P4: Generate lambda skeleton when no type-based suggestion
+    skeleton = _generate_lambda_skeleton(sig)
+    return f"{skeleton_prefix}{skeleton}"

invar/core/tautology.py

@@ -0,0 +1,137 @@
+"""Semantic tautology detection for contract quality (P7). No I/O operations."""
+
+from __future__ import annotations
+
+import ast
+
+from deal import post, pre
+
+from invar.core.lambda_helpers import find_lambda
+from invar.core.models import FileInfo, RuleConfig, Severity, SymbolKind, Violation
+from invar.core.suggestions import format_suggestion_for_violation
+
+
+@pre(lambda expression: ("lambda" in expression and ":" in expression) or not expression.strip())
+def is_semantic_tautology(expression: str) -> tuple[bool, str]:
+    """Check if a contract expression is a semantic tautology.
+
+    Returns (is_tautology, pattern_description).
+
+    P7: Detects patterns that are always true:
+    - x == x (identity comparison)
+    - len(x) >= 0 (length always non-negative)
+    - isinstance(x, object) (everything is object)
+    - x or True (always true due to True)
+    - True and x (simplifies but starts with True)
+
+    Examples:
+        >>> is_semantic_tautology("lambda x: x == x")
+        (True, 'x == x is always True')
+        >>> is_semantic_tautology("lambda x: len(x) >= 0")
+        (True, 'len(x) >= 0 is always True for any sequence')
+        >>> is_semantic_tautology("lambda x: isinstance(x, object)")
+        (True, 'isinstance(x, object) is always True')
+        >>> is_semantic_tautology("lambda x: x > 0")
+        (False, '')
+        >>> is_semantic_tautology("lambda x: x or True")
+        (True, 'expression contains unconditional True')
+    """
+    if not expression.strip():
+        return (False, "")
+    try:
+        tree = ast.parse(expression, mode="eval")
+        lambda_node = find_lambda(tree)
+        if lambda_node is None:
+            return (False, "")
+        return _check_tautology_patterns(lambda_node.body)
+    except (SyntaxError, TypeError, ValueError):
+        return (False, "")
+
+
+@post(lambda result: isinstance(result, tuple) and len(result) == 2)
+def _check_tautology_patterns(node: ast.expr) -> tuple[bool, str]:
+    """Check for common tautology patterns in AST node."""
+    # Identity comparison pattern (e.g., x == x)
+    if (
+        isinstance(node, ast.Compare)
+        and len(node.ops) == 1
+        and isinstance(node.ops[0], (ast.Eq, ast.Is))
+    ):
+        left = ast.unparse(node.left)
+        right = ast.unparse(node.comparators[0])
+        if left == right:
+            return (True, f"{left} == {right} is always True")
+
+    # Length non-negative pattern (e.g., len(x) >= 0)
+    if isinstance(node, ast.Compare) and len(node.ops) == 1 and len(node.comparators) == 1:
+        left = node.left
+        op = node.ops[0]
+        right = node.comparators[0]
+        if (
+            isinstance(left, ast.Call)
+            and isinstance(left.func, ast.Name)
+            and left.func.id == "len"
+            and isinstance(op, ast.GtE)
+            and isinstance(right, ast.Constant)
+            and right.value == 0
+        ):
+            arg = ast.unparse(left.args[0]) if left.args else "x"
+            return (True, f"len({arg}) >= 0 is always True for any sequence")
+
+    # isinstance with object pattern (always True)
+    if (
+        isinstance(node, ast.Call)
+        and isinstance(node.func, ast.Name)
+        and node.func.id == "isinstance"
+        and len(node.args) == 2
+    ):
+        type_arg = node.args[1]
+        if isinstance(type_arg, ast.Name) and type_arg.id == "object":
+            arg = ast.unparse(node.args[0])
+            return (True, f"isinstance({arg}, object) is always True")
+
+    # Pattern: x or True, True or x (always true)
+    if isinstance(node, ast.BoolOp) and isinstance(node.op, ast.Or):
+        for val in node.values:
+            if isinstance(val, ast.Constant) and val.value is True:
+                return (True, "expression contains unconditional True")
+
+    return (False, "")
+
+
+@pre(lambda file_info, config: isinstance(file_info, FileInfo))
+def check_semantic_tautology(file_info: FileInfo, config: RuleConfig) -> list[Violation]:
+    """Check for semantic tautology contracts. Core files only.
+
+    P7: Detects contracts that are always true due to semantic patterns:
+    - x == x, len(x) >= 0, isinstance(x, object), x or True
+
+    Examples:
+        >>> from invar.core.models import FileInfo, Symbol, SymbolKind, Contract, RuleConfig
+        >>> c = Contract(kind="pre", expression="lambda x: x == x", line=1)
+        >>> s = Symbol(name="f", kind=SymbolKind.FUNCTION, line=1, end_line=5, contracts=[c])
+        >>> vs = check_semantic_tautology(FileInfo(path="c.py", lines=10, symbols=[s], is_core=True), RuleConfig())
+        >>> vs[0].rule
+        'semantic_tautology'
+    """
+    violations: list[Violation] = []
+    if not file_info.is_core:
+        return violations
+    for symbol in file_info.symbols:
+        if symbol.kind not in (SymbolKind.FUNCTION, SymbolKind.METHOD):
+            continue
+        for contract in symbol.contracts:
+            is_tautology, pattern_desc = is_semantic_tautology(contract.expression)
+            if is_tautology:
+                kind = "Method" if symbol.kind == SymbolKind.METHOD else "Function"
+                violations.append(
+                    Violation(
+                        rule="semantic_tautology",
+                        severity=Severity.WARNING,
+                        file=file_info.path,
+                        line=contract.line,
+                        message=f"{kind} '{symbol.name}' has tautological contract: {pattern_desc}",
+                        suggestion=format_suggestion_for_violation(symbol, "semantic_tautology"),
+                    )
+                )
+    return violations

invar/core/timeout_inference.py

@@ -0,0 +1,114 @@
+"""
+Timeout inference for CrossHair based on code characteristics.
+
+Part of DX-12: Hypothesis as CrossHair fallback.
+Extracted from hypothesis_strategies.py to reduce file size.
+"""
+
+from __future__ import annotations
+
+import inspect
+import re
+from dataclasses import dataclass
+from typing import TYPE_CHECKING
+
+from deal import post, pre
+
+if TYPE_CHECKING:
+    from collections.abc import Callable
+
+
+@dataclass
+class TimeoutTier:
+    """Timeout tier for CrossHair based on code characteristics."""
+
+    name: str
+    timeout: int
+    description: str
+
+
+TIMEOUT_TIERS = {
+    "pure_python": TimeoutTier("pure_python", 10, "Pure Python, no external libs"),
+    "stdlib_only": TimeoutTier("stdlib_only", 15, "Uses collections, itertools"),
+    "numpy_pandas": TimeoutTier("numpy_pandas", 5, "Quick check, likely to skip"),
+    "complex_nested": TimeoutTier("complex_nested", 30, "Deep recursion, many branches"),
+}
+
+# Libraries that CrossHair cannot handle well
+LIBRARY_BLACKLIST = frozenset([
+    "numpy", "pandas", "torch", "tensorflow", "scipy",
+    "sklearn", "cv2", "PIL", "requests", "aiohttp",
+])
+
+
+@pre(lambda func: callable(func))
+@post(lambda result: isinstance(result, int) and result > 0)
+def infer_timeout(func: Callable) -> int:
+    """
+    Infer appropriate CrossHair timeout from function source.
+
+    Args:
+        func: The function to analyze
+
+    Returns:
+        Timeout in seconds
+
+    >>> def pure_func(x: int) -> int: return x * 2
+    >>> infer_timeout(pure_func)
+    10
+    """
+    try:
+        source = inspect.getsource(func)
+    except (OSError, TypeError):
+        return TIMEOUT_TIERS["pure_python"].timeout
+
+    # Check for blacklisted libraries
+    for lib in LIBRARY_BLACKLIST:
+        if re.search(rf"\b{lib}\b", source):
+            return TIMEOUT_TIERS["numpy_pandas"].timeout
+
+    # Count complexity indicators
+    nesting_depth = _estimate_nesting_depth(source)
+    branch_count = _count_branches(source)
+
+    if nesting_depth > 4 or branch_count > 10:
+        return TIMEOUT_TIERS["complex_nested"].timeout
+
+    if _uses_only_stdlib(source):
+        return TIMEOUT_TIERS["stdlib_only"].timeout
+
+    return TIMEOUT_TIERS["pure_python"].timeout
+
+
+@pre(lambda source: isinstance(source, str))
+@post(lambda result: isinstance(result, int) and result >= 0)
+def _estimate_nesting_depth(source: str) -> int:
+    """Estimate maximum nesting depth from indentation."""
+    max_indent = 0
+    for line in source.split("\n"):
+        stripped = line.lstrip()
+        if stripped and not stripped.startswith("#"):
+            indent = len(line) - len(stripped)
+            spaces = indent // 4  # Assuming 4-space indent
+            max_indent = max(max_indent, spaces)
+    return max_indent
+
+
+@pre(lambda source: isinstance(source, str))
+@post(lambda result: isinstance(result, int) and result >= 0)
+def _count_branches(source: str) -> int:
+    """Count branching statements (if, for, while, try)."""
+    return len(re.findall(r"\b(if|for|while|try|elif|except)\b", source))
+
+
+@pre(lambda source: isinstance(source, str))
+@post(lambda result: isinstance(result, bool))
+def _uses_only_stdlib(source: str) -> bool:
+    """Check if source only uses standard library."""
+    stdlib_patterns = ["collections", "itertools", "functools", "typing", "dataclasses"]
+    third_party_patterns = ["pandas", "numpy", "requests", "flask", "django"]
+
+    has_stdlib = any(pat in source for pat in stdlib_patterns)
+    has_third_party = any(pat in source for pat in third_party_patterns)
+
+    return has_stdlib and not has_third_party