feat(parser)!: adjust AST node classes for new syntax

core/ast/midas.py

@@ -1,3 +1,8 @@
+"""
+This file was generated by a script. Any manual changes might be overwritten.
+Please modify gen/ast.py instead and run gen/gen.py
+"""
+
 from __future__ import annotations
 
 from abc import ABC, abstractmethod
@@ -8,8 +13,9 @@ from lexer.token import Token
 
 T = TypeVar("T")
 
-
+##############
-# Statements
+# Statements #
+##############
 
 
 @dataclass(frozen=True)
@@ -19,26 +25,43 @@ class Stmt(ABC):
 
     class Visitor(ABC, Generic[T]):
         @abstractmethod
-        def visit_type_stmt(self, stmt: TypeStmt) -> T: ...
+        def visit_simple_type_stmt(self, stmt: SimpleTypeStmt) -> T: ...
+
+        @abstractmethod
+        def visit_complex_type_stmt(self, stmt: ComplexTypeStmt) -> T: ...
 
         @abstractmethod
         def visit_property_stmt(self, stmt: PropertyStmt) -> T: ...
 
+        @abstractmethod
+        def visit_extend_stmt(self, stmt: ExtendStmt) -> T: ...
+
         @abstractmethod
         def visit_op_stmt(self, stmt: OpStmt) -> T: ...
 
         @abstractmethod
-        def visit_constraint_stmt(self, stmt: ConstraintStmt) -> T: ...
+        def visit_predicate_stmt(self, stmt: PredicateStmt) -> T: ...
 
 
 @dataclass(frozen=True)
-class TypeStmt(Stmt):
+class SimpleTypeStmt(Stmt):
     name: Token
-    bases: list[TypeExpr]
+    template: Optional[TemplateExpr]
-    body: Optional[TypeBodyExpr]
+    base: SimpleTypeExpr
+    constraint: Optional[Expr]
 
     def accept(self, visitor: Stmt.Visitor[T]) -> T:
-        return visitor.visit_type_stmt(self)
+        return visitor.visit_simple_type_stmt(self)
+
+
+@dataclass(frozen=True)
+class ComplexTypeStmt(Stmt):
+    name: Token
+    template: Optional[TemplateExpr]
+    properties: list[PropertyStmt]
+
+    def accept(self, visitor: Stmt.Visitor[T]) -> T:
+        return visitor.visit_complex_type_stmt(self)
 
 
 @dataclass(frozen=True)
@@ -50,11 +73,19 @@ class PropertyStmt(Stmt):
         return visitor.visit_property_stmt(self)
 
 
+@dataclass(frozen=True)
+class ExtendStmt(Stmt):
+    type: TypeExpr
+    operations: list[OpStmt]
+
+    def accept(self, visitor: Stmt.Visitor[T]) -> T:
+        return visitor.visit_extend_stmt(self)
+
+
 @dataclass(frozen=True)
 class OpStmt(Stmt):
-    left: TypeExpr
+    name: Token
-    op: Token
+    operand: TypeExpr
-    right: TypeExpr
     result: TypeExpr
 
     def accept(self, visitor: Stmt.Visitor[T]) -> T:
@@ -62,15 +93,19 @@ class OpStmt(Stmt):
 
 
 @dataclass(frozen=True)
-class ConstraintStmt(Stmt):
+class PredicateStmt(Stmt):
     name: Token
-    constraint: ConstraintExpr
+    subject: Token
+    type: TypeExpr
+    condition: Expr
 
     def accept(self, visitor: Stmt.Visitor[T]) -> T:
-        return visitor.visit_constraint_stmt(self)
+        return visitor.visit_predicate_stmt(self)
 
 
-# Expressions
+###############
+# Expressions #
+###############
 
 
 @dataclass(frozen=True)
@@ -80,27 +115,53 @@ class Expr(ABC):
 
     class Visitor(ABC, Generic[T]):
         @abstractmethod
-        def visit_wildcard_expr(self, expr: WildcardExpr) -> T: ...
+        def visit_simple_type_expr(self, expr: SimpleTypeExpr) -> T: ...
+
+        @abstractmethod
+        def visit_binary_expr(self, expr: BinaryExpr) -> T: ...
+
+        @abstractmethod
+        def visit_unary_expr(self, expr: UnaryExpr) -> T: ...
 
         @abstractmethod
         def visit_literal_expr(self, expr: LiteralExpr) -> T: ...
 
+        @abstractmethod
+        def visit_wildcard_expr(self, expr: WildcardExpr) -> T: ...
+
+        @abstractmethod
+        def visit_template_expr(self, expr: TemplateExpr) -> T: ...
+
         @abstractmethod
         def visit_type_expr(self, expr: TypeExpr) -> T: ...
 
-        @abstractmethod
-        def visit_constraint_expr(self, expr: ConstraintExpr) -> T: ...
-
-        @abstractmethod
-        def visit_type_body_expr(self, expr: TypeBodyExpr) -> T: ...
-
 
 @dataclass(frozen=True)
-class WildcardExpr(Expr):
+class SimpleTypeExpr(Expr):
-    token: Token
+    name: Token
+    optional: bool
 
     def accept(self, visitor: Expr.Visitor[T]) -> T:
-        return visitor.visit_wildcard_expr(self)
+        return visitor.visit_simple_type_expr(self)
+
+
+@dataclass(frozen=True)
+class BinaryExpr(Expr):
+    left: Expr
+    operator: Token
+    right: Expr
+
+    def accept(self, visitor: Expr.Visitor[T]) -> T:
+        return visitor.visit_binary_expr(self)
+
+
+@dataclass(frozen=True)
+class UnaryExpr(Expr):
+    operator: Token
+    right: Expr
+
+    def accept(self, visitor: Expr.Visitor[T]) -> T:
+        return visitor.visit_unary_expr(self)
 
 
 @dataclass(frozen=True)
@@ -111,28 +172,27 @@ class LiteralExpr(Expr):
         return visitor.visit_literal_expr(self)
 
 
+@dataclass(frozen=True)
+class WildcardExpr(Expr):
+    pass
+
+    def accept(self, visitor: Expr.Visitor[T]) -> T:
+        return visitor.visit_wildcard_expr(self)
+
+
+@dataclass(frozen=True)
+class TemplateExpr(Expr):
+    type: TypeExpr
+
+    def accept(self, visitor: Expr.Visitor[T]) -> T:
+        return visitor.visit_template_expr(self)
+
+
 @dataclass(frozen=True)
 class TypeExpr(Expr):
     name: Token
-    constraints: list[ConstraintExpr]
+    template: Optional[TemplateExpr]
+    optional: bool
 
     def accept(self, visitor: Expr.Visitor[T]) -> T:
         return visitor.visit_type_expr(self)
-
-
-@dataclass(frozen=True)
-class ConstraintExpr(Expr):
-    left: Expr
-    op: Token
-    right: Expr
-
-    def accept(self, visitor: Expr.Visitor[T]) -> T:
-        return visitor.visit_constraint_expr(self)
-
-
-@dataclass(frozen=True)
-class TypeBodyExpr(Expr):
-    properties: list[PropertyStmt]
-
-    def accept(self, visitor: Expr.Visitor[T]) -> T:
-        return visitor.visit_type_body_expr(self)

gen/ast.py

@@ -0,0 +1,56 @@
+class SimpleTypeStmt:
+    name: Token
+    template: Optional[TemplateExpr]
+    base: SimpleTypeExpr
+    constraint: Optional[Expr]
+
+class SimpleTypeExpr:
+    name: Token
+    optional: bool
+
+class BinaryExpr:
+    left: Expr
+    operator: Token
+    right: Expr
+
+class UnaryExpr:
+    operator: Token
+    right: Expr
+
+class LiteralExpr:
+    value: Any
+
+class WildcardExpr:
+    pass
+
+class TemplateExpr:
+    type: TypeExpr
+
+class TypeExpr:
+    name: Token
+    template: Optional[TemplateExpr]
+    optional: bool
+
+class ComplexTypeStmt:
+    name: Token
+    template: Optional[TemplateExpr]
+    properties: list[PropertyStmt]
+
+class PropertyStmt:
+    name: Token
+    type: TypeExpr
+
+class ExtendStmt:
+    type: TypeExpr
+    operations: list[OpStmt]
+
+class OpStmt:
+    name: Token
+    operand: TypeExpr
+    result: TypeExpr
+
+class PredicateStmt:
+    name: Token
+    subject: Token
+    type: TypeExpr
+    condition: Expr