deimos-lang/src/parser/ast.yaml

# $schema: ./ast.schema.yaml
# Operators
Operator:
  leaf_enum:
    rules:
      - Or
      - And
      - EqualTo
      - NotEqualTo
      - Greater
      - Less
      - GreaterEqual
      - LessEqual
      - Add
      - Subtract
      - Multiply
      - Divide
      - Modulo
      - LeftShift
      - RightShift
      - Spread
      - Star
      - Not
      - Negative
      - PlusPlus
      - MinusMinus
      - CallOp
      - Index

# Names
Identifier:
  leaf_struct:
    members:
      - name:
          kind: string
      - file_id:
          kind: file_id
      - range:
          kind: range
    derive:
      - Clone
      - PartialEq
      - Eq
      - Hash
FullyQualifiedName:
  struct:
    children:
      - identifiers:
          vec:
            rule: Identifier

# Lists
TypeUseList:
  struct:
    children:
      - type_uses:
          vec:
            rule: TypeUse
IdentifierList:
  struct:
    children:
      - identifiers:
          vec:
            rule: Identifier
ParenthesesOptionalTypeUseList:
  struct:
    children:
      - type_use_list:
          member:
            optional: true

# Type Use
TypeUse:
  tree_enum:
    rules:
      - PrimitiveType
      - InterfaceOrClassTypeUse
      - TupleTypeUse
      - FunctionTypeUse
PrimitiveType:
  leaf_enum:
    rules:
      - Byte
      - Short
      - Char
      - Int
      - Long
      - Double
      - Bool
      - String
      - TypedArray
      - Any
      - Void
TypedArray:
  struct:
    children:
      - array_kw:
          skip:
            rule: Array
      - generic_arguments
InterfaceOrClassTypeUse:
  struct:
    children:
      - fully_qualified_name
      - generic_arguments:
          member:
            rule: GenericArguments
            build:
              node:
                or_else_default: true
TupleTypeUse:
  struct:
    children:
      - tuple_arguments
FunctionTypeUse:
  struct:
    children:
      - fn_kw:
          skip:
            rule: Fn
      - generic_parameters:
          member:
            rule: GenericParameters
            build:
              node:
                or_else_default: true
      - parameters:
          member:
            rule: Parameters
            build:
              node:
                or_else_default: true
      - return_type

# Generic Arguments
GenericArguments:
  struct:
    children:
      - type_use_list

# Generic Parameters
GenericParameters:
  struct:
    children:
      - identifier_list

# Tuple Arguments
TupleArguments:
  struct:
    children:
      - parentheses_optional_type_use_list

# Implements List
ImplementsList:
  struct:
    children:
      - type_uses:
          vec:
            rule: TypeUse

# Parameters
Parameters:
  struct:
    children:
      - parameters:
          vec:
            rule: Parameter
Parameter:
  struct:
    children:
      - identifier
      - type_use

# Return Type
ReturnType:
  struct:
    children:
      - type_use

# Top-level constructs
CompilationUnit:
  struct:
    children:
      - parent_mod:
          member:
            optional: true
      - use_statements:
          vec:
            rule: UseStatement
      - module_level_declarations:
          vec:
            rule: ModuleLevelDeclaration
      - eoi:
          skip:
            rule: EOI
ParentMod:
  struct:
    children:
      - mod_kw:
          skip:
            rule: Mod
      - fqn:
          member:
            rule: FullyQualifiedName
UseStatement:
  struct:
    children:
      - use_kw:
          skip:
            rule: Use
      - prefixes:
          vec:
            rule: UseStatementPrefix
      - suffix:
          member:
            rule: UseStatementSuffix
      - file_id:
          member: 
            build:
              special:
                kind: file_id
      - range:
          member: 
            build:
              special:
                kind: range
UseStatementPrefix:
  struct:
    children:
      - identifier
UseStatementSuffix:
  tree_enum:
    rules:
      - Identifier
      - Star:
          child: false
      - UseList
UseList:
  struct:
    children:
      - identifiers:
          vec:
            rule: Identifier

# Level declarations
ModuleLevelDeclaration:
  tree_enum:
    rules:
      - Module
      - Interface
      - Class
      - Function
      - PlatformFunction
InterfaceLevelDeclaration:
  tree_enum:
    rules:
      - CompanionModule
      - Interface
      - Class
      - InterfaceFunction
      - InterfaceDefaultFunction
      - InterfaceOperatorFunction
      - InterfaceDefaultOperatorFunction
ClassLevelDeclaration:
  tree_enum:
    rules:
      - CompanionModule
      - Interface
      - Class
      - Function
      - OperatorFunction
      - PlatformFunction

# Main organizational constructs
Module:
  struct:
    children:
      - is_public:
          member:
            rule: Pub
            build:
              boolean:
                on: rule_present
      - mod_kw:
          skip:
            rule: Mod
      - identifier
      - declarations:
          vec:
            rule: ModuleLevelDeclaration
      - end_kw:
          skip:
            rule: End
CompanionModule:
  struct:
    children:
      - companion_kw:
          skip:
            rule: Companion
      - mod_kw:
          skip:
            rule: Mod
      - declarations:
          vec:
            rule: ModuleLevelDeclaration
      - end_kw:
          skip:
            rule: End
Interface:
  struct:
    children:
      - is_public:
          member:
            rule: Pub
            build:
              boolean:
                on: rule_present
      - int_kw:
          skip:
            rule: IntKw
      - identifier
      - generic_parameters:
          member:
            build:
              node:
                or_else_default: true
      - implements_list:
          member:
            build:
              node:
                or_else_default: true
      - declarations:
          vec:
            rule: InterfaceLevelDeclaration
      - end_kw:
          skip:
            rule: End
Class:
  struct:
    children:
      - is_public:
          member:
            rule: Pub
            build:
              boolean:
                on: rule_present
      - class_kw:
          skip:
            rule: ClassKw
      - identifier
      - generic_parameters:
          member:
            build:
              node:
                or_else_default: true
      - class_constructor:
          member:
            build:
              node:
                or_else_default: true
      - implements_list:
          member:
            build:
              node:
                or_else_default: true
      - class_level_declarations:
          vec:
            rule: ClassLevelDeclaration
      - end_kw:
          skip:
            rule: End

# Function constructs
Function:
  struct:
    children:
      - is_public:
          member:
            rule: Pub
            build:
              boolean:
                on: rule_present
      - fn_kw:
          skip:
            rule: Fn
      - generics:
          member:
            rule: GenericParameters
            build:
              node:
                or_else_default: true
      - identifier
      - parameters
      - return_type:
          member:
            build:
              node:
                or_else: void
      - function_body
OperatorFunction:
  struct:
    children:
      - is_public:
          member:
            rule: Pub
            build:
              boolean:
                on: rule_present
      - op_kw:
          skip:
            rule: Op
      - generics:
          member:
            rule: GenericParameters
            build:
              node:
                or_else_default: true
      - operator
      - parameters
      - return_type:
          member:
            build:
              node:
                or_else: void
      - function_body
PlatformFunction:
  struct:
    children:
      - is_public:
          member:
            rule: Pub
            build:
              boolean:
                on: rule_present
      - platform_kw:
          skip:
            rule: Platform
      - fn_kw:
          skip:
            rule: Fn
      - generics:
          member:
            rule: GenericParameters
            build:
              node:
                or_else_default: true
      - identifier
      - parameters
      - return_type
InterfaceFunction:
  struct:
    children:
      - fn_kw:
          skip:
            rule: Fn
      - generics:
          member:
            rule: GenericParameters
            build:
              node:
                or_else_default: true
      - identifier
      - parameters
      - return_type
InterfaceDefaultFunction:
  struct:
    children:
      - def_kw:
          skip:
            rule: Def
      - fn_kw:
          skip:
            rule: Fn
      - generics:
          member:
            rule: GenericParameters
            build:
              node:
                or_else_default: true
      - identifier
      - parameters
      - return_type:
          member:
            build:
              node:
                or_else: void
      - function_body
InterfaceOperatorFunction:
  struct:
    children:
      - op_kw:
          skip:
            rule: Op
      - generics:
          member:
            rule: GenericParameters
            build:
              node:
                or_else_default: true
      - operator
      - parameters
      - return_type
InterfaceDefaultOperatorFunction:
  struct:
    children:
      - def_kw:
          skip:
            rule: Def
      - op_kw:
          skip:
            rule: Op
      - generics:
          member:
            rule: GenericParameters
            build:
              node:
                or_else_default: true
      - operator
      - parameters
      - return_type:
          member:
            build:
              node:
                or_else: void
      - function_body

# Function Bodies
FunctionBody:
  tree_enum:
    rules:
      - FunctionAliasBody
      - FunctionEqualsBody
      - FunctionBlockBody
FunctionEqualsBody:
  struct:
    children:
      - expression
FunctionAliasBody:
  struct:
    children:
      - alias_kw:
          skip:
            rule: Alias
      - identifier
FunctionBlockBody:
  struct:
    children:
      - statements:
          vec:
            rule: Statement
      - end_kw:
          skip:
            rule: End

# Class constructs
ClassConstructor:
  struct:
    children:
      - members:
          vec:
            rule: Member
Member:
  struct:
    children:
      - is_public:
          member:
            rule: Pub
            build:
              boolean:
                on: rule_present
      - is_mut:
          member:
            rule: Mut
            build:
              boolean:
                on: rule_present
      - identifier
      - type_use

# Statements
Statement:
  tree_enum:
    rules:
      - VariableDeclaration
      - AssignmentStatement
      - ExpressionStatement
      - UseStatement
      - IfStatement
      - WhileStatement
      - ForStatement
VariableDeclaration:
  struct:
    children:
      - let_kw:
          skip:
            rule: Let
      - is_mut:
          member:
            rule: Mut
            build:
              boolean:
                on: rule_present
      - identifier
      - type_use:
          member:
            optional: true
      - expression:
          member:
            optional: true
AssignmentStatement:
  struct:
    children:
      - left:
          member:
            rule: Expression
      - right:
          member:
            rule: Expression
ExpressionStatement:
  struct:
    children:
      - expression
IfStatement:
  struct:
    children:
      - if_clause
      - if_else_ifs:
          vec:
            rule: IfElseIf
      - if_else
      - end_kw:
          skip:
            rule: End
IfClause:
  struct:
    children:
      - if_kw:
          skip:
            rule: If
      - expression
      - then_kw:
          skip:
            rule: Then
      - statements:
          skip:
            rule: Statement
IfElseIf:
  struct:
    children:
      - else_kw:
          skip:
            rule: Else
      - if_clause
IfElse:
  struct:
    children:
      - else_kw:
          skip:
            rule: Else
      - statements:
          vec:
            rule: Statement
WhileStatement:
  struct:
    children:
      - while_kw:
          skip:
            rule: While
      - expression
      - do_kw:
          skip:
            rule: Do
      - statements:
          vec:
            rule: Statement
      - end_kw:
          skip:
            rule: End
ForStatement:
  struct:
    children:
      - for_kw:
          skip:
            rule: For
      - identifier
      - in_kw:
          skip:
            rule: In
      - expression
      - do_kw:
          skip:
            rule: Do
      - statement:
          vec:
            rule: Statement
      - end_kw:
          skip:
            rule: End

# Expressions
Expression:
  polymorphic_type:
    variants:
      - Ternary:
          inner:
            kind: TernaryExpression
      - Or:
          inner:
            kind: OrExpression
      - And:
          inner:
            kind: AndExpression
      - Comparison:
          inner:
            kind: ComparisonExpression
      - Shift:
          inner:
            kind: ShiftExpression
      - Additive:
          inner:
            kind: AdditiveExpression
      - Multiplicative:
          inner:
            kind: MultiplicativeExpression
      - Prefix:
          inner:
            kind: PrefixExpression
      - Suffix:
          inner:
            kind: SuffixExpression
      - Literal:
          inner:
            kind: Literal
      - Fqn:
          inner:
            kind: FullyQualifiedName
      - Closure:
          inner:
            kind: Closure
      - List:
          inner:
            kind: ListExpression
    build:
      kind: TernaryExpression

# Ternary
TernaryExpression:
  polymorphic_enum_loop_build:
    kind: Expression
    rules:
      - OrExpression:
          pass_through:
            kind: Expression
            with: OrExpression
      - TernaryRhs:
          build:
            variant: Ternary
            children:
              - test:
                  use_current:
                    kind: Expression
              - right:
                  on_each:
                    rule: TernaryRhs
TernaryRhs:
  struct:
    children:
      - true_alternative:
          member:
            rule: TernaryTrueAlternative
            build:
              node:
                kind: Expression
                with: TernaryTrueAlternative
      - false_alternative:
          member:
            rule: TernaryFalseAlternative
            build:
              node:
                kind: Expression
                with: TernaryFalseAlternative
TernaryTrueAlternative:
  node_production:
    kind: Expression
    with: OrExpression
TernaryFalseAlternative:
  node_production:
    kind: Expression
    with: OrExpression

# Or
OrExpression:
  polymorphic_enum_loop_build:
    kind: Expression
    rules:
      - AndExpression:
          pass_through:
            kind: Expression
            with: AndExpression
      - AndRhs:
          build:
            variant: Or
            children:
              - left:
                  use_current:
                    kind: Expression
              - right:
                  on_each:
                    rule: OrRhs
OrRhs:
  struct:
    children:
      - or_kw:
          skip:
            rule: Or
      - expression:
          member:
            rule: AndExpression
            build:
              node:
                kind: Expression
                with: AndExpression

# And
AndExpression:
  polymorphic_enum_loop_build:
    kind: Expression
    rules:
      - ComparisonExpression:
          pass_through:
            kind: Expression
            with: ComparisonExpression
      - AndRhs:
          build:
            variant: And
            children:
              - left:
                  use_current:
                    kind: Expression
              - right:
                  on_each:
                    rule: AndRhs
AndRhs:
  struct:
    children:
      - and_kw:
          skip:
            rule: And
      - expression:
          member:
            rule: ComparisonExpression
            build:
              node:
                kind: Expression
                with: ComparisonExpression

# Comparison
ComparisonExpression:
  polymorphic_enum_loop_build:
    kind: Expression
    rules:
      - ShiftExpression:
          pass_through:
            kind: Expression
            with: ShiftExpression
      - ComparisonRhs:
          build:
            variant: Comparison
            children:
              - left:
                  use_current:
                    kind: Expression
              - rhs:
                  on_each:
                    rule: ComparisonRhs
ComparisonRhs:
  struct:
    children:
      - operator:
          member:
            rule: ComparisonOperator
      - expression:
          member:
            rule: ShiftExpression
            build:
              node:
                kind: Expression
                with: ShiftExpression
ComparisonOperator:
  leaf_enum:
    rules:
      - Greater
      - Less
      - GreaterEqual
      - LessEqual
      - EqualTo
      - NotEqualTo
ShiftExpression:
  polymorphic_enum_loop_build:
    kind: Expression
    rules:
      - AdditiveExpression:
          pass_through:
            kind: Expression
            with: AdditiveExpression
      - ShiftRhs:
          build:
            variant: Shift
            children:
              - left:
                  use_current:
                    kind: Expression
              - right:
                  on_each:
                    rule: ShiftRhs
ShiftRhs:
  struct:
    children:
      - operator:
          member:
            rule: ShiftOperator
      - expression:
          member:
            rule: AdditiveExpression
            build:
              node:
                kind: Expression
                with: AdditiveExpression
ShiftOperator:
  leaf_enum:
    rules:
      - LeftShift
      - RightShift
AdditiveExpression:
  polymorphic_enum_loop_build:
    kind: Expression
    rules:
      - MultiplicativeExpression:
          pass_through:
            kind: Expression
            with: MultiplicativeExpression
      - AdditiveRhs:
          build:
            variant: Additive
            children:
              - left:
                  use_current:
                    kind: Expression
              - rhs:
                  on_each:
                    rule: AdditiveRhs
AdditiveRhs:
  struct:
    children:
      - operator:
          member:
            rule: AdditiveOperator
      - expression:
          member:
            rule: MultiplicativeExpression
            build:
              node:
                kind: Expression
                with: MultiplicativeExpression
AdditiveOperator:
  leaf_enum:
    rules:
      - Add
      - Subtract
MultiplicativeExpression:
  polymorphic_enum_loop_build:
    kind: Expression
    rules:
      - PrefixExpression:
          pass_through:
            kind: Expression
            with: PrefixExpression
      - MultiplicativeRhs:
          build:
            variant: Multiplicative
            children:
              - left:
                  use_current:
                    kind: Expression
              - rhs:
                  on_each:
                    rule: MultiplicativeRhs
MultiplicativeRhs:
  struct:
    children:
      - operator:
          member:
            rule: MultiplicativeOperator
      - expression:
          member:
            rule: PrefixExpression
            build:
              node:
                kind: Expression
                with: PrefixExpression
MultiplicativeOperator:
  leaf_enum:
    rules:
      - Multiply
      - Divide
      - Modulo
PrefixExpression:
  polymorphic_enum_loop_build:
    kind: Expression
    reverse: true
    rules:
      - PrefixOperator:
          build:
            variant: Prefix
            children:
              - operator:
                  on_each:
                    rule: PrefixOperator
              - expression:
                  use_current:
                    kind: Expression
      - SuffixExpression:
          pass_through:
            kind: Expression
            with: SuffixExpression
PrefixOperator:
  leaf_enum:
    rules:
      - Spread
      - Not
      - Negative
SuffixExpression:
  polymorphic_enum_loop_build:
    kind: Expression
    rules:
      - PrimaryExpression:
          pass_through:
            kind: Expression
            with: PrimaryExpression
      - SuffixOperator:
          build:
            variant: Suffix
            children:
              - expression:
                  use_current:
                    kind: Expression
              - operator:
                  on_each:
                    rule: SuffixOperator
SuffixOperator:
  tree_enum:
    rules:
      - PlusPlus:
          child: false
      - MinusMinus:
          child: false
      - ObjectProperty
      - ObjectIndex
      - Call
ObjectProperty:
  struct:
    children:
      - identifier
ObjectIndex:
  struct:
    children:
      - expression
PrimaryExpression:
  polymorphic_pass_through:
    build:
      kind: Expression
    variants:
      - Literal:
          inner:
            kind: Literal
      - Fqn:
          inner:
            kind: FullyQualifiedName
      - Closure:
          inner:
            kind: Closure
      - List:
          inner:
            kind: ListExpression
      - ParenthesizedExpression:
          pass_through:
            kind: Expression
ListExpression:
  struct:
    children:
      - expression_list
ParenthesizedExpression:
  node_production:
    kind: Expression
    with: Expression

# Calls
Call:
  tree_enum:
    rules:
      - ParenthesesCall
      - NonParenthesesCall
ParenthesesCall:
  struct:
    children:
      - turbo_fish:
          member:
            optional: true
      - expression_list:
          member:
            optional: true
      - closure:
          member:
            optional: true
NonParenthesesCall:
  struct:
    children:
      - turbo_fish:
          member:
            optional: true
      - expression_list:
          member:
            optional: true
      - closure:
          member:
            optional: true
TurboFish:
  struct:
    children:
      - generic_arguments
ExpressionList:
  struct:
    children:
      - expressions:
          vec:
            rule: Expression

# Closure
Closure:
  struct:
    children:
      - closure_parameters:
          member:
            build:
              node:
                or_else_default: true
      - statements:
          vec:
            rule: Statement
ClosureParameters:
  struct:
    children:
      - parameters:
          vec:
            rule: ClosureParameter
ClosureParameter:
  struct:
    children:
      - identifier
      - type_use:
          member:
            optional: true

# Literals
Literal:
  tree_enum:
    rules:
      - IntLiteral:
          kind: int
      - LongLiteral:
          kind: long
      - DoubleLiteral:
          kind: double
      - SingleQuoteString:
          kind: string
      - DString
      - BacktickString
      - BooleanLiteral:
          kind: boolean

# Numbers
IntLiteral:
  production:
    kind: int
LongLiteral:
  production:
    kind: long
DoubleLiteral:
  production:
    kind: double

# Strings
SingleQuoteString:
  production:
    kind: string
    from: string_inner
DString:
  struct:
    children:
      - inners:
          vec:
            rule: DStringInner
            kind: string
      - expressions:
          vec:
            rule: DStringExpression
DStringInner:
  production:
    kind: string
    from: whole_pair
DStringExpression:
  struct:
    children:
      - expression
BacktickString:
  struct:
    children:
      - inners:
          vec:
            rule: BacktickInner
            kind: string
      - expressions:
          vec:
            rule: DStringExpression
BacktickInner:
  production:
    kind: string
    from: whole_pair
BooleanLiteral:
  production:
    kind: boolean
    from: parse_whole_pair