endorphin-aster-vm/crates/frontend/src/ast/generated.rs

// Generated by scripts/generate_ast.py from Endor.asdl. Do not edit.

use super::Spanned;
use crate::Span;
pub const AST_SCHEMA_ID: &str =
    "urn:endor:ast:sha256:21b0349ac295d9bc8cedcad8f07d8e2d45cf220e19e7c2fad10269555fcfd71a";
#[derive(Debug, Clone, PartialEq, Eq, serde::Serialize, serde::Deserialize)]
#[serde(deny_unknown_fields)]
pub struct AstDocument {
    pub schema: String,
    pub root: AstRoot,
}
#[derive(Debug, Clone, PartialEq, Eq, serde::Serialize, serde::Deserialize)]
#[serde(tag = "kind", content = "data", deny_unknown_fields)]
pub enum AstRoot {
    Module(Program),
    Expression(Expr),
    Interactive(InteractiveInput),
}
impl Spanned for AstRoot {
    fn span(&self) -> Span {
        match self {
            Self::Module(node) => node.span(),
            Self::Expression(node) => node.span(),
            Self::Interactive(node) => node.span(),
        }
    }
}
#[derive(Debug, Clone, PartialEq, Eq, serde::Serialize, serde::Deserialize)]
#[serde(deny_unknown_fields)]
pub struct Name {
    pub text: String,
    pub span: Span,
}
impl Spanned for Name {
    fn span(&self) -> Span {
        self.span
    }
}
#[derive(Debug, Clone, PartialEq, Eq, serde::Serialize, serde::Deserialize)]
#[serde(deny_unknown_fields)]
pub struct Program {
    pub declarations: Vec<Decl>,
    pub span: Span,
}
impl Spanned for Program {
    fn span(&self) -> Span {
        self.span
    }
}
#[derive(Debug, Clone, PartialEq, Eq, serde::Serialize, serde::Deserialize)]
#[serde(deny_unknown_fields)]
pub struct Decl {
    pub kind: DeclKind,
    pub span: Span,
}
impl Spanned for Decl {
    fn span(&self) -> Span {
        self.span
    }
}
#[derive(Debug, Clone, PartialEq, Eq, serde::Serialize, serde::Deserialize)]
#[serde(tag = "kind", content = "data", deny_unknown_fields)]
pub enum DeclKind {
    Function(Function),
    Class(Class),
}
impl Spanned for DeclKind {
    fn span(&self) -> Span {
        match self {
            Self::Function(node) => node.span(),
            Self::Class(node) => node.span(),
        }
    }
}
#[derive(Debug, Clone, PartialEq, Eq, serde::Serialize, serde::Deserialize)]
#[serde(deny_unknown_fields)]
pub struct Class {
    pub name: Name,
    pub base: Option<Name>,
    pub fields: Vec<Parameter>,
    pub methods: Vec<Function>,
    pub span: Span,
}
impl Spanned for Class {
    fn span(&self) -> Span {
        self.span
    }
}
#[derive(Debug, Clone, PartialEq, Eq, serde::Serialize, serde::Deserialize)]
#[serde(deny_unknown_fields)]
pub struct Function {
    pub name: Name,
    pub parameters: Vec<Parameter>,
    pub return_type: Name,
    pub body: Block,
    pub span: Span,
}
impl Spanned for Function {
    fn span(&self) -> Span {
        self.span
    }
}
#[derive(Debug, Clone, PartialEq, Eq, serde::Serialize, serde::Deserialize)]
#[serde(deny_unknown_fields)]
pub struct Parameter {
    pub name: Name,
    pub type_name: Name,
    pub span: Span,
}
impl Spanned for Parameter {
    fn span(&self) -> Span {
        self.span
    }
}
#[derive(Debug, Clone, PartialEq, Eq, serde::Serialize, serde::Deserialize)]
#[serde(deny_unknown_fields)]
pub struct Block {
    pub statements: Vec<Stmt>,
    pub span: Span,
}
impl Spanned for Block {
    fn span(&self) -> Span {
        self.span
    }
}
#[derive(Debug, Clone, PartialEq, Eq, serde::Serialize, serde::Deserialize)]
#[serde(deny_unknown_fields)]
pub struct Stmt {
    pub kind: StmtKind,
    pub span: Span,
}
impl Spanned for Stmt {
    fn span(&self) -> Span {
        self.span
    }
}
#[derive(Debug, Clone, PartialEq, Eq, serde::Serialize, serde::Deserialize)]
#[serde(tag = "kind", content = "data", deny_unknown_fields)]
pub enum StmtKind {
    Binding(Binding),
    Assignment(Assignment),
    MemberAssignment(MemberAssignment),
    If(IfStatement),
    While(WhileStatement),
    Return(ReturnStatement),
    Expression(Expr),
    Declaration(Decl),
}
impl Spanned for StmtKind {
    fn span(&self) -> Span {
        match self {
            Self::Binding(node) => node.span(),
            Self::Assignment(node) => node.span(),
            Self::MemberAssignment(node) => node.span(),
            Self::If(node) => node.span(),
            Self::While(node) => node.span(),
            Self::Return(node) => node.span(),
            Self::Expression(node) => node.span(),
            Self::Declaration(node) => node.span(),
        }
    }
}
#[derive(Debug, Clone, PartialEq, Eq, serde::Serialize, serde::Deserialize)]
#[serde(deny_unknown_fields)]
pub struct Binding {
    pub name: Name,
    pub value: Expr,
    pub span: Span,
}
impl Spanned for Binding {
    fn span(&self) -> Span {
        self.span
    }
}
#[derive(Debug, Clone, PartialEq, Eq, serde::Serialize, serde::Deserialize)]
#[serde(deny_unknown_fields)]
pub struct Assignment {
    pub name: Name,
    pub value: Expr,
    pub span: Span,
}
impl Spanned for Assignment {
    fn span(&self) -> Span {
        self.span
    }
}
#[derive(Debug, Clone, PartialEq, Eq, serde::Serialize, serde::Deserialize)]
#[serde(deny_unknown_fields)]
pub struct MemberAssignment {
    pub object: Expr,
    pub name: Name,
    pub value: Expr,
    pub span: Span,
}
impl Spanned for MemberAssignment {
    fn span(&self) -> Span {
        self.span
    }
}
#[derive(Debug, Clone, PartialEq, Eq, serde::Serialize, serde::Deserialize)]
#[serde(deny_unknown_fields)]
pub struct IfStatement {
    pub condition: Expr,
    pub body: Block,
    pub otherwise: Option<Block>,
    pub span: Span,
}
impl Spanned for IfStatement {
    fn span(&self) -> Span {
        self.span
    }
}
#[derive(Debug, Clone, PartialEq, Eq, serde::Serialize, serde::Deserialize)]
#[serde(deny_unknown_fields)]
pub struct WhileStatement {
    pub condition: Expr,
    pub body: Block,
    pub span: Span,
}
impl Spanned for WhileStatement {
    fn span(&self) -> Span {
        self.span
    }
}
#[derive(Debug, Clone, PartialEq, Eq, serde::Serialize, serde::Deserialize)]
#[serde(deny_unknown_fields)]
pub struct ReturnStatement {
    pub value: Option<Expr>,
    pub span: Span,
}
impl Spanned for ReturnStatement {
    fn span(&self) -> Span {
        self.span
    }
}
#[derive(Debug, Clone, PartialEq, Eq, serde::Serialize, serde::Deserialize)]
#[serde(deny_unknown_fields)]
pub struct InteractiveInput {
    pub statements: Vec<Stmt>,
    pub span: Span,
}
impl Spanned for InteractiveInput {
    fn span(&self) -> Span {
        self.span
    }
}
#[derive(Debug, Clone, PartialEq, Eq, serde::Serialize, serde::Deserialize)]
#[serde(deny_unknown_fields)]
pub struct Expr {
    pub kind: ExprKind,
    pub span: Span,
}
impl Spanned for Expr {
    fn span(&self) -> Span {
        self.span
    }
}
#[derive(Debug, Clone, PartialEq, Eq, serde::Serialize, serde::Deserialize)]
#[serde(tag = "kind", content = "data", deny_unknown_fields)]
pub enum ExprKind {
    Name(String),
    Number(String),
    String(String),
    Symbol(Name),
    Await(Box<Expr>),
    Unary {
        operation: UnaryOp,
        operand: Box<Expr>,
    },
    Binary {
        operation: BinaryOp,
        left: Box<Expr>,
        right: Box<Expr>,
    },
    Member {
        object: Box<Expr>,
        name: Name,
    },
    Call {
        callee: Box<Expr>,
        arguments: Vec<Expr>,
    },
}
#[derive(Debug, Clone, PartialEq, Eq, serde::Serialize, serde::Deserialize, Copy)]
pub enum UnaryOp {
    Negate,
}
#[derive(Debug, Clone, PartialEq, Eq, serde::Serialize, serde::Deserialize, Copy)]
pub enum BinaryOp {
    Add,
    Subtract,
    Multiply,
    Divide,
    Equal,
    NotEqual,
    Less,
    LessEqual,
    Greater,
    GreaterEqual,
}