midas/midas/ast/midas.py

"""
This file was generated by a script. Any manual changes might be overwritten.
Please modify gen/midas.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 midas.ast.location import Location
from midas.lexer.token import Token

T = TypeVar("T")

@dataclass(frozen=True, kw_only=True)
class TypeParam:
    location: Location
    name: Token
    bound: Optional[Type]


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


@dataclass(frozen=True, kw_only=True)
class Stmt(ABC):
    location: Location

    @abstractmethod
    def accept(self, visitor: Visitor[T]) -> T: ...

    class Visitor(ABC, Generic[T]):
        @abstractmethod
        def visit_type_stmt(self, stmt: TypeStmt) -> T: ...

        @abstractmethod
        def visit_member_stmt(self, stmt: MemberStmt) -> 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 TypeStmt(Stmt):
    name: Token
    params: list[TypeParam]
    type: Type

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


@dataclass(frozen=True)
class MemberStmt(Stmt):
    name: Token
    type: Type

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


@dataclass(frozen=True)
class ExtendStmt(Stmt):
    params: list[TypeParam]
    type: Type
    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: Type
    result: Type

    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: Type
    condition: Expr

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


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


@dataclass(frozen=True, kw_only=True)
class Expr(ABC):
    location: Location

    @abstractmethod
    def accept(self, visitor: Visitor[T]) -> T: ...

    class Visitor(ABC, Generic[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: ...


@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)


#########
# Types #
#########


@dataclass(frozen=True, kw_only=True)
class Type(ABC):
    location: Location

    @abstractmethod
    def accept(self, visitor: Visitor[T]) -> T: ...

    class Visitor(ABC, Generic[T]):
        @abstractmethod
        def visit_named_type(self, type: NamedType) -> T: ...

        @abstractmethod
        def visit_generic_type(self, type: GenericType) -> T: ...

        @abstractmethod
        def visit_constraint_type(self, type: ConstraintType) -> T: ...

        @abstractmethod
        def visit_complex_type(self, type: ComplexType) -> T: ...

        @abstractmethod
        def visit_extension_type(self, type: ExtensionType) -> T: ...

        @abstractmethod
        def visit_function_type(self, type: FunctionType) -> T: ...


@dataclass(frozen=True)
class NamedType(Type):
    name: Token

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


@dataclass(frozen=True)
class GenericType(Type):
    type: Type
    args: list[Type]

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


@dataclass(frozen=True)
class ConstraintType(Type):
    type: Type
    constraint: Expr

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


@dataclass(frozen=True)
class ComplexType(Type):
    members: list[MemberStmt]

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


@dataclass(frozen=True)
class ExtensionType(Type):
    base: Type
    extension: ComplexType

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


@dataclass(frozen=True)
class FunctionType(Type):
    pos_args: list[Argument]
    kw_args: list[Argument]
    returns: Type

    @dataclass(frozen=True, kw_only=True)
    class Argument:
        location: Optional[Location] = None
        name: Optional[Token]
        type: Type
        required: bool

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