Merge pull request 'Update README' (#14) from fix/update-readme into main

Reviewed-on: #14

README.md

@@ -1,4 +1,4 @@
-# Midas
+<h1>Midas</h1>
 
 *Midas* is a type system to _Maintain Integrity of Data with Annotated Structures_. In Greek mythology, [Midas](https://en.wikipedia.org/wiki/Midas) was a Phrygian king who was blessed with the gift of turning everything he touched into gold.
 
@@ -6,6 +6,24 @@
 
 This framework is being developed as part of a Bachelor's Thesis by Louis Heredero at HEI Sion.
 
+<details>
+<summary><strong>Table of Contents</strong></summary>
+
+- [Requirements](#requirements)
+- [Installation](#installation)
+- [Commands](#commands)
+  - [Type Checking](#type-checking)
+  - [Compiling](#compiling)
+  - [Formatting](#formatting)
+  - [Highlighting](#highlighting)
+  - [Dumping the AST](#dumping-the-ast)
+  - [Dumping the Registry](#dumping-the-registry)
+  - [Showing Type Judgements](#showing-type-judgements)
+  - [Validating Definitions](#validating-definitions)
+- [Tests](#tests)
+</details>
+
+
 ## Requirements
 
 - Python 3.11+
@@ -32,10 +50,26 @@ This framework is being developed as part of a Bachelor's Thesis by Louis Herede
 
 ## Commands
 
-### Compiling
+<!--
+check
+compile
+format
+highlight
+parse
+dump_registry
+types
+validate
+-->
 
-> [!NOTE]
-> In the current state of the project, the `compile` command doesn't generate any runnable code, it only runs the parsers and type checker on the provided files
+### Type Checking
+
+```shell
+midas check -t types.midas source.py
+```
+
+This command parses the given files and run the type checkers against the Midas definitions and Python program. Diagnostics are then printed showing warnings and errors.
+
+### Compiling
 
 ```shell
 midas compile -t types.midas source.py
@@ -43,14 +77,22 @@ midas compile -t types.midas source.py
 
 With the `compile` command, you can process a source Python file, with any number of custom type definition files (`-t FILE` option), and the type checker will verify the coherence of your program and generate the runnable code with valid syntax and runtime assertions.
 
-The optional `-l FILE` option lets you produce a highlighted version of the source code showing diagnostics from the type checker (see [Highlighting](#highlighting))
+### Formatting
+
+```shell
+midas format types.midas
+midas format types.midas -o formatted.midas
+```
+
+This command parses the given Midas file and outputs a pretty printed file from the AST.
 
 ### Highlighting
 
 ```shell
-midas utils highlight source.py
-# or
-midas utils highlight types.midas
+midas highlight source.py
+midas highlight source.py -o highlighted.html
+midas highlight types.midas
+midas highlight types.midas -o highlighted.html
 ```
 
 The `highlight` command takes in a source file (Python or Midas), runs the appropriate parser and outputs an HTML file containing the source code with added highlighting. This highlighting takes the form of hoverable annotations showing some of the parsed structures (e.g. a function definition, an assignment, a generic type, etc.)
@@ -60,14 +102,35 @@ The optional `-o FILE` option can be used to specify an output path. By default,
 ### Dumping the AST
 
 ```shell
-midas utils dump-ast source.py
-# or
-midas utils dump-ast types.midas
+midas parse source.py
+midas parse types.midas
 ```
 
-For debugging purposes, you can output the AST parsed from a Python or Midas file. For Python files, the `-p` flags lets you toggle the custom AST parsing. Without `-p`, the raw AST is returned, as produced by the builtin `ast` module. This flag has no effect on Midas files.
+For debugging purposes, you can output the AST parsed from a Python or Midas file. For Python files, the `--raw` flags lets you toggle the custom AST parsing. With `--raw`, the raw AST is returned, as produced by the builtin `ast` module. This flag has no effect on Midas files.
 
-The optional `-o FILE` option can be used to specify an output path. By default, the file is printed in stdout (equivalent to `-o -`).
+### Dumping the Registry
+
+```shell
+midas dump-registry -t types.midas
+```
+
+This command processes the given Midas definitions and dumps the contents of the types registry.
+
+### Showing Type Judgements
+
+```shell
+midas types -t types.midas source.py
+```
+
+This command type checks the given Python source file and logs all typing judgements made by the type checker.
+
+### Validating Definitions
+
+```shell
+midas validate types.midas
+```
+
+This command lets you validate a Midas definition file by running the parser and type checker, verifying syntax and references.
 
 ## Tests
 
@@ -77,6 +140,7 @@ Several snapshot tests are available to assert the good behaviour of the parsers
 uv run -m tests.midas run -a
 uv run -m tests.python run -a
 uv run -m tests.checker run -a
+uv run -m tests.generator run -a
 ```
 
 **Available subcommands:**

gen/midas.py

@@ -26,14 +26,6 @@ class MemberKind(Enum):
     METHOD = auto()
 
 
-@dataclass(frozen=True, kw_only=True)
-class ParamSpec:
-    l_paren: Token
-    pos: list[FunctionType.Argument]
-    mixed: list[FunctionType.Argument]
-    kw: list[FunctionType.Argument]
-
-
 ###<
 
 
@@ -58,8 +50,9 @@ class ExtendStmt:
 
 class PredicateStmt:
     name: Token
-    params: list[ParamSpec]
-    body: Expr
+    subject: Token
+    type: Type
+    condition: Expr
 
 
 ###<
@@ -85,12 +78,6 @@ class UnaryExpr:
     right: Expr
 
 
-class CallExpr:
-    callee: Expr
-    arguments: list[Expr]
-    keywords: dict[str, Expr]
-
-
 class GetExpr:
     expr: Expr
     name: Token
@@ -141,7 +128,9 @@ class ExtensionType:
 
 
 class FunctionType:
-    params: ParamSpec
+    pos_args: list[Argument]
+    args: list[Argument]
+    kw_args: list[Argument]
     returns: Type
 
     @dataclass(frozen=True, kw_only=True)

midas/ast/midas.py

@@ -27,14 +27,6 @@ class MemberKind(Enum):
     METHOD = auto()
 
 
-@dataclass(frozen=True, kw_only=True)
-class ParamSpec:
-    l_paren: Token
-    pos: list[FunctionType.Argument]
-    mixed: list[FunctionType.Argument]
-    kw: list[FunctionType.Argument]
-
-
 ##############
 # Statements #
 ##############
@@ -94,8 +86,9 @@ class ExtendStmt(Stmt):
 @dataclass(frozen=True)
 class PredicateStmt(Stmt):
     name: Token
-    params: list[ParamSpec]
-    body: Expr
+    subject: Token
+    type: Type
+    condition: Expr
 
     def accept(self, visitor: Stmt.Visitor[T]) -> T:
         return visitor.visit_predicate_stmt(self)
@@ -123,9 +116,6 @@ class Expr(ABC):
         @abstractmethod
         def visit_unary_expr(self, expr: UnaryExpr) -> T: ...
 
-        @abstractmethod
-        def visit_call_expr(self, expr: CallExpr) -> T: ...
-
         @abstractmethod
         def visit_get_expr(self, expr: GetExpr) -> T: ...
 
@@ -171,16 +161,6 @@ class UnaryExpr(Expr):
         return visitor.visit_unary_expr(self)
 
 
-@dataclass(frozen=True)
-class CallExpr(Expr):
-    callee: Expr
-    arguments: list[Expr]
-    keywords: dict[str, Expr]
-
-    def accept(self, visitor: Expr.Visitor[T]) -> T:
-        return visitor.visit_call_expr(self)
-
-
 @dataclass(frozen=True)
 class GetExpr(Expr):
     expr: Expr
@@ -299,7 +279,9 @@ class ExtensionType(Type):
 
 @dataclass(frozen=True)
 class FunctionType(Type):
-    params: ParamSpec
+    pos_args: list[Argument]
+    args: list[Argument]
+    kw_args: list[Argument]
     returns: Type
 
     @dataclass(frozen=True, kw_only=True)

midas/ast/printer.py

@@ -150,17 +150,13 @@ class MidasAstPrinter(
         self._write_line("PredicateStmt")
         with self._child_level():
             self._write_line(f'name: "{stmt.name.lexeme}"')
-            self._write_line("params")
-            with self._child_level():
-                for i, spec in enumerate(stmt.params):
-                    self._idx = i
-                    if i == len(stmt.params) - 1:
-                        self._mark_last()
-                    self._visit_param_spec(spec)
-
-            self._write_line("body", last=True)
+            self._write_line(f'subject: "{stmt.subject.lexeme}"')
+            self._write_line("type")
             with self._child_level(single=True):
-                stmt.body.accept(self)
+                stmt.type.accept(self)
+            self._write_line("condition", last=True)
+            with self._child_level(single=True):
+                stmt.condition.accept(self)
 
     # Expressions
 
@@ -199,29 +195,6 @@ class MidasAstPrinter(
             with self._child_level(single=True):
                 expr.right.accept(self)
 
-    def visit_call_expr(self, expr: m.CallExpr) -> None:
-        self._write_line("CallExpr")
-        with self._child_level():
-            self._write_line("callee")
-            with self._child_level(single=True):
-                expr.callee.accept(self)
-            self._write_line("arguments")
-            with self._child_level():
-                for i, arg in enumerate(expr.arguments):
-                    self._idx = i
-                    if i == len(expr.arguments) - 1:
-                        self._mark_last()
-                    arg.accept(self)
-            self._write_line("keywords", last=True)
-            with self._child_level():
-                for i, (name, arg) in enumerate(expr.keywords.items()):
-                    self._idx = i
-                    if i == len(expr.keywords) - 1:
-                        self._mark_last()
-                    self._write_line(name)
-                    with self._child_level(single=True):
-                        arg.accept(self)
-
     def visit_get_expr(self, expr: m.GetExpr):
         self._write_line("GetExpr")
         with self._child_level():
@@ -303,41 +276,34 @@ class MidasAstPrinter(
     def visit_function_type(self, type: m.FunctionType) -> None:
         self._write_line("FunctionType")
         with self._child_level():
-            self._write_line("params")
-            with self._child_level(single=True):
-                self._visit_param_spec(type.params)
+            self._write_line("pos_args")
+            with self._child_level():
+                for i, arg in enumerate(type.pos_args):
+                    self._idx = i
+                    if i == len(type.pos_args) - 1:
+                        self._mark_last()
+                    self._print_function_arg(arg)
+
+            self._write_line("args")
+            with self._child_level():
+                for i, arg in enumerate(type.args):
+                    self._idx = i
+                    if i == len(type.args) - 1:
+                        self._mark_last()
+                    self._print_function_arg(arg)
+
+            self._write_line("kw_args")
+            with self._child_level():
+                for i, arg in enumerate(type.kw_args):
+                    self._idx = i
+                    if i == len(type.kw_args) - 1:
+                        self._mark_last()
+                    self._print_function_arg(arg)
 
             self._write_line("returns", last=True)
             with self._child_level(single=True):
                 type.returns.accept(self)
 
-    def _visit_param_spec(self, spec: m.ParamSpec) -> None:
-        self._write_line("ParamSpec")
-        with self._child_level():
-            self._write_line("pos")
-            with self._child_level():
-                for i, arg in enumerate(spec.pos):
-                    self._idx = i
-                    if i == len(spec.pos) - 1:
-                        self._mark_last()
-                    self._print_function_arg(arg)
-
-            self._write_line("mixed")
-            with self._child_level():
-                for i, arg in enumerate(spec.mixed):
-                    self._idx = i
-                    if i == len(spec.mixed) - 1:
-                        self._mark_last()
-                    self._print_function_arg(arg)
-
-            self._write_line("kw", last=True)
-            with self._child_level():
-                for i, arg in enumerate(spec.kw):
-                    self._idx = i
-                    if i == len(spec.kw) - 1:
-                        self._mark_last()
-                    self._print_function_arg(arg)
-
     def _print_function_arg(self, arg: m.FunctionType.Argument) -> None:
         self._write_line("Argument")
         with self._child_level():
@@ -401,9 +367,10 @@ class MidasPrinter(m.Expr.Visitor[str], m.Stmt.Visitor[str], m.Type.Visitor[str]
 
     def visit_predicate_stmt(self, stmt: m.PredicateStmt):
         name: str = stmt.name.lexeme
-        sig: str = "".join(self._visit_param_spec(spec) for spec in stmt.params)
-        body: str = stmt.body.accept(self)
-        return self.indented(f"predicate {name}{sig} = {body}")
+        subject: str = stmt.subject.lexeme
+        type: str = stmt.type.accept(self)
+        condition: str = stmt.condition.accept(self)
+        return self.indented(f"predicate {name}({subject}: {type}) = {condition}")
 
     def visit_logical_expr(self, expr: m.LogicalExpr):
         left: str = expr.left.accept(self)
@@ -422,12 +389,6 @@ class MidasPrinter(m.Expr.Visitor[str], m.Stmt.Visitor[str], m.Type.Visitor[str]
         right: str = expr.right.accept(self)
         return f"{operator}{right}"
 
-    def visit_call_expr(self, expr: m.CallExpr) -> str:
-        args: list[str] = [arg.accept(self) for arg in expr.arguments] + [
-            f"{name}={arg.accept(self)}" for name, arg in expr.keywords.items()
-        ]
-        return f"{expr.callee.accept(self)}({', '.join(args)})"
-
     def visit_get_expr(self, expr: m.GetExpr):
         expr_: str = expr.expr.accept(self)
         name: str = expr.name.lexeme
@@ -475,13 +436,9 @@ class MidasPrinter(m.Expr.Visitor[str], m.Stmt.Visitor[str], m.Type.Visitor[str]
         return f"{type.base.accept(self)} & {type.extension.accept(self)}"
 
     def visit_function_type(self, type: m.FunctionType) -> str:
-        spec: str = self._visit_param_spec(type.params)
-        return f"fn {spec} -> {type.returns.accept(self)}"
-
-    def _visit_param_spec(self, spec: m.ParamSpec) -> str:
-        pos_args: list[str] = [self._print_arg(arg) for arg in spec.pos]
-        mixed_args: list[str] = [self._print_arg(arg) for arg in spec.mixed]
-        kw_args: list[str] = [self._print_arg(arg) for arg in spec.kw]
+        pos_args: list[str] = [self._print_arg(arg) for arg in type.pos_args]
+        mixed_args: list[str] = [self._print_arg(arg) for arg in type.args]
+        kw_args: list[str] = [self._print_arg(arg) for arg in type.kw_args]
         args: list[str] = pos_args
 
         if len(pos_args) != 0:
@@ -490,7 +447,8 @@ class MidasPrinter(m.Expr.Visitor[str], m.Stmt.Visitor[str], m.Type.Visitor[str]
         if len(kw_args) != 0:
             args.append("*")
         args += kw_args
-        return f"({', '.join(args)})"
+
+        return f"fn ({', '.join(args)}) -> {type.returns.accept(self)}"
 
     def _print_arg(self, arg: m.FunctionType.Argument) -> str:
         res: str = ""

midas/checker/midas.py

@@ -1,5 +1,4 @@
 import logging
-from dataclasses import dataclass
 from pathlib import Path
 from typing import Optional
 
@@ -10,11 +9,9 @@ from midas.checker.reporter import FileReporter, Reporter
 from midas.checker.types import (
     AliasType,
     ComplexType,
-    ConstraintType,
     ExtensionType,
     Function,
     GenericType,
-    Predicate,
     Type,
     TypeVar,
     UnknownType,
@@ -24,14 +21,7 @@ from midas.lexer.token import Token
 from midas.parser.midas import MidasParser
 
 
-@dataclass(frozen=True, kw_only=True)
-class TypedParamSpec:
-    pos: list[Function.Argument]
-    mixed: list[Function.Argument]
-    kw: list[Function.Argument]
-
-
-class MidasTyper(m.Stmt.Visitor[None], m.Expr.Visitor[Type], m.Type.Visitor[Type]):
+class MidasTyper(m.Stmt.Visitor[None], m.Expr.Visitor[None], m.Type.Visitor[Type]):
     """A resolver which evaluates Midas type definitions and build a registry"""
 
     def __init__(self, types: TypesRegistry, reporter: Reporter) -> None:
@@ -41,16 +31,12 @@ class MidasTyper(m.Stmt.Visitor[None], m.Expr.Visitor[Type], m.Type.Visitor[Type
         self.types: TypesRegistry = types
         self._local_variables: dict[str, TypeVar] = {}
 
-        self._predicate_params: dict[str, Type] = {}
-
         self._current_name: Optional[str] = None
 
         define_builtins(self.types)
         builtins_path: Path = (Path(__file__).parent / "builtins.midas").resolve()
         self.process(builtins_path.read_text(), str(builtins_path))
 
-        self._bool: Type = self.get_type("bool")
-
     def process(self, source: str, path: Optional[str]):
         self.reporter = self.reporter.for_file(path)
         lexer: MidasLexer = MidasLexer(source)
@@ -61,10 +47,6 @@ class MidasTyper(m.Stmt.Visitor[None], m.Expr.Visitor[Type], m.Type.Visitor[Type
             self.reporter.error(error.token.get_location(), error.message)
         self.resolve(stmts)
 
-    def type_of(self, expr: m.Expr) -> Type:
-        type: Type = expr.accept(self)
-        return type
-
     def get_type(self, name: str) -> Type:
         """Get a type from its name
 
@@ -81,14 +63,6 @@ class MidasTyper(m.Stmt.Visitor[None], m.Expr.Visitor[Type], m.Type.Visitor[Type
             return self._local_variables[name]
         return self.types.get_type(name)
 
-    def get_variable(self, name: str) -> Type:
-        if name in self._predicate_params:
-            return self._predicate_params[name]
-        predicate: Optional[Predicate] = self.types.lookup_predicate(name)
-        if predicate is None:
-            raise NameError(f"Unknown variable '{name}'")
-        return predicate.type
-
     def resolve(self, stmts: list[m.Stmt]):
         """Process a sequence of statements
 
@@ -98,12 +72,6 @@ class MidasTyper(m.Stmt.Visitor[None], m.Expr.Visitor[Type], m.Type.Visitor[Type
         for stmt in stmts:
             stmt.accept(self)
 
-    def assert_bool(self, expr: m.Expr):
-        type: Type = self.type_of(expr)
-        if not self.types.is_subtype(type, self._bool):
-            # TODO: change back to error when operations are type checked
-            self.reporter.warning(expr.location, f"Must be a boolean but is {type}")
-
     def visit_type_stmt(self, stmt: m.TypeStmt) -> None:
         name: str = stmt.name.lexeme
         self._current_name = name
@@ -138,125 +106,31 @@ class MidasTyper(m.Stmt.Visitor[None], m.Expr.Visitor[Type], m.Type.Visitor[Type
             )
 
     def visit_predicate_stmt(self, stmt: m.PredicateStmt) -> None:
-        for spec in stmt.params:
-            for param in spec.mixed:
-                assert param.name is not None
-                self._predicate_params[param.name.lexeme] = param.type.accept(self)
+        self.reporter.warning(stmt.location, "PredicateStmt not yet supported")
 
-        type: Type = self.type_of(stmt.body)
-        params: list[TypedParamSpec] = [
-            self._visit_param_spec(spec) for spec in stmt.params
-        ]
+    def visit_logical_expr(self, expr: m.LogicalExpr) -> None:
+        self.reporter.warning(expr.location, "LogicalExpr not yet supported")
 
-        if not self._is_valid_predicate(type):
-            # TODO: change back to error when operations are type checked
-            self.reporter.warning(
-                stmt.body.location,
-                f"Predicate function body must evaluate to a boolean, got {type}",
-            )
-        if len(params) != 0:
-            type = self._bool
-            for spec in reversed(params):
-                type = Function(
-                    pos_args=spec.pos,
-                    args=spec.mixed,
-                    kw_args=spec.kw,
-                    returns=type,
-                )
-        self._predicate_params = {}
-        self.types.define_predicate(
-            stmt.name.lexeme,
-            Predicate(
-                type=type,
-                body=stmt.body,
-                alias=len(params) == 0,
-            ),
-        )
-
-    def _is_valid_predicate(self, body: Type) -> bool:
-        match body:
-            case Function(returns=returns):
-                return self._is_valid_predicate(returns)
-            case _ if self.types.is_subtype(body, self._bool):
-                return True
-            case _:
-                return False
-
-    def visit_logical_expr(self, expr: m.LogicalExpr) -> Type:
-        self.assert_bool(expr.left)
-        self.assert_bool(expr.right)
-        return self._bool
-
-    def visit_binary_expr(self, expr: m.BinaryExpr) -> Type:
-        # TODO
+    def visit_binary_expr(self, expr: m.BinaryExpr) -> None:
         self.reporter.warning(expr.location, "BinaryExpr not yet supported")
-        return UnknownType()
 
-    def visit_unary_expr(self, expr: m.UnaryExpr) -> Type:
-        # TODO
+    def visit_unary_expr(self, expr: m.UnaryExpr) -> None:
         self.reporter.warning(expr.location, "UnaryExpr not yet supported")
-        return UnknownType()
 
-    def visit_call_expr(self, expr: m.CallExpr) -> Type:
-        callee: Type = expr.callee.accept(self)
-        if not isinstance(callee, Function):
-            self.reporter.error(expr.location, f"Cannot call {callee}")
-            return UnknownType()
-        args: list[Type] = [arg.accept(self) for arg in expr.arguments]
+    def visit_get_expr(self, expr: m.GetExpr) -> None:
+        self.reporter.warning(expr.location, "GetExpr not yet supported")
 
-        n_args: int = len(args)
-        n_params: int = len(callee.args)
-        if n_args != n_params:
-            self.reporter.error(
-                expr.location,
-                f"Wrong number of argument, expected {n_params}, got {n_args}",
-            )
-            return UnknownType()
+    def visit_variable_expr(self, expr: m.VariableExpr) -> None:
+        self.reporter.warning(expr.location, "VariableExpr not yet supported")
 
-        valid: bool = True
-        for arg, param in zip(args, callee.args):
-            if not self.types.is_subtype(arg, param.type):
-                self.reporter.error(
-                    expr.location,
-                    f"Invalid argument type at pos {param.pos}, expected {param.type}, got {arg}",
-                )
-                valid = False
-        if not valid:
-            return UnknownType()
-        return callee.returns
-
-    def visit_get_expr(self, expr: m.GetExpr) -> Type:
-        object: Type = expr.expr.accept(self)
-        member: Optional[Type] = self.types.lookup_member(object, expr.name.lexeme)
-        if member is None:
-            self.reporter.error(
-                expr.location, f"Unknown member '{expr.name}' of {object}"
-            )
-            return UnknownType()
-        return member
-
-    def visit_variable_expr(self, expr: m.VariableExpr) -> Type:
-        return self.get_variable(expr.name.lexeme)
-
-    def visit_grouping_expr(self, expr: m.GroupingExpr) -> Type:
+    def visit_grouping_expr(self, expr: m.GroupingExpr) -> None:
         return expr.expr.accept(self)
 
-    def visit_literal_expr(self, expr: m.LiteralExpr) -> Type:
-        match expr.value:
-            case bool():  # Must be before int
-                return self.types.get_type("bool")
-            case int():
-                return self.types.get_type("int")
-            case float():
-                return self.types.get_type("float")
-            case str():
-                return self.types.get_type("str")
-            case _:
-                self.reporter.warning(expr.location, f"Unknown literal {expr}")
-                return UnknownType()
+    def visit_literal_expr(self, expr: m.LiteralExpr) -> None:
+        self.reporter.warning(expr.location, "LiteralExpr not yet supported")
 
-    def visit_wildcard_expr(self, expr: m.WildcardExpr) -> Type:
-        return self.get_variable("_")
+    def visit_wildcard_expr(self, expr: m.WildcardExpr) -> None:
+        self.reporter.warning(expr.location, "WildcardExpr not yet supported")
 
     def visit_named_type(self, type: m.NamedType) -> Type:
         name: str = type.name.lexeme
@@ -279,10 +153,10 @@ class MidasTyper(m.Stmt.Visitor[None], m.Expr.Visitor[Type], m.Type.Visitor[Type
             return UnknownType()
 
     def visit_constraint_type(self, type: m.ConstraintType) -> Type:
-        return ConstraintType(
-            type=type.type.accept(self),
-            constraint=type.constraint,
-        )
+        type_: Type = type.type.accept(self)
+        type.constraint.accept(self)
+        # TODO
+        return UnknownType()
 
     def visit_complex_type(self, type: m.ComplexType) -> ComplexType:
         return ComplexType(
@@ -298,17 +172,8 @@ class MidasTyper(m.Stmt.Visitor[None], m.Expr.Visitor[Type], m.Type.Visitor[Type
         )
 
     def visit_function_type(self, type: m.FunctionType) -> Type:
-        params: TypedParamSpec = self._visit_param_spec(type.params)
-        return Function(
-            pos_args=params.pos,
-            args=params.mixed,
-            kw_args=params.kw,
-            returns=type.returns.accept(self),
-        )
-
-    def _visit_param_spec(self, spec: m.ParamSpec) -> TypedParamSpec:
-        n_pos: int = len(spec.pos)
-        n_mixed: int = len(spec.mixed)
+        n_pos_args: int = len(type.pos_args)
+        n_args: int = len(type.args)
 
         def process_arg(arg: m.FunctionType.Argument, i: int) -> Function.Argument:
             return Function.Argument(
@@ -318,10 +183,14 @@ class MidasTyper(m.Stmt.Visitor[None], m.Expr.Visitor[Type], m.Type.Visitor[Type
                 required=arg.required,
             )
 
-        return TypedParamSpec(
-            pos=[process_arg(arg, i) for i, arg in enumerate(spec.pos)],
-            mixed=[process_arg(arg, i + n_pos) for i, arg in enumerate(spec.mixed)],
-            kw=[process_arg(arg, i + n_pos + n_mixed) for i, arg in enumerate(spec.kw)],
+        return Function(
+            pos_args=[process_arg(arg, i) for i, arg in enumerate(type.pos_args)],
+            args=[process_arg(arg, i + n_pos_args) for i, arg in enumerate(type.args)],
+            kw_args=[
+                process_arg(arg, i + n_pos_args + n_args)
+                for i, arg in enumerate(type.kw_args)
+            ],
+            returns=type.returns.accept(self),
         )
 
     def _resolve_type_params(self, params: list[m.TypeParam]):

midas/checker/python.py

@@ -652,7 +652,7 @@ class PythonTyper(
         If the function has overloads, the function will try to resolve the
         appropriate signature.
         Argument types are matched to the defined parameters.
-        The function doesn't take the raw expression as a parameter to accommodate
+        The function doesn't take the raw expression as a parameter to accomodate
         for desugared calls such as for operators.
 
         Args:
@@ -743,7 +743,7 @@ class PythonTyper(
 
         Returns:
             Optional[Function]: the resolved function signature if it can be
-            determined unambiguously, or `None`.
+            determined unambigously, or `None`.
         """
         candidates: list[OverloadCandidate] = []
         for overload in overloads:

midas/checker/registry.py

@@ -7,12 +7,10 @@ from midas.checker.types import (
     AppliedType,
     BaseType,
     ComplexType,
-    ConstraintType,
     ExtensionType,
     Function,
     GenericType,
     OverloadedFunction,
-    Predicate,
     TopType,
     Type,
     TypeVar,
@@ -26,7 +24,6 @@ class TypesRegistry:
         self.logger: logging.Logger = logging.getLogger("TypesRegistry")
         self._types: dict[str, Type] = {}
         self._members: dict[str, dict[str, Type]] = {}
-        self._predicates: dict[str, Predicate] = {}
 
     def get_type(self, name: str) -> Type:
         """Get a type from its name
@@ -84,11 +81,6 @@ class TypesRegistry:
         else:
             members[member_name] = member_type
 
-    def define_predicate(self, name: str, predicate: Predicate):
-        if name in self._predicates:
-            raise ValueError(f"Predicate {name} already defined")
-        self._predicates[name] = predicate
-
     def is_subtype(self, type1: Type, type2: Type) -> bool:
         """Check whether `type1` is a subtype of `type2`
 
@@ -131,9 +123,6 @@ class TypesRegistry:
                     return False
                 return self.is_subtype(bound, type2)
 
-            case (ConstraintType(type=base1), _):
-                return self.is_subtype(base1, type2)
-
         return False
 
     # TODO: verify the logic in here
@@ -356,6 +345,3 @@ class TypesRegistry:
             case _:
                 self.logger.debug(f"Can't get member on {type}")
                 return None
-
-    def lookup_predicate(self, name: str) -> Optional[Predicate]:
-        return self._predicates.get(name)

midas/checker/types.py

@@ -1,10 +1,7 @@
 from __future__ import annotations
 
 from dataclasses import dataclass, field
-from typing import Optional, assert_never
-
-import midas.ast.midas as m
-from midas.ast.printer import MidasPrinter
+from typing import Optional
 
 
 @dataclass(frozen=True, kw_only=True)
@@ -133,16 +130,6 @@ class AppliedType:
         return f"{self.name}[{', '.join(map(str, self.args))}]"
 
 
-@dataclass(frozen=True, kw_only=True)
-class ConstraintType:
-    type: Type
-    constraint: m.Expr
-
-    def __str__(self) -> str:
-        printer = MidasPrinter()
-        return f"{self.type} where {printer.print(self.constraint)}"
-
-
 def substitute_typevars(type: Type, substitutions: dict[str, Type]) -> Type:
     def sub_argument(arg: Function.Argument):
         return Function.Argument(
@@ -208,12 +195,6 @@ def substitute_typevars(type: Type, substitutions: dict[str, Type]) -> Type:
                 body=substitute_typevars(body, substitutions),
             )
 
-        case ConstraintType():
-            return ConstraintType(
-                type=substitute_typevars(type.type, substitutions),
-                constraint=type.constraint,
-            )
-
         case TypeVar(name=name):
             if name in substitutions:
                 return substitutions[name]
@@ -222,12 +203,8 @@ def substitute_typevars(type: Type, substitutions: dict[str, Type]) -> Type:
         case UnknownType() | UnitType():
             return type
 
-        case TopType() | GenericType():
-            raise NotImplementedError(f"Unsupported type {type}")
-
-        # Ensure exhaustiveness
         case _:
-            assert_never(type)
+            raise NotImplementedError(f"Unsupported type {type}")
 
 
 def unfold_type(type: Type) -> Type:
@@ -238,65 +215,6 @@ def unfold_type(type: Type) -> Type:
             return type
 
 
-def to_annotation(type: Type) -> str:
-    def _args_annotation(func: Function) -> str:
-        if len(func.kw_args) != 0:
-            return "..."
-
-        args: str = ", ".join(
-            to_annotation(arg.type) for arg in func.pos_args + func.args
-        )
-        return f"[{args}]"
-
-    match type:
-        case TopType():
-            return "Any"
-
-        case BaseType(name=name):
-            return name
-
-        case AliasType(name=name):
-            return name
-
-        case UnknownType():
-            return "Any"
-
-        case UnitType():
-            return "None"
-
-        case Function(returns=returns):
-            params_annot: str = _args_annotation(type)
-            return f"Callable[{params_annot}, {to_annotation(returns)}]"
-
-        case OverloadedFunction():
-            return "Callable"
-
-        case ComplexType() | ExtensionType():
-            raise NotImplementedError
-
-        case TypeVar(name=name):
-            return name
-
-        case GenericType(name=name, params=params):
-            return f"{name}[{', '.join(map(to_annotation, params))}]"
-
-        case AppliedType(name=name, args=args):
-            return f"{name}[{', '.join(map(to_annotation, args))}]"
-
-        case ConstraintType():
-            return str(type)
-
-        case _:
-            assert_never(type)
-
-
-@dataclass(frozen=True, kw_only=True)
-class Predicate:
-    type: Type
-    body: m.Expr
-    alias: bool
-
-
 Type = (
     TopType
     | BaseType
@@ -310,5 +228,4 @@ Type = (
     | TypeVar
     | GenericType
     | AppliedType
-    | ConstraintType
 )

midas/cli/commands/compile.py

@@ -38,5 +38,5 @@ def compile(
     if any(map(lambda d: d.type == DiagnosticType.ERROR, diagnostics)):
         sys.exit(1)
 
-    generator = Generator(workdir=source_path.parent, types=checker.types)
+    generator = Generator(workdir=source_path.parent)
     generator.generate(typed_ast, source_path)

midas/cli/commands/registry.py

@@ -8,7 +8,6 @@ from typing import TextIO
 
 import click
 
-from midas.ast.printer import MidasPrinter
 from midas.checker.checker import TypeChecker
 from midas.checker.types import AliasType, AppliedType, BaseType, GenericType, Type
 
@@ -36,7 +35,6 @@ def dump_registry(
     for types_file in types:
         checker.import_midas(Path(types_file.name).resolve())
 
-    print("##### Types #####")
     for name, type in checker.types._types.items():
         members: dict[str, Type] = checker.types._members.get(name, {})
         print(f"{name} = {base_type(type)}")
@@ -44,17 +42,3 @@ def dump_registry(
             print(" " * 4 + "Members:")
             for member_name, member_type in members.items():
                 print(" " * 8 + f"{member_name}: {member_type}")
-
-    print("##### Predicates #####")
-    printer = MidasPrinter()
-    for name, predicate in checker.types._predicates.items():
-        body: str = printer.print(predicate.body)
-        if predicate.alias:
-            print(f"{name}: {predicate.type} = {body}")
-        else:
-            print(f"{name}{predicate.type}:")
-            body = "\n".join(
-                "    " + ("return " if i == 0 else "") + line
-                for i, line in enumerate(body.split("\n"))
-            )
-            print(body)

midas/generator/constraints.py

@@ -1,224 +0,0 @@
-import ast
-from typing import Optional
-
-import midas.ast.midas as m
-from midas.checker.registry import TypesRegistry
-from midas.checker.types import (
-    Function,
-    Predicate,
-    Type,
-    to_annotation,
-)
-from midas.lexer.token import TokenType
-
-LOGICAL_OPERATORS: dict[TokenType, type[ast.boolop]] = {
-    TokenType.AND: ast.And,
-    # TokenType.OR: ast.Or,
-}
-
-BINARY_OPERATORS: dict[TokenType, type[ast.operator]] = {
-    # TokenType.PLUS: ast.Add,
-    TokenType.MINUS: ast.Sub,
-    TokenType.STAR: ast.Mult,
-    TokenType.SLASH: ast.Div,
-}
-
-UNARY_OPERATORS: dict[TokenType, type[ast.unaryop]] = {
-    # TokenType.PLUS: ast.UAdd,
-    TokenType.MINUS: ast.USub,
-}
-
-COMPARISON_OPERATORS: dict[TokenType, type[ast.cmpop]] = {
-    TokenType.GREATER: ast.Gt,
-    TokenType.GREATER_EQUAL: ast.GtE,
-    TokenType.LESS: ast.Lt,
-    TokenType.LESS_EQUAL: ast.LtE,
-    TokenType.EQUAL_EQUAL: ast.Eq,
-    TokenType.BANG_EQUAL: ast.NotEq,
-}
-
-
-class ConstraintGenerator(m.Expr.Visitor[ast.expr]):
-    def __init__(self, types: TypesRegistry):
-        self.types: TypesRegistry = types
-        self._id: int = 0
-        self._definitions: list[ast.stmt] = []
-        self._aliases: dict[str, str] = {}
-
-    def get_definitions(self) -> list[ast.stmt]:
-        return self._definitions
-
-    def generate(self, expr: m.Expr) -> ast.expr:
-        match expr:
-            case m.VariableExpr():
-                return expr.accept(self)
-            case _:
-                func = Function(
-                    pos_args=[],
-                    args=[
-                        Function.Argument(
-                            pos=0,
-                            name="_",
-                            type=self.types.get_type("Any"),
-                            required=True,
-                        )
-                    ],
-                    kw_args=[],
-                    returns=self.types.get_type("bool"),
-                )
-                alias: str = self.make_alias(None)
-                definition: ast.stmt = self.make_definition(
-                    alias, Predicate(type=func, body=expr, alias=False)
-                )
-                self._definitions.append(definition)
-                return ast.Name(id=alias)
-
-    def make_alias(self, name: Optional[str]) -> str:
-        suffix: str
-        if name is None:
-            suffix = f"p{self._id}"
-            self._id += 1
-        else:
-            suffix = name
-        alias: str = f"__midas_{suffix}__"
-        return alias
-
-    def make_definition(self, name: str, predicate: Predicate) -> ast.stmt:
-        body: ast.expr = predicate.body.accept(self)
-        if predicate.alias:
-            return ast.Assign(
-                targets=[
-                    ast.Name(id=name),
-                ],
-                value=body,
-            )
-        return self.make_func(name, [ast.Return(value=body)], predicate.type)
-
-    def make_args(self, func: Function) -> ast.arguments:
-        return ast.arguments(
-            posonlyargs=[
-                ast.arg(
-                    arg=arg.name,
-                    annotation=ast.Constant(value=to_annotation(arg.type)),
-                )
-                for arg in func.pos_args
-            ],
-            args=[
-                ast.arg(
-                    arg=arg.name,
-                    annotation=ast.Constant(value=to_annotation(arg.type)),
-                )
-                for arg in func.args
-            ],
-            kwonlyargs=[
-                ast.arg(
-                    arg=arg.name,
-                    annotation=ast.Constant(value=to_annotation(arg.type)),
-                )
-                for arg in func.kw_args
-            ],
-            defaults=[],
-            kw_defaults=[],
-        )
-
-    def make_func(
-        self, name: str, inner_body: list[ast.stmt], type: Type, level: int = 0
-    ) -> ast.stmt:
-        match type:
-            case Function(returns=Function()):
-                inner_name: str = f"inner{level}"
-                return ast.FunctionDef(
-                    name=name,
-                    args=self.make_args(type),
-                    body=[
-                        self.make_func(inner_name, inner_body, type.returns, level + 1),
-                        ast.Return(value=ast.Name(id=inner_name)),
-                    ],
-                    returns=ast.Constant(value=to_annotation(type.returns)),
-                    decorator_list=[],
-                )
-
-            case Function():
-                return ast.FunctionDef(
-                    name=name,
-                    args=self.make_args(type),
-                    body=inner_body,
-                    returns=ast.Constant(value=to_annotation(type.returns)),
-                    decorator_list=[],
-                )
-
-            case _:
-                raise ValueError(f"Expected function, got {type!r}")
-
-    def get_predicate(self, name: str) -> Optional[ast.expr]:
-        if name not in self._aliases:
-            predicate: Optional[Predicate] = self.types.lookup_predicate(name)
-            if predicate is None:
-                return None
-            alias: str = self.make_alias(name)
-            self._aliases[name] = alias
-            self._definitions.append(self.make_definition(alias, predicate))
-
-        return ast.Name(id=self._aliases[name])
-
-    def visit_logical_expr(self, expr: m.LogicalExpr) -> ast.expr:
-        return ast.BoolOp(
-            op=LOGICAL_OPERATORS[expr.operator.type](),
-            values=[
-                expr.left.accept(self),
-                expr.right.accept(self),
-            ],
-        )
-
-    def visit_binary_expr(self, expr: m.BinaryExpr) -> ast.expr:
-        op: TokenType = expr.operator.type
-        if op in BINARY_OPERATORS:
-            return ast.BinOp(
-                left=expr.left.accept(self),
-                op=BINARY_OPERATORS[op](),
-                right=expr.right.accept(self),
-            )
-        if op in COMPARISON_OPERATORS:
-            return ast.Compare(
-                left=expr.left.accept(self),
-                ops=[COMPARISON_OPERATORS[op]()],
-                comparators=[expr.right.accept(self)],
-            )
-        raise ValueError(f"Unexpected binary operator {op}")
-
-    def visit_unary_expr(self, expr: m.UnaryExpr) -> ast.expr:
-        return ast.UnaryOp(
-            op=UNARY_OPERATORS[expr.operator.type](),
-            operand=expr.right.accept(self),
-        )
-
-    def visit_call_expr(self, expr: m.CallExpr) -> ast.expr:
-        return ast.Call(
-            func=expr.callee.accept(self),
-            args=[arg.accept(self) for arg in expr.arguments],
-            keywords=[
-                ast.keyword(arg=name, value=arg.accept(self))
-                for name, arg in expr.keywords.items()
-            ],
-        )
-
-    def visit_get_expr(self, expr: m.GetExpr) -> ast.expr:
-        return ast.Attribute(
-            value=expr.expr.accept(self),
-            attr=expr.name.lexeme,
-        )
-
-    def visit_variable_expr(self, expr: m.VariableExpr) -> ast.expr:
-        name: str = expr.name.lexeme
-        if (p := self.get_predicate(name)) is not None:
-            return p
-        return ast.Name(id=name)
-
-    def visit_grouping_expr(self, expr: m.GroupingExpr) -> ast.expr:
-        return expr.accept(self)
-
-    def visit_literal_expr(self, expr: m.LiteralExpr) -> ast.expr:
-        return ast.Constant(value=expr.value)
-
-    def visit_wildcard_expr(self, expr: m.WildcardExpr) -> ast.expr:
-        return ast.Name(id="_")

midas/generator/generator.py

@@ -2,19 +2,15 @@ import ast
 import shutil
 from dataclasses import dataclass, field
 from pathlib import Path
-from typing import Optional, assert_never
+from typing import Optional
 
-import midas.ast.midas as m
 import midas.ast.python as p
 from midas.ast.location import Location
-from midas.ast.printer import MidasPrinter
-from midas.checker.registry import TypesRegistry
 from midas.checker.types import (
     AliasType,
     AppliedType,
     BaseType,
     ComplexType,
-    ConstraintType,
     ExtensionType,
     Function,
     GenericType,
@@ -23,9 +19,7 @@ from midas.checker.types import (
     Type,
     TypeVar,
     UnitType,
-    UnknownType,
 )
-from midas.generator.constraints import ConstraintGenerator
 from midas.utils import TypedAST
 
 
@@ -36,7 +30,7 @@ class Scope:
 
 
 class Generator(p.Stmt.Visitor[ast.stmt], p.Expr.Visitor[ast.expr]):
-    def __init__(self, workdir: Path, types: TypesRegistry) -> None:
+    def __init__(self, workdir: Path) -> None:
         self.workdir: Path = workdir.resolve()
         self.build_dir: Path = self.workdir / "build" / "midas"
         if self.build_dir.exists():
@@ -49,18 +43,13 @@ class Generator(p.Stmt.Visitor[ast.stmt], p.Expr.Visitor[ast.expr]):
             judgements=[],
         )
         self._alias_count: int = 0
-        self._predicate_count: int = 0
         self._scopes: list[Scope] = []
 
-        self._constraint_generator: ConstraintGenerator = ConstraintGenerator(types)
-        self._constraints: list[tuple[m.Expr, ast.expr]] = []
-
     def generate_ast(self, typed_ast: TypedAST, src_path: Path) -> ast.AST:
         self.rel_src_path = src_path.relative_to(self.workdir)
         self._typed_ast = typed_ast
         body: list[ast.stmt] = self._visit_body(typed_ast.stmts)
-        predicates: list[ast.stmt] = self._constraint_generator.get_definitions()
-        module = ast.Module(body=predicates + body, type_ignores=[])
+        module = ast.Module(body=body, type_ignores=[])
         module = ast.fix_missing_locations(module)
         return module
 
@@ -257,7 +246,7 @@ class Generator(p.Stmt.Visitor[ast.stmt], p.Expr.Visitor[ast.expr]):
         return generated
 
     def _make_alias(self, expr: ast.expr) -> ast.expr:
-        name: str = f"__midas_a{self._alias_count}__"
+        name: str = f"__midas_alias_{self._alias_count}__"
         alias = ast.Name(id=name)
         self._alias_count += 1
         self._scopes[-1].aliases.append(name)
@@ -287,9 +276,6 @@ class Generator(p.Stmt.Visitor[ast.stmt], p.Expr.Visitor[ast.expr]):
 
     def _make_cast_asserts(self, src_location: Location, expr: ast.expr, type: Type):
         match type:
-            case UnknownType():
-                pass
-
             case BaseType(name=name):
                 self._add_assert(
                     ast.Call(
@@ -315,15 +301,8 @@ class Generator(p.Stmt.Visitor[ast.stmt], p.Expr.Visitor[ast.expr]):
                     self._make_cast_assert_message(src_location, expr, type),
                 )
 
-            case AppliedType(body=body):
-                self._make_cast_asserts(src_location, expr, body)
-
-            case ConstraintType(type=base, constraint=constraint):
-                self._make_cast_asserts(src_location, expr, base)
-                self._make_constraint_assert(src_location, expr, constraint)
-
-            case TypeVar():
-                raise RuntimeError("Unexpected TypeVar")
+            case AppliedType():
+                self._make_cast_asserts(src_location, expr, type.body)
 
             case (
                 TopType()
@@ -335,9 +314,8 @@ class Generator(p.Stmt.Visitor[ast.stmt], p.Expr.Visitor[ast.expr]):
             ):
                 raise NotImplementedError(f"Can't make assertion for type {type}")
 
-            # Ensure exhaustiveness
-            case _:
-                assert_never(type)
+            case TypeVar():
+                raise RuntimeError("Unexpected TypeVar")
 
     def _make_cast_assert_message(
         self, location: Location, expr: ast.expr, type: Type
@@ -361,36 +339,3 @@ class Generator(p.Stmt.Visitor[ast.stmt], p.Expr.Visitor[ast.expr]):
                 ast.Constant(f" to {type}"),
             ]
         )
-
-    def _make_constraint_assert(
-        self, src_location: Location, expr: ast.expr, constraint: m.Expr
-    ):
-        test_func: ast.expr = self._get_constraint(constraint)
-        self._add_assert(
-            ast.Call(
-                func=test_func,
-                args=[expr],
-                keywords=[],
-            ),
-            self._make_constraint_assert_message(src_location, expr, constraint),
-        )
-
-    def _make_constraint_assert_message(
-        self, location: Location, expr: ast.expr, constraint: m.Expr
-    ) -> ast.expr:
-        printer = MidasPrinter()
-        constraint_str: str = printer.print(constraint)
-        loc_str: str = f"{self.rel_src_path}:L{location.lineno}:{location.col_offset+1}"
-        # f"file.py:L1:1: ConstraintError: Value does not fit constraint 'v > 0'"
-        return ast.Constant(
-            f"{loc_str}: ConstraintError: Value does not fit constraint '{constraint_str}'"
-        )
-
-    def _get_constraint(self, expr: m.Expr) -> ast.expr:
-        for expr2, constraint in self._constraints:
-            if expr2 == expr:
-                return constraint
-
-        constraint: ast.expr = self._constraint_generator.generate(expr)
-        self._constraints.append((expr, constraint))
-        return constraint

midas/parser/midas.py

@@ -3,7 +3,6 @@ from typing import Optional
 from midas.ast.location import Location
 from midas.ast.midas import (
     BinaryExpr,
-    CallExpr,
     ComplexType,
     ConstraintType,
     Expr,
@@ -18,7 +17,6 @@ from midas.ast.midas import (
     MemberKind,
     MemberStmt,
     NamedType,
-    ParamSpec,
     PredicateStmt,
     Stmt,
     Type,
@@ -267,9 +265,6 @@ class MidasParser(Parser):
         Returns:
             Expr: the parsed constraint expression
         """
-        return self.expression()
-
-    def expression(self) -> Expr:
         return self.and_()
 
     def and_(self) -> Expr:
@@ -336,55 +331,7 @@ class MidasParser(Parser):
             right: Expr = self.unary()
             location: Location = Location.span(operator.get_location(), right.location)
             return UnaryExpr(location=location, operator=operator, right=right)
-        return self.call()
-
-    def call(self) -> Expr:
-        expr: Expr = self.reference()
-        while self.match(TokenType.LEFT_PAREN):
-            expr = self.finish_call(expr)
-        return expr
-
-    def finish_call(self, callee: Expr) -> Expr:
-        l_paren: Token = self.previous()
-        pos_args: list[Expr] = []
-        kw_args: dict[str, Expr] = {}
-        keywords: bool = False
-        while not self.match(TokenType.RIGHT_PAREN):
-            if self.check_identifier() and self.check_next(TokenType.EQUAL):
-                keywords = True
-                keyword: Token = self.advance()
-                value: Expr = self.expression()
-                name: str = keyword.lexeme
-                if name in kw_args:
-                    self.error(
-                        self.peek(),
-                        f"Multiple values passed for '{name}', only the last occurrence will be used",
-                    )
-                kw_args[name] = value
-            else:
-                value = self.expression()
-                if self.check(TokenType.EQUAL):
-                    if keywords:
-                        raise self.error(self.peek(), "Invalid keyword argument name")
-                    else:
-                        raise self.error(
-                            self.peek(),
-                            "Cannot pass positional arguments after a keyword argument",
-                        )
-                pos_args.append(value)
-
-            if not self.match(TokenType.COMMA):
-                break
-
-        r_paren: Token = self.consume(
-            TokenType.RIGHT_PAREN, "Expected ')' after arguments."
-        )
-        return CallExpr(
-            location=Location.span(callee.location, r_paren.get_location()),
-            callee=callee,
-            arguments=pos_args,
-            keywords=kw_args,
-        )
+        return self.reference()
 
     def reference(self) -> Expr:
         """Parse an attribute access expression or a simpler expression
@@ -506,35 +453,23 @@ class MidasParser(Parser):
             PredicateStmt: the parsed predicate declaration statement
         """
         keyword: Token = self.previous()
-
         name: Token = self.consume_identifier("Expected predicate name")
-
-        params: list[ParamSpec] = []
-        while self.check(TokenType.LEFT_PAREN):
-            params.append(self.function_args())
-
+        self.consume(TokenType.LEFT_PAREN, "Expected '(' before predicate subject")
+        subject: Token = self.consume_identifier("Expected subject name")
+        self.consume(TokenType.COLON, "Expected ':' after subject name")
+        type: Type = self.type_expr()
+        self.consume(TokenType.RIGHT_PAREN, "Expected ')' after predicate subject")
         self.consume(TokenType.EQUAL, "Expected '=' after predicate subject")
-        body: Expr = self.constraint()
+        condition: Expr = self.constraint()
         return PredicateStmt(
             location=keyword.location_to(self.previous()),
             name=name,
-            params=params,
-            body=body,
+            subject=subject,
+            type=type,
+            condition=condition,
         )
 
     def function(self) -> FunctionType:
-        params: ParamSpec = self.function_args()
-
-        self.consume(TokenType.ARROW, "Expected '->' before result type")
-        result: Type = self.type_expr()
-
-        return FunctionType(
-            location=params.l_paren.location_to(self.previous()),
-            params=params,
-            returns=result,
-        )
-
-    def function_args(self) -> ParamSpec:
         l_paren: Token = self.consume(
             TokenType.LEFT_PAREN, "Expected '(' before function parameters"
         )
@@ -591,4 +526,14 @@ class MidasParser(Parser):
                 self.error(token, "Unnamed mixed argument")
 
         self.consume(TokenType.RIGHT_PAREN, "Expected ')' after function parameters")
-        return ParamSpec(l_paren=l_paren, pos=pos_args, mixed=args, kw=kw_args)
+
+        self.consume(TokenType.ARROW, "Expected '->' before result type")
+        result: Type = self.type_expr()
+
+        return FunctionType(
+            location=l_paren.location_to(self.previous()),
+            pos_args=pos_args,
+            args=args,
+            kw_args=kw_args,
+            returns=result,
+        )

tests/cases/generator/01_simple_types.py.ref.txt

@@ -9,13 +9,13 @@ Module(
       level=0),
     Assign(
       targets=[
-        Name(id='__midas_a0__')],
+        Name(id='__midas_alias_0__')],
       value=Constant(value=123.45)),
     Assert(
       test=Call(
         func=Name(id='isinstance'),
         args=[
-          Name(id='__midas_a0__'),
+          Name(id='__midas_alias_0__'),
           Name(id='float')],
         keywords=[]),
       msg=JoinedStr(
@@ -26,7 +26,7 @@ Module(
               value=Call(
                 func=Name(id='type'),
                 args=[
-                  Name(id='__midas_a0__')],
+                  Name(id='__midas_alias_0__')],
                 keywords=[]),
               attr='__name__'),
             conversion=-1),
@@ -34,19 +34,19 @@ Module(
     Assign(
       targets=[
         Name(id='distance')],
-      value=Name(id='__midas_a0__')),
+      value=Name(id='__midas_alias_0__')),
     Delete(
       targets=[
-        Name(id='__midas_a0__')]),
+        Name(id='__midas_alias_0__')]),
     Assign(
       targets=[
-        Name(id='__midas_a1__')],
+        Name(id='__midas_alias_1__')],
       value=Constant(value=6.7)),
     Assert(
       test=Call(
         func=Name(id='isinstance'),
         args=[
-          Name(id='__midas_a1__'),
+          Name(id='__midas_alias_1__'),
           Name(id='float')],
         keywords=[]),
       msg=JoinedStr(
@@ -57,7 +57,7 @@ Module(
               value=Call(
                 func=Name(id='type'),
                 args=[
-                  Name(id='__midas_a1__')],
+                  Name(id='__midas_alias_1__')],
                 keywords=[]),
               attr='__name__'),
             conversion=-1),
@@ -65,10 +65,10 @@ Module(
     Assign(
       targets=[
         Name(id='time')],
-      value=Name(id='__midas_a1__')),
+      value=Name(id='__midas_alias_1__')),
     Delete(
       targets=[
-        Name(id='__midas_a1__')]),
+        Name(id='__midas_alias_1__')]),
     Assign(
       targets=[
         Name(id='speed')],

tests/cases/midas-parser/01_simple_types.midas.ref.json

@@ -2582,21 +2582,18 @@
           "name": "__sub__",
           "type": {
             "_type": "FunctionType",
-            "params": {
-              "_type": "ParamSpec",
-              "pos": [
-                {
-                  "name": null,
-                  "type": {
-                    "_type": "NamedType",
-                    "name": "GeoLocation"
-                  },
-                  "required": true
-                }
-              ],
-              "mixed": [],
-              "kw": []
-            },
+            "pos_args": [
+              {
+                "name": null,
+                "type": {
+                  "_type": "NamedType",
+                  "name": "GeoLocation"
+                },
+                "required": true
+              }
+            ],
+            "args": [],
+            "kw_args": [],
             "returns": {
               "_type": "GenericType",
               "type": {
@@ -2676,21 +2673,18 @@
           "name": "__sub__",
           "type": {
             "_type": "FunctionType",
-            "params": {
-              "_type": "ParamSpec",
-              "pos": [
-                {
-                  "name": null,
-                  "type": {
-                    "_type": "NamedType",
-                    "name": "Latitude"
-                  },
-                  "required": true
-                }
-              ],
-              "mixed": [],
-              "kw": []
-            },
+            "pos_args": [
+              {
+                "name": null,
+                "type": {
+                  "_type": "NamedType",
+                  "name": "Latitude"
+                },
+                "required": true
+              }
+            ],
+            "args": [],
+            "kw_args": [],
             "returns": {
               "_type": "GenericType",
               "type": {
@@ -2719,21 +2713,18 @@
           "name": "__sub__",
           "type": {
             "_type": "FunctionType",
-            "params": {
-              "_type": "ParamSpec",
-              "pos": [
-                {
-                  "name": null,
-                  "type": {
-                    "_type": "NamedType",
-                    "name": "Longitude"
-                  },
-                  "required": true
-                }
-              ],
-              "mixed": [],
-              "kw": []
-            },
+            "pos_args": [
+              {
+                "name": null,
+                "type": {
+                  "_type": "NamedType",
+                  "name": "Longitude"
+                },
+                "required": true
+              }
+            ],
+            "args": [],
+            "kw_args": [],
             "returns": {
               "_type": "GenericType",
               "type": {
@@ -2754,24 +2745,12 @@
     {
       "_type": "PredicateStmt",
       "name": "Positive",
-      "params": [
-        {
-          "_type": "ParamSpec",
-          "pos": [],
-          "mixed": [
-            {
-              "name": "v",
-              "type": {
-                "_type": "NamedType",
-                "name": "float"
-              },
-              "required": true
-            }
-          ],
-          "kw": []
-        }
-      ],
-      "body": {
+      "subject": "v",
+      "type": {
+        "_type": "NamedType",
+        "name": "float"
+      },
+      "condition": {
         "_type": "BinaryExpr",
         "left": {
           "_type": "VariableExpr",
@@ -2787,24 +2766,12 @@
     {
       "_type": "PredicateStmt",
       "name": "StrictlyPositive",
-      "params": [
-        {
-          "_type": "ParamSpec",
-          "pos": [],
-          "mixed": [
-            {
-              "name": "v",
-              "type": {
-                "_type": "NamedType",
-                "name": "float"
-              },
-              "required": true
-            }
-          ],
-          "kw": []
-        }
-      ],
-      "body": {
+      "subject": "v",
+      "type": {
+        "_type": "NamedType",
+        "name": "float"
+      },
+      "condition": {
         "_type": "BinaryExpr",
         "left": {
           "_type": "VariableExpr",
@@ -2820,24 +2787,12 @@
     {
       "_type": "PredicateStmt",
       "name": "Equatorial",
-      "params": [
-        {
-          "_type": "ParamSpec",
-          "pos": [],
-          "mixed": [
-            {
-              "name": "loc",
-              "type": {
-                "_type": "NamedType",
-                "name": "GeoLocation"
-              },
-              "required": true
-            }
-          ],
-          "kw": []
-        }
-      ],
-      "body": {
+      "subject": "loc",
+      "type": {
+        "_type": "NamedType",
+        "name": "GeoLocation"
+      },
+      "condition": {
         "_type": "GroupingExpr",
         "expr": {
           "_type": "BinaryExpr",
@@ -2872,24 +2827,12 @@
     {
       "_type": "PredicateStmt",
       "name": "Arctic",
-      "params": [
-        {
-          "_type": "ParamSpec",
-          "pos": [],
-          "mixed": [
-            {
-              "name": "loc",
-              "type": {
-                "_type": "NamedType",
-                "name": "GeoLocation"
-              },
-              "required": true
-            }
-          ],
-          "kw": []
-        }
-      ],
-      "body": {
+      "subject": "loc",
+      "type": {
+        "_type": "NamedType",
+        "name": "GeoLocation"
+      },
+      "condition": {
         "_type": "GroupingExpr",
         "expr": {
           "_type": "BinaryExpr",

tests/generator.py

@@ -45,7 +45,7 @@ class GeneratorTester(Tester):
         typed_ast: TypedAST = checker.type_check(path)
 
         if not any(d.type == DiagnosticType.ERROR for d in checker.diagnostics):
-            generator = Generator(workdir=path.parent, types=checker.types)
+            generator = Generator(workdir=path.parent)
             result.compiled_ast = generator.generate_ast(typed_ast, path)
 
         return result

tests/serializer/midas.py

@@ -2,7 +2,6 @@ from typing import Optional, Sequence
 
 from midas.ast.midas import (
     BinaryExpr,
-    CallExpr,
     ComplexType,
     ConstraintType,
     Expr,
@@ -16,7 +15,6 @@ from midas.ast.midas import (
     LogicalExpr,
     MemberStmt,
     NamedType,
-    ParamSpec,
     PredicateStmt,
     Stmt,
     Type,
@@ -80,8 +78,9 @@ class MidasAstJsonSerializer(
         return {
             "_type": "PredicateStmt",
             "name": stmt.name.lexeme,
-            "params": [self._serialize_param_spec(spec) for spec in stmt.params],
-            "body": stmt.body.accept(self),
+            "subject": stmt.subject.lexeme,
+            "type": stmt.type.accept(self),
+            "condition": stmt.condition.accept(self),
         }
 
     def visit_logical_expr(self, expr: LogicalExpr) -> dict:
@@ -107,14 +106,6 @@ class MidasAstJsonSerializer(
             "right": expr.right.accept(self),
         }
 
-    def visit_call_expr(self, expr: CallExpr) -> dict:
-        return {
-            "_type": "CallExpr",
-            "callee": expr.callee.accept(self),
-            "arguments": self._serialize_list(expr.arguments),
-            "keywords": {name: arg.accept(self) for name, arg in expr.keywords.items()},
-        }
-
     def visit_get_expr(self, expr: GetExpr) -> dict:
         return {
             "_type": "GetExpr",
@@ -172,21 +163,15 @@ class MidasAstJsonSerializer(
     def visit_function_type(self, type: FunctionType) -> dict:
         return {
             "_type": "FunctionType",
-            "params": self._serialize_param_spec(type.params),
+            "pos_args": [self._serialize_func_arg(arg) for arg in type.pos_args],
+            "args": [self._serialize_func_arg(arg) for arg in type.args],
+            "kw_args": [self._serialize_func_arg(arg) for arg in type.kw_args],
             "returns": type.returns.accept(self),
         }
 
-    def _serialize_param_spec(self, spec: ParamSpec) -> dict:
-        return {
-            "_type": "ParamSpec",
-            "pos": [self._serialize_func_arg(arg) for arg in spec.pos],
-            "mixed": [self._serialize_func_arg(arg) for arg in spec.mixed],
-            "kw": [self._serialize_func_arg(arg) for arg in spec.kw],
-        }
-
     def _serialize_func_arg(self, arg: FunctionType.Argument) -> dict:
         return {
-            "name": arg.name.lexeme if arg.name is not None else None,
+            "name": arg.name,
             "type": arg.type.accept(self),
             "required": arg.required,
         }