frml 0.1.0__py3-none-any.whl

frml/__init__.py

@@ -0,0 +1,3 @@
+"""Frml: a minimal contract-based verification language."""
+
+__version__ = "0.1.0"

frml/__main__.py

@@ -0,0 +1,4 @@
+from .cli import main
+
+if __name__ == "__main__":
+    raise SystemExit(main())

frml/ast_nodes.py

@@ -0,0 +1,347 @@
+"""Abstract-syntax-tree node definitions for Frml."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+
+from .types import Type
+
+
+class Node:
+    """Base class carrying a source location."""
+
+    def __init__(self, line: int, col: int):
+        self.line = line
+        self.col = col
+
+
+# ---------------------------------------------------------------------------
+# Top level
+# ---------------------------------------------------------------------------
+
+@dataclass
+class Function(Node):
+    name: str
+    params: list[Parameter]
+    return_type: Type | None  # None means a void procedure
+    requires: list[Expr]
+    ensures: list[Expr]
+    decreases: Expr | None
+    body: list[Stmt]
+    line: int = 0
+    col: int = 0
+
+    def __init__(self, name, params, return_type, requires, ensures, decreases, body, line, col):
+        Node.__init__(self, line, col)
+        self.name = name
+        self.params = params
+        self.return_type = return_type
+        self.requires = requires
+        self.ensures = ensures
+        self.decreases = decreases
+        self.body = body
+
+
+@dataclass
+class Parameter(Node):
+    name: str
+    type: Type
+    line: int = 0
+    col: int = 0
+
+    def __init__(self, name: str, type_: Type, line: int, col: int):
+        Node.__init__(self, line, col)
+        self.name = name
+        self.type = type_
+
+
+@dataclass
+class Program:
+    functions: list[Function] = field(default_factory=list)
+
+
+# ---------------------------------------------------------------------------
+# Statements
+# ---------------------------------------------------------------------------
+
+@dataclass
+class Stmt(Node):
+    pass
+
+
+@dataclass
+class StmtArrayAssign(Stmt):
+    array: Expr
+    index: Expr
+    value: Expr
+    line: int = 0
+    col: int = 0
+
+    def __init__(self, array, index, value, line, col):
+        Node.__init__(self, line, col)
+        self.array = array
+        self.index = index
+        self.value = value
+
+
+@dataclass
+class StmtAssign(Stmt):
+    name: str
+    expr: Expr
+    line: int = 0
+    col: int = 0
+
+    def __init__(self, name, expr, line, col):
+        Node.__init__(self, line, col)
+        self.name = name
+        self.expr = expr
+
+
+@dataclass
+class StmtAssert(Stmt):
+    expr: Expr
+    line: int = 0
+    col: int = 0
+
+    def __init__(self, expr, line, col):
+        Node.__init__(self, line, col)
+        self.expr = expr
+
+
+@dataclass
+class StmtCall(Stmt):
+    name: str
+    args: list[Expr]
+    line: int = 0
+    col: int = 0
+
+    def __init__(self, name, args, line, col):
+        Node.__init__(self, line, col)
+        self.name = name
+        self.args = args
+
+
+@dataclass
+class StmtIf(Stmt):
+    cond: Expr
+    then: list[Stmt]
+    else_: list[Stmt] | None
+    line: int = 0
+    col: int = 0
+
+    def __init__(self, cond, then, else_, line, col):
+        Node.__init__(self, line, col)
+        self.cond = cond
+        self.then = then
+        self.else_ = else_
+
+
+@dataclass
+class StmtLet(Stmt):
+    name: str
+    type: Type
+    init: Expr
+    line: int = 0
+    col: int = 0
+
+    def __init__(self, name, type_, init, line, col):
+        Node.__init__(self, line, col)
+        self.name = name
+        self.type = type_
+        self.init = init
+
+
+@dataclass
+class StmtReturn(Stmt):
+    expr: Expr
+    line: int = 0
+    col: int = 0
+
+    def __init__(self, expr, line, col):
+        Node.__init__(self, line, col)
+        self.expr = expr
+
+
+@dataclass
+class StmtWhile(Stmt):
+    cond: Expr
+    invariants: list[Expr]
+    decreases: Expr | None
+    body: list[Stmt]
+    line: int = 0
+    col: int = 0
+
+    def __init__(self, cond, invariants, decreases, body, line, col):
+        Node.__init__(self, line, col)
+        self.cond = cond
+        self.invariants = invariants
+        self.decreases = decreases
+        self.body = body
+
+
+# ---------------------------------------------------------------------------
+# Expressions
+# ---------------------------------------------------------------------------
+
+@dataclass
+class Expr(Node):
+    pass
+
+
+@dataclass
+class ExprArrayAccess(Expr):
+    array: Expr
+    index: Expr
+    line: int = 0
+    col: int = 0
+
+    def __init__(self, array, index, line, col):
+        Node.__init__(self, line, col)
+        self.array = array
+        self.index = index
+
+
+@dataclass
+class ExprArrayLiteral(Expr):
+    elements: list[Expr]
+    line: int = 0
+    col: int = 0
+
+    def __init__(self, elements, line, col):
+        Node.__init__(self, line, col)
+        self.elements = elements
+
+
+@dataclass
+class ExprBinary(Expr):
+    op: str
+    left: Expr
+    right: Expr
+    line: int = 0
+    col: int = 0
+
+    def __init__(self, op, left, right, line, col):
+        Node.__init__(self, line, col)
+        self.op = op
+        self.left = left
+        self.right = right
+
+
+@dataclass
+class ExprCall(Expr):
+    name: str
+    args: list[Expr]
+    line: int = 0
+    col: int = 0
+
+    def __init__(self, name, args, line, col):
+        Node.__init__(self, line, col)
+        self.name = name
+        self.args = args
+
+
+@dataclass
+class ExprLength(Expr):
+    arg: Expr
+    line: int = 0
+    col: int = 0
+
+    def __init__(self, arg, line, col):
+        Node.__init__(self, line, col)
+        self.arg = arg
+
+
+@dataclass
+class ExprOld(Expr):
+    arg: Expr
+    line: int = 0
+    col: int = 0
+
+    def __init__(self, arg, line, col):
+        Node.__init__(self, line, col)
+        self.arg = arg
+
+
+@dataclass
+class ExprQuantifier(Expr):
+    quant: str  # "forall" or "exists"
+    var_name: str
+    var_type: Type
+    body: Expr
+    line: int = 0
+    col: int = 0
+
+    def __init__(self, quant, var_name, var_type, body, line, col):
+        Node.__init__(self, line, col)
+        self.quant = quant
+        self.var_name = var_name
+        self.var_type = var_type
+        self.body = body
+
+
+@dataclass
+class ExprStringify(Expr):
+    operand: Expr
+    line: int = 0
+    col: int = 0
+
+    def __init__(self, operand, line, col):
+        Node.__init__(self, line, col)
+        self.operand = operand
+
+
+@dataclass
+class ExprUnary(Expr):
+    op: str
+    operand: Expr
+    line: int = 0
+    col: int = 0
+
+    def __init__(self, op, operand, line, col):
+        Node.__init__(self, line, col)
+        self.op = op
+        self.operand = operand
+
+
+@dataclass
+class ExprVar(Expr):
+    name: str
+    line: int = 0
+    col: int = 0
+
+    def __init__(self, name, line, col):
+        Node.__init__(self, line, col)
+        self.name = name
+
+
+@dataclass
+class LiteralBool(Expr):
+    value: bool
+    line: int = 0
+    col: int = 0
+
+    def __init__(self, value, line, col):
+        Node.__init__(self, line, col)
+        self.value = value
+
+
+@dataclass
+class LiteralInt(Expr):
+    value: int
+    line: int = 0
+    col: int = 0
+
+    def __init__(self, value, line, col):
+        Node.__init__(self, line, col)
+        self.value = value
+
+
+@dataclass
+class LiteralString(Expr):
+    value: str
+    line: int = 0
+    col: int = 0
+
+    def __init__(self, value, line, col):
+        Node.__init__(self, line, col)
+        self.value = value

frml/cli.py

@@ -0,0 +1,120 @@
+"""Command-line interface for Frml.
+
+Usage:
+    frml check FILE.frml        parse, type-check and verify
+    frml run FILE.frml          type-check and execute main()
+    frml verify-run FILE.frml   verify, then execute main()
+"""
+
+from __future__ import annotations
+
+import sys
+
+from . import ast_nodes as ast
+from .errors import FrmlError
+from .interpreter import Interpreter
+from .parser import parse
+from .prover import verify_program
+from .typechecker import TypeChecker
+
+
+def main(argv: list[str] | None = None) -> int:
+    argv = list(sys.argv[1:] if argv is None else argv)
+    if not argv:
+        print(__doc__.strip(), file=sys.stderr)
+        return 1
+
+    command = argv[0]
+    if command in ("-h", "--help", "help"):
+        print(__doc__.strip())
+        return 0
+
+    if command not in ("check", "run", "verify-run"):
+        print(f"unknown command {command!r}", file=sys.stderr)
+        print(__doc__.strip(), file=sys.stderr)
+        return 1
+
+    if len(argv) != 2:
+        print(f"usage: frml {command} FILE.frml", file=sys.stderr)
+        return 1
+
+    filename = argv[1]
+    if command == "check":
+        return do_check(filename)
+    if command == "run":
+        return do_run(filename)
+    return do_verify_run(filename)
+
+
+def do_check(filename: str, timeout_ms: int = 10000) -> int:
+    try:
+        program = load_program(filename)
+    except FrmlError as e:
+        print(e.format(filename), file=sys.stderr)
+        return 1
+
+    _, outcomes = verify_program(program, timeout_ms=timeout_ms)
+
+    failed = [o for o in outcomes if o.status == "FAILED"]
+    unknown = [o for o in outcomes if o.status == "UNKNOWN"]
+
+    for o in failed:
+        print(_format_outcome(filename, o), file=sys.stderr)
+    for o in unknown:
+        print(_format_outcome(filename, o), file=sys.stderr)
+
+    if failed:
+        print("FAILED", file=sys.stderr)
+        return 1
+    if unknown:
+        print("UNKNOWN", file=sys.stderr)
+        return 2
+    print("VERIFIED")
+    return 0
+
+
+def do_run(filename: str) -> int:
+    try:
+        program = load_program(filename)
+    except FrmlError as e:
+        print(e.format(filename), file=sys.stderr)
+        return 1
+
+    try:
+        code = Interpreter(program).run_main()
+    except FrmlError as e:
+        print(e.format(filename), file=sys.stderr)
+        return 1
+
+    return int(code)
+
+
+def do_verify_run(filename: str, timeout_ms: int = 10000) -> int:
+    status = do_check(filename, timeout_ms=timeout_ms)
+    if status != 0:
+        return status
+    return do_run(filename)
+
+
+def load_program(filename: str) -> ast.Program:
+    with open(filename, "r", encoding="utf-8") as f:
+        source = f.read()
+    program = parse(source)
+    TypeChecker(program).check()
+    return program
+
+
+def _format_outcome(filename: str, outcome) -> str:
+    ob = outcome.obligation
+    loc = filename
+    if ob.line is not None:
+        loc += f":{ob.line}"
+        if ob.col is not None:
+            loc += f":{ob.col}"
+    if outcome.status == "FAILED":
+        return f"{loc}: FAILED\n{ob.kind} may not hold:\n    {ob.description}"
+    return f"{loc}: UNKNOWN\n{ob.kind} could not be decided:\n    {ob.description}"
+
+
+if __name__ == "__main__":  # pragma: no cover
+    sys.exit(main())

frml/errors.py

@@ -0,0 +1,61 @@
+"""Exception types used throughout the Frml compiler, interpreter and prover."""
+
+from __future__ import annotations
+
+
+class FrmlError(Exception):
+    """Base class for all Frml errors.
+
+    Each error carries a human-readable category (SyntaxError, TypeError, ...)
+    and an optional source location so the command-line tool can print
+    `file.frml:line:col: message` diagnostics.
+    """
+
+    category = "Error"
+
+    def __init__(self, message: str, line: int | None = None, col: int | None = None):
+        self.message = message
+        self.line = line
+        self.col = col
+        super().__init__(message)
+
+    def format(self, filename: str | None = None) -> str:
+        prefix = ""
+        if filename:
+            prefix = filename
+        if self.line is not None:
+            loc = str(self.line)
+            if self.col is not None:
+                loc += f":{self.col}"
+            prefix = f"{prefix}:{loc}" if prefix else loc
+        if prefix:
+            return f"{prefix}: {self.category}: {self.message}"
+        return f"{self.category}: {self.message}"
+
+
+class FrmlContractError(FrmlError):
+    category = "ContractError"
+
+
+class FrmlNameError(FrmlError):
+    category = "NameError"
+
+
+class FrmlRuntimeError(FrmlError):
+    category = "RuntimeError"
+
+
+class FrmlSyntaxError(FrmlError):
+    category = "SyntaxError"
+
+
+class FrmlTerminationError(FrmlError):
+    category = "TerminationError"
+
+
+class FrmlTypeError(FrmlError):
+    category = "TypeError"
+
+
+class FrmlVerificationError(FrmlError):
+    category = "VerificationError"