LordBaryhobal
f0e3f7574f
add type judgements to checker test results and update all tests (including the new subtyping rules)
95 lines
3.0 KiB
Python
95 lines
3.0 KiB
Python
import ast
|
|
import json
|
|
from dataclasses import asdict, dataclass, field
|
|
from pathlib import Path
|
|
|
|
import midas.ast.python as p
|
|
from midas.checker.checker import Checker
|
|
from midas.checker.diagnostic import Diagnostic
|
|
from midas.checker.types import Type
|
|
from midas.parser.python import PythonParser
|
|
from midas.resolver.resolver import Resolver
|
|
from tests.base import Tester
|
|
from tests.serializer.python import PythonAstJsonSerializer
|
|
|
|
|
|
@dataclass
|
|
class CaseResult:
|
|
diagnostics: list[dict] = field(default_factory=list)
|
|
judgments: list = field(default_factory=list)
|
|
|
|
def dumps(self) -> str:
|
|
return json.dumps(asdict(self), indent=2)
|
|
|
|
|
|
class CheckerTester(Tester):
|
|
@property
|
|
def namespace(self) -> str:
|
|
return "checker"
|
|
|
|
def _list_tests(self) -> list[Path]:
|
|
return list(self.base_dir.rglob("*.py"))
|
|
|
|
def _exec_case(self, path: Path) -> CaseResult:
|
|
if not path.exists():
|
|
raise FileNotFoundError(f"Could not find test '{path}'")
|
|
if not path.is_file():
|
|
raise TypeError(f"Test '{path}' is not a file")
|
|
|
|
types_paths: list[Path] = []
|
|
types_path: Path = path.with_suffix(".midas")
|
|
if types_path.exists():
|
|
types_paths.append(types_path)
|
|
source: str = path.read_text()
|
|
tree: ast.Module = ast.parse(source, filename=path)
|
|
parser = PythonParser()
|
|
stmts: list[p.Stmt] = parser.parse_module(tree)
|
|
resolver = Resolver()
|
|
resolver.resolve(*stmts)
|
|
result: CaseResult = CaseResult()
|
|
checker = Checker(
|
|
resolver.locals,
|
|
source_path=path,
|
|
types_paths=types_paths,
|
|
)
|
|
|
|
diagnostics: list[Diagnostic] = checker.check(stmts)
|
|
for diagnostic in diagnostics:
|
|
result.diagnostics.append(
|
|
{
|
|
"type": str(diagnostic.type),
|
|
"location": {
|
|
"start": (
|
|
diagnostic.location.lineno,
|
|
diagnostic.location.col_offset,
|
|
),
|
|
"end": (
|
|
diagnostic.location.end_lineno,
|
|
diagnostic.location.end_col_offset,
|
|
),
|
|
},
|
|
"message": diagnostic.message,
|
|
}
|
|
)
|
|
|
|
judgements: list[tuple[p.Expr, Type]] = checker.judgements
|
|
serializer = PythonAstJsonSerializer()
|
|
for expr, type in judgements:
|
|
loc = expr.location
|
|
result.judgments.append(
|
|
{
|
|
"location": {
|
|
"from": f"L{loc.lineno}:{loc.col_offset}",
|
|
"to": f"L{loc.end_lineno}:{loc.end_col_offset}",
|
|
},
|
|
"expr": expr.accept(serializer),
|
|
"type": asdict(type),
|
|
}
|
|
)
|
|
|
|
return result
|
|
|
|
|
|
if __name__ == "__main__":
|
|
CheckerTester.main()
|