fix(tests): remove custom imports

remove custom import statement (`midas.using`) in favor of passing type definition files as arguments to the checker

examples/00_syntax_prototype/02_custom_types.py

@@ -2,10 +2,6 @@
 # ruff: disable[F821]
 from __future__ import annotations
 
-# Prototype of custom type import to use valid Python syntax
-import midas
-midas.using("02_custom_types.midas")
-
 # A data-frame using a custom type
 df: Frame[
     location: GeoLocation

examples/01_simple_type_checking/02_simple_types.py

@@ -1,8 +1,6 @@
 # type: ignore
 # ruff: disable [F821]
 
-midas.using("02_simple_types.midas")
-
 distance: Meter = cast(Meter, 123.45)
 time: Second = cast(Second, 6.7)
 speed = distance / time

midas/checker/checker.py

@@ -34,9 +34,15 @@ class Checker(
 ):
     """A type checker which can use custom type definitions"""
 
-    def __init__(self, locals: dict[p.Expr, int], file_path: Path):
+    def __init__(
+        self,
+        locals: dict[p.Expr, int],
+        source_path: Path,
+        types_paths: list[Path],
+    ):
         self.logger: logging.Logger = logging.getLogger("Checker")
-        self.file_path: Path = file_path
+        self.source_path: Path = source_path
+        self.types_paths: list[Path] = types_paths
         self.ctx: MidasResolver = MidasResolver()
         self.global_env: Environment = Environment()
         self.env: Environment = self.global_env
@@ -46,7 +52,7 @@ class Checker(
     def diagnostic(self, type: DiagnosticType, location: Location, message: str):
         self.diagnostics.append(
             Diagnostic(
-                file_path=self.file_path,
+                file_path=self.source_path,
                 location=location,
                 type=type,
                 message=message,
@@ -119,6 +125,12 @@ class Checker(
             list[Diagnostic]: the list of diagnostics (errors, warning, etc.)
         """
         self.diagnostics = []
+
+        for path in self.types_paths:
+            self.import_midas(path)
+        self.logger.debug(f"Midas types: {self.ctx._types}")
+        self.logger.debug(f"Midas operations: {self.ctx._operations}")
+
         for stmt in statements:
             stmt.accept(self)
 
@@ -140,30 +152,6 @@ class Checker(
             return self.env.get_at(distance, name)
         return self.global_env.get(name)
 
-    def parse_midas_import(self, expr: p.CallExpr) -> Optional[Path]:
-        """Parse a Midas import statement
-
-        The statement should be written as `midas.using("path/to/types.midas")`
-
-        Args:
-            expr (p.CallExpr): the import call expression
-
-        Returns:
-            Optional[Path]: the path to the imported file, or None if the expression is malformed
-        """
-        match expr:
-            case p.CallExpr(
-                callee=p.GetExpr(
-                    object=p.VariableExpr(name="midas"),
-                    name="using",
-                ),
-                arguments=[
-                    p.LiteralExpr(value=path),
-                ],
-            ):
-                return Path(path)
-        return None
-
     def import_midas(self, path: Path) -> None:
         """Import Midas definitions from a path
 
@@ -171,14 +159,11 @@ class Checker(
             path (Path): the import path
         """
         self.logger.debug(f"Importing type definitions from {path}")
-        path = (self.file_path.parent / path).resolve()
         lexer: MidasLexer = MidasLexer(path.read_text())
         tokens: list[Token] = lexer.process()
         parser: MidasParser = MidasParser(tokens)
         stmts: list[m.Stmt] = parser.parse()
         self.ctx.resolve(stmts)
-        self.logger.debug(f"Midas types: {self.ctx._types}")
-        self.logger.debug(f"Midas operations: {self.ctx._operations}")
 
     def visit_expression_stmt(self, stmt: p.ExpressionStmt) -> None:
         self.type_of(stmt.expr)
@@ -362,9 +347,6 @@ class Checker(
     def visit_unary_expr(self, expr: p.UnaryExpr) -> Type: ...
 
     def visit_call_expr(self, expr: p.CallExpr) -> Type:
-        if path := self.parse_midas_import(expr):
-            self.import_midas(path)
-            return UnknownType()
         callee: Type = self.type_of(expr.callee)
         if not isinstance(callee, Function):
             self.error(expr.callee.location, "Callee is not a function")

midas/cli/main.py

@@ -34,8 +34,9 @@ def midas():
 
 @midas.command()
 @click.option("-l", "--highlight", type=click.File("w"))
+@click.option("-t", "--types", type=click.File("r"), multiple=True)
 @click.argument("file", type=click.File("r"))
-def compile(highlight: Optional[TextIO], file: TextIO):
+def compile(highlight: Optional[TextIO], file: TextIO, types: tuple[TextIO]):
     logging.basicConfig(level=logging.DEBUG)
     source: str = file.read()
     tree: ast.Module = ast.parse(source, filename=file.name)
@@ -43,7 +44,12 @@ def compile(highlight: Optional[TextIO], file: TextIO):
     stmts: list[p.Stmt] = parser.parse_module(tree)
     resolver = Resolver()
     resolver.resolve(*stmts)
-    checker = Checker(resolver.locals, file_path=Path(file.name).resolve())
+    types_paths: list[Path] = [Path(t.name).resolve() for t in types]
+    checker = Checker(
+        resolver.locals,
+        source_path=Path(file.name).resolve(),
+        types_paths=types_paths,
+    )
     diagnostics: list[Diagnostic] = checker.check(stmts)
     for diagnostic in diagnostics:
         print(diagnostic)

tests/cases/checker/04_custom_types.py

@@ -1,8 +1,6 @@
 # type: ignore
 # ruff: disable [F821]
 
-midas.using("04_custom_types.midas")
-
 distance: Meter = cast(Meter, 123.45)
 time: Second = cast(Second, 6.7)
 speed = distance / time

tests/cases/python-parser/02_custom_types.py

@@ -2,10 +2,6 @@
 # ruff: disable[F821]
 from __future__ import annotations
 
-import midas
-
-midas.using("02_custom_types.midas")
-
 df: Frame[
     location: GeoLocation
 ]

tests/cases/python-parser/02_custom_types.py.ref.json

@@ -1,26 +1,5 @@
 {
   "stmts": [
-    {
-      "_type": "ExpressionStmt",
-      "expr": {
-        "_type": "CallExpr",
-        "callee": {
-          "_type": "GetExpr",
-          "object": {
-            "_type": "VariableExpr",
-            "name": "midas"
-          },
-          "name": "using"
-        },
-        "arguments": [
-          {
-            "_type": "LiteralExpr",
-            "value": "02_custom_types.midas"
-          }
-        ],
-        "keywords": {}
-      }
-    },
     {
       "_type": "TypeAssign",
       "name": "df",

tests/checker.py

@@ -33,6 +33,10 @@ class CheckerTester(Tester):
         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()
@@ -40,7 +44,11 @@ class CheckerTester(Tester):
         resolver = Resolver()
         resolver.resolve(*stmts)
         result: CaseResult = CaseResult()
-        checker = Checker(resolver.locals, file_path=path)
+        checker = Checker(
+            resolver.locals,
+            source_path=path,
+            types_paths=types_paths,
+        )
         diagnostics: list[Diagnostic] = checker.check(stmts)
         for diagnostic in diagnostics:
             result.diagnostics.append(