serenecode 0.1.0__py3-none-any.whl

serenecode/checker/symbolic.py

@@ -0,0 +1,178 @@
+"""Symbolic verification checker for Serenecode (Level 4).
+
+This module implements Level 4 verification: it transforms results from
+symbolic execution backends into structured CheckResult objects.
+The actual verification is delegated to adapters.
+
+This is a core module — no I/O operations are permitted. Verification
+results are received as structured data, not generated here.
+"""
+
+from __future__ import annotations
+
+import icontract
+
+from serenecode.models import (
+    CheckResult,
+    CheckStatus,
+    Detail,
+    FunctionResult,
+    VerificationLevel,
+    make_check_result,
+)
+from serenecode.ports.symbolic_checker import SymbolicFinding
+
+
+@icontract.require(
+    lambda findings: isinstance(findings, list),
+    "findings must be a list",
+)
+@icontract.ensure(
+    lambda result: isinstance(result, CheckResult),
+    "result must be a CheckResult",
+)
+def transform_symbolic_results(
+    findings: list[SymbolicFinding],
+    file_path: str,
+    duration_seconds: float,
+) -> CheckResult:
+    """Transform symbolic verification findings into a CheckResult.
+
+    Maps each SymbolicFinding to a FunctionResult with appropriate
+    status, counterexamples, and suggestions.
+
+    Args:
+        findings: List of symbolic findings from a verification adapter.
+        file_path: Source file path for reporting.
+        duration_seconds: How long the verification took.
+
+    Returns:
+        A CheckResult containing all symbolic verification results.
+    """
+    func_results: list[FunctionResult] = []
+
+    # Loop invariant: func_results contains transformed results for findings[0..i]
+    for finding in findings:
+        details: list[Detail] = []
+        status: CheckStatus
+        level_achieved: int
+
+        if finding.outcome == "verified":
+            status = CheckStatus.PASSED
+            level_achieved = 5
+            details.append(Detail(
+                level=VerificationLevel.SYMBOLIC,
+                tool="crosshair",
+                finding_type="verified",
+                message=f"No counterexample found within analysis bounds: '{finding.function_name}'",
+            ))
+        elif finding.outcome == "counterexample":
+            status = CheckStatus.FAILED
+            level_achieved = 4
+            details.append(Detail(
+                level=VerificationLevel.SYMBOLIC,
+                tool="crosshair",
+                finding_type="counterexample",
+                message=finding.message,
+                counterexample=finding.counterexample,
+                suggestion=_suggest_fix_symbolic(finding),
+            ))
+        elif finding.outcome == "timeout":
+            status = CheckStatus.SKIPPED
+            level_achieved = 4
+            details.append(Detail(
+                level=VerificationLevel.SYMBOLIC,
+                tool="crosshair",
+                finding_type="timeout",
+                message=f"Symbolic verification timed out for '{finding.function_name}'",
+                suggestion=(
+                    "The solver ran out of time. Options: "
+                    "(1) increase --per-condition-timeout or --module-timeout, "
+                    "(2) simplify the function logic or contracts, "
+                    "(3) split the function into smaller pieces, "
+                    "(4) add tighter preconditions to reduce the search space"
+                ),
+            ))
+        elif finding.outcome == "unsupported":
+            status = CheckStatus.EXEMPT
+            level_achieved = 4
+            details.append(Detail(
+                level=VerificationLevel.SYMBOLIC,
+                tool="crosshair",
+                finding_type="unsupported",
+                message=f"Symbolic verification unsupported for '{finding.function_name}'",
+                suggestion=(
+                    "This function cannot be symbolically verified — "
+                    "it has non-primitive parameter types that the solver cannot generate. "
+                    "Ensure it is covered by property-based tests (L3) or explicit unit tests"
+                ),
+            ))
+        else:
+            status = CheckStatus.FAILED
+            level_achieved = 4
+            details.append(Detail(
+                level=VerificationLevel.SYMBOLIC,
+                tool="crosshair",
+                finding_type="error",
+                message=finding.message,
+                suggestion=(
+                    "Symbolic verification encountered an internal error. "
+                    "Check that the module imports cleanly and that all dependencies are installed"
+                ),
+            ))
+
+        func_results.append(FunctionResult(
+            function=finding.function_name,
+            file=file_path,
+            line=1,
+            level_requested=5,
+            level_achieved=level_achieved,
+            status=status,
+            details=tuple(details),
+        ))
+
+    return make_check_result(
+        tuple(func_results),
+        level_requested=5,
+        duration_seconds=duration_seconds,
+    )
+
+
+@icontract.require(
+    lambda finding: isinstance(finding, SymbolicFinding),
+    "finding must be a SymbolicFinding",
+)
+@icontract.ensure(
+    lambda result: result is None or isinstance(result, str),
+    "result must be None or a string",
+)
+def _suggest_fix_symbolic(finding: SymbolicFinding) -> str | None:
+    """Generate a fix suggestion from a symbolic finding.
+
+    Args:
+        finding: The symbolic finding to generate a suggestion for.
+
+    Returns:
+        A suggestion string, or None.
+    """
+    if finding.counterexample is not None and isinstance(finding.counterexample, dict) and finding.counterexample:
+        inputs = ", ".join(f"{k}={v}" for k, v in finding.counterexample.items())
+        fix_steps = (
+            f"Counterexample: {inputs}. "
+            "To fix: (1) if the inputs are invalid, add a @icontract.require "
+            "precondition to exclude them; (2) if the inputs are valid, fix the "
+            "implementation so the postcondition holds"
+        )
+        if finding.condition:
+            fix_steps += f"; violated condition: {finding.condition}"
+        return fix_steps
+    if finding.condition:
+        return (
+            f"Condition '{finding.condition}' violated. "
+            "Either fix the implementation to satisfy the postcondition, "
+            "or add a precondition to narrow the valid input domain"
+        )
+    return (
+        "Symbolic verification found a violation. "
+        "Read the function's postconditions and check which one can fail"
+    )

serenecode/checker/types.py

@@ -0,0 +1,148 @@
+"""Type checking checker for Serenecode (Level 2).
+
+This module implements Level 2 verification: it transforms results from
+static type analysis backends (like mypy) into structured CheckResult
+objects. The actual type checking is delegated to adapters.
+
+This is a core module — no I/O operations are permitted. Type check
+results are received as structured data, not generated here.
+"""
+
+from __future__ import annotations
+
+import icontract
+
+from serenecode.contracts.predicates import is_non_empty_string
+from serenecode.models import (
+    CheckResult,
+    CheckStatus,
+    Detail,
+    FunctionResult,
+    VerificationLevel,
+    make_check_result,
+)
+from serenecode.ports.type_checker import TypeIssue
+
+
+@icontract.require(
+    lambda issues: isinstance(issues, list),
+    "issues must be a list",
+)
+@icontract.ensure(
+    lambda result: isinstance(result, CheckResult),
+    "result must be a CheckResult",
+)
+def transform_type_results(
+    issues: list[TypeIssue],
+    duration_seconds: float,
+) -> CheckResult:
+    """Transform mypy type issues into a CheckResult.
+
+    Groups issues by file and line, creating FunctionResult entries
+    for each location with type errors.
+
+    Args:
+        issues: List of type issues from a type checker adapter.
+        duration_seconds: How long the type checking took.
+
+    Returns:
+        A CheckResult containing all type checking findings.
+    """
+    # Group issues by (file, line)
+    grouped: dict[tuple[str, int], list[TypeIssue]] = {}
+    # Loop invariant: grouped contains all issues from issues[0..i]
+    for issue in issues:
+        key = (issue.file, issue.line)
+        grouped.setdefault(key, []).append(issue)
+
+    func_results: list[FunctionResult] = []
+
+    # Loop invariant: func_results contains results for all groups processed
+    for (file_path, line), file_issues in sorted(grouped.items()):
+        errors = [i for i in file_issues if i.severity == "error"]
+        if not errors:
+            continue
+
+        details: list[Detail] = []
+        # Loop invariant: details contains Detail for errors[0..j]
+        for error in errors:
+            suggestion = (
+                _suggest_from_mypy_code(error.code, error.message)
+                if error.code and is_non_empty_string(error.message)
+                else None
+            )
+            details.append(Detail(
+                level=VerificationLevel.TYPES,
+                tool="mypy",
+                finding_type="violation",
+                message=f"{error.message}" + (f" [{error.code}]" if error.code else ""),
+                suggestion=suggestion,
+            ))
+
+        func_results.append(FunctionResult(
+            function=f"<line {line}>",
+            file=file_path,
+            line=line,
+            level_requested=2,
+            level_achieved=1,
+            status=CheckStatus.FAILED,
+            details=tuple(details),
+        ))
+
+    return make_check_result(
+        tuple(func_results),
+        level_requested=2,
+        duration_seconds=duration_seconds,
+    )
+
+
+@icontract.require(
+    lambda code: code is None or is_non_empty_string(code),
+    "code must be a non-empty string when provided",
+)
+@icontract.require(
+    lambda message: is_non_empty_string(message),
+    "message must be a non-empty string",
+)
+@icontract.ensure(
+    lambda result: result is None or isinstance(result, str),
+    "result must be a string or None",
+)
+def _suggest_from_mypy_code(code: str | None, message: str) -> str | None:
+    """Generate a fix suggestion from a mypy error code.
+
+    Args:
+        code: The mypy error code (e.g. "arg-type").
+        message: The mypy error message.
+
+    Returns:
+        A suggestion string, or None.
+    """
+    suggestions: dict[str, str] = {
+        "arg-type": "Change the argument to match the expected parameter type, or update the parameter annotation",
+        "return-value": "Change the return expression to match the declared return type, or fix the return annotation",
+        "assignment": "Change the assigned value to match the variable's type annotation, or fix the annotation",
+        "attr-defined": "The attribute does not exist on this type — check for typos, add the attribute, or use hasattr/cast",
+        "name-defined": "This name is not defined — add an import or fix the spelling",
+        "override": "The method signature must match the parent class — update parameter or return types to be compatible",
+        "misc": "Review the type annotation for correctness",
+        "union-attr": "Not all union variants have this attribute — narrow the type with isinstance() or handle each variant",
+        "no-untyped-def": "Add type annotations to all parameters and the return type",
+        "type-arg": "Generic type needs explicit type parameters (e.g. list[str] not list)",
+        "var-annotated": "Add a type annotation to this variable",
+        "no-any-return": "The return type should not be Any — use a specific type",
+        "import-untyped": "This module has no type stubs — add a # type: ignore[import-untyped] comment or install stubs",
+        "call-overload": "No overload variant matches these argument types — check the function's overload signatures",
+        "index": "Invalid index type — use the correct key/index type for this container",
+        "operator": "This operator is not supported for these types — check operand types",
+        "redundant-cast": "This cast is unnecessary — the expression already has the target type",
+        "unreachable": "This code is unreachable — review the control flow above it",
+        "truthy-bool": "This expression is always truthy/falsy — the condition may be wrong",
+        "possibly-undefined": "This variable might not be defined on all code paths — initialize it or add a check",
+    }
+    if code and code in suggestions:
+        return suggestions[code]
+    # Fallback: include the error code so the agent can look it up
+    if code:
+        return f"Fix the type error (mypy code: {code}) — run 'mypy --show-error-codes' for details"
+    return "Fix the type error — run 'mypy --strict' on this file for full details"