midas/core/ast/midas.py

"""
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
from dataclasses import dataclass
from typing import Any, Generic, Optional, TypeVar

from lexer.token import Token

T = TypeVar("T")

##############
# Statements #
##############


@dataclass(frozen=True)
class Stmt(ABC):
    @abstractmethod
    def accept(self, visitor: Visitor[T]) -> T: ...

    class Visitor(ABC, Generic[T]):
        @abstractmethod
        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_predicate_stmt(self, stmt: PredicateStmt) -> T: ...


@dataclass(frozen=True)
class SimpleTypeStmt(Stmt):
    name: Token
    template: Optional[TemplateExpr]
    base: TypeExpr
    constraint: Optional[Expr]

    def accept(self, visitor: Stmt.Visitor[T]) -> T:
        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)
class PropertyStmt(Stmt):
    name: Token
    type: TypeExpr
    constraint: Optional[Expr]

    def accept(self, visitor: Stmt.Visitor[T]) -> T:
        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):
    name: Token
    operand: TypeExpr
    result: TypeExpr

    def accept(self, visitor: Stmt.Visitor[T]) -> T:
        return visitor.visit_op_stmt(self)


@dataclass(frozen=True)
class PredicateStmt(Stmt):
    name: Token
    subject: Token
    type: TypeExpr
    condition: Expr

    def accept(self, visitor: Stmt.Visitor[T]) -> T:
        return visitor.visit_predicate_stmt(self)


###############
# Expressions #
###############


@dataclass(frozen=True)
class Expr(ABC):
    @abstractmethod
    def accept(self, visitor: Visitor[T]) -> T: ...

    class Visitor(ABC, Generic[T]):
        @abstractmethod
        def visit_simple_type_expr(self, expr: SimpleTypeExpr) -> T: ...

        @abstractmethod
        def visit_logical_expr(self, expr: LogicalExpr) -> T: ...

        @abstractmethod
        def visit_binary_expr(self, expr: BinaryExpr) -> T: ...

        @abstractmethod
        def visit_unary_expr(self, expr: UnaryExpr) -> T: ...

        @abstractmethod
        def visit_get_expr(self, expr: GetExpr) -> T: ...

        @abstractmethod
        def visit_variable_expr(self, expr: VariableExpr) -> T: ...

        @abstractmethod
        def visit_grouping_expr(self, expr: GroupingExpr) -> 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: ...


@dataclass(frozen=True)
class SimpleTypeExpr(Expr):
    name: Token
    optional: bool

    def accept(self, visitor: Expr.Visitor[T]) -> T:
        return visitor.visit_simple_type_expr(self)


@dataclass(frozen=True)
class LogicalExpr(Expr):
    left: Expr
    operator: Token
    right: Expr

    def accept(self, visitor: Expr.Visitor[T]) -> T:
        return visitor.visit_logical_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)
class GetExpr(Expr):
    expr: Expr
    name: Token

    def accept(self, visitor: Expr.Visitor[T]) -> T:
        return visitor.visit_get_expr(self)


@dataclass(frozen=True)
class VariableExpr(Expr):
    name: Token

    def accept(self, visitor: Expr.Visitor[T]) -> T:
        return visitor.visit_variable_expr(self)


@dataclass(frozen=True)
class GroupingExpr(Expr):
    expr: Expr

    def accept(self, visitor: Expr.Visitor[T]) -> T:
        return visitor.visit_grouping_expr(self)


@dataclass(frozen=True)
class LiteralExpr(Expr):
    value: Any

    def accept(self, visitor: Expr.Visitor[T]) -> T:
        return visitor.visit_literal_expr(self)


@dataclass(frozen=True)
class WildcardExpr(Expr):
    token: Token

    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
    template: Optional[TemplateExpr]
    optional: bool

    def accept(self, visitor: Expr.Visitor[T]) -> T:
        return visitor.visit_type_expr(self)