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 enum import Enum, auto
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]


class MemberKind(Enum):
    PROPERTY = auto()
    METHOD = auto()


##############
# 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_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
    kind: MemberKind

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


@dataclass(frozen=True)
class ExtendStmt(Stmt):
    name: Token
    params: list[TypeParam]
    members: list[MemberStmt]

    def accept(self, visitor: Stmt.Visitor[T]) -> T:
        return visitor.visit_extend_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]
    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)