# $schema: ./ast.schema.yaml
# Operators
Operator:
  leaf_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:
  members:
    - name:
        kind: string
        from: whole_pair
FullyQualifiedName:
  children:
    - identifiers:
        rule: Identifier
        vec: true

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

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

# Generic Arguments
GenericArguments:
  children:
    - type_use_list

# Generic Parameters
GenericParameters:
  children:
    - identifier_list

# Tuple Arguments
TupleArguments:
  children:
    - parentheses_optional_type_use_list

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

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

# Return Type
ReturnType:
  children:
    - type_use

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

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

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

# Function constructs
Function:
  children:
    - is_public:
        rule: Pub
        build:
          kind: boolean
          on: rule_present
    - fn_kw:
        rule: Fn
        skip: true
    - generics:
        rule: GenericParameters
        build:
          or_else_default: true
    - identifier
    - parameters
    - return_type:
        build:
          or_else: void
    - function_body
OperatorFunction:
  children:
    - is_public:
        rule: Pub
        build:
          kind: boolean
          on: rule_present
    - op_kw:
        rule: Op
        skip: true
    - generics:
        rule: GenericParameters
        build:
          or_else_default: true
    - operator
    - parameters
    - return_type:
        build:
          or_else: void
    - function_body
PlatformFunction:
  children:
    - is_public:
        rule: Pub
        build:
          kind: boolean
          on: rule_present
    - platform_kw:
        rule: Platform
        skip: true
    - fn_kw:
        rule: Fn
        skip: true
    - generics:
        rule: GenericParameters
        build:
          or_else_default: true
    - identifier
    - parameters
    - return_type
InterfaceFunction:
  children:
    - fn_kw:
        rule: Fn
        skip: true
    - generics:
        rule: GenericParameters
        build:
          or_else_default: true
    - identifier
    - parameters
    - return_type
InterfaceDefaultFunction:
  children:
    - def_kw:
        rule: Def
        skip: true
    - fn_kw:
        rule: Fn
        skip: true
    - generics:
        rule: GenericParameters
        build:
          or_else_default: true
    - identifier
    - parameters
    - return_type:
        build:
          or_else: void
    - function_body
InterfaceOperatorFunction:
  children:
    - op_kw:
        rule: Op
        skip: true
    - generics:
        rule: GenericParameters
        build:
          or_else_default: true
    - operator
    - parameters
    - return_type
InterfaceDefaultOperatorFunction:
  children:
    - def_kw:
        rule: Def
        skip: true
    - op_kw:
        rule: Op
        skip: true
    - generics:
        rule: GenericParameters
        build:
          or_else_default: true
    - operator
    - parameters
    - return_type:
        build:
          or_else: void
    - function_body
      
# Function Bodies
FunctionBody:
  rules:
    - FunctionAliasBody
    - FunctionEqualsBody
    - FunctionBlockBody
FunctionEqualsBody:
  children:
    - expression
FunctionAliasBody:
  children:
    - alias_kw:
        rule: Alias
        skip: true
    - identifier
FunctionBlockBody:
  children:
    - statements:
        rule: Statement
        vec: true
    - end_kw:
        rule: End
        skip: true

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

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

# Expressions
Expression:
  polymorphic_type:
    enum_members:
      - 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
    build:
      kind: TernaryExpression
TernaryExpression:
  polymorphic_build:
    return_type: Expression
    alternatives:
      - test:
          number_of_pairs: 1
        action:
          return_build:
            kind: OrExpression
      - test:
          number_of_pairs: 3
        action:
          build:
            enum_variant: Ternary
            children:
              - test:
                  kind: Expression
                  rule: OrExpression
              - on_true:
                  kind: Expression
                  rule: TernaryTrueAlternative
              - on_false:
                  kind: Expression
                  rule: TernaryFalseAlternative
TernaryTrueAlternative:
  produce:
    kind:
      node: Expression
TernaryFalseAlternative:
  produce:
    kind:
      node: Expression
OrExpression:
  polymorphic_build:
    return_type: Expression
    alternatives:
      - test:
          number_of_pairs: 1
        action:
          return_build:
            kind: AndExpression
      - test:
          number_of_pairs: 3
        action:
          build:
            enum_variant: Or
            children:
              - left:
                  kind: Expression
                  rule: AndExpression
              - or_sym:
                  rule: Or
                  skip: true
              - right:
                  kind: Expression
                  rule: Expression
AndExpression:
  polymorphic_build:
    return_type: Expression
    alternatives:
      - test:
          number_of_pairs: 1
        action:
          return_build:
            kind: ComparisonExpression
      - test:
          number_of_pairs: 3
        action:
          build:
            enum_variant: And
            children:
              - left:
                  kind: Expression
                  rule: ComparisonExpression
              - and_sym:
                  rule: And
                  skip: true
              - right:
                  kind: Expression
                  rule: Expression
ComparisonExpression:
  polymorphic_build:
    return_type: Expression
    alternatives:
      - test:
          number_of_pairs: 1
        action:
          return_build:
            kind: ShiftExpression
      - test:
          number_of_pairs: 3
        action:
          build:
            enum_variant: Comparison
            children:
              - left:
                  kind: Expression
                  rule: ShiftExpression
              - operator:
                  kind: ComparisonOperator
                  rule: ComparisonOperator
              - right:
                  kind: Expression
                  rule: Expression
ComparisonOperator:
  leaf_rules:
    - Greater
    - Less
    - GreaterEqual
    - LessEqual
    - EqualTo
    - NotEqualTo
ShiftExpression:
  polymorphic_build:
    return_type: Expression
    alternatives:
      - test:
          number_of_pairs: 1
        action:
          return_build:
            kind: AdditiveExpression
      - test:
          number_of_pairs: 3
        action:
          build:
            enum_variant: Shift
            children:
              - left:
                  kind: Expression
                  rule: AdditiveExpression
              - operator:
                  kind: ShiftOperator
                  rule: ShiftOperator
              - right:
                  kind: Expression
                  rule: Expression
ShiftOperator:
  leaf_rules:
    - LeftShift
    - RightShift
AdditiveExpression:
  polymorphic_build:
    return_type: Expression
    alternatives:
      - test:
          number_of_pairs: 1
        action:
          return_build:
            kind: MultiplicativeExpression
      - test:
          number_of_pairs: 3
        action:
          build:
            enum_variant: Additive
            children:
              - left:
                  kind: Expression
                  rule: MultiplicativeExpression
              - operator:
                  kind: AdditiveOperator
                  rule: AdditiveOperator
              - right:
                  kind: Expression
                  rule: Expression
AdditiveOperator:
  leaf_rules:
    - Add
    - Subtract
MultiplicativeExpression:
  polymorphic_build:
    return_type: Expression
    alternatives:
      - test:
          number_of_pairs: 1
        action:
          return_build:
            kind: PrefixExpression
      - test:
          number_of_pairs: 3
        action:
          build:
            enum_variant: Multiplicative
            children:
              - left:
                  kind: Expression
                  rule: PrefixExpression
              - operator:
                  kind: MultiplicativeOperator
                  rule: MultiplicativeOperator
              - right:
                  kind: Expression
                  rule: Expression
MultiplicativeOperator:
  leaf_rules:
    - Multiply
    - Divide
    - Modulo
PrefixExpression:
  polymorphic_build:
    return_type: Expression
    alternatives:
      - test:
          number_of_pairs: 1
        action:
          return_build:
            kind: SuffixExpression
      - test:
          number_of_pairs: 2
        action:
          build:
            enum_variant: Prefix
            children:
              - prefix_operators:
                  kind: PrefixOperators
                  rule: PrefixOperators
              - right:
                  kind: Expression
                  rule: SuffixExpression
PrefixOperators:
  children:
    - operators:
        rule: PrefixOperator
        vec: true
PrefixOperator:
  leaf_rules:
    - Spread
    - Not
    - Negative
SuffixExpression:
  polymorphic_build:
    return_type: Expression
    alternatives:
      - test:
          number_of_pairs: 1
        action:
          return_build:
            kind: PrimaryExpression
      - test:
          number_of_pairs: 2
        action:
          build:
            enum_variant: Suffix
            children:
              - left:
                  kind: Expression
                  rule: PrimaryExpression
              - suffix_operators:
                  kind: SuffixOperators
                  rule: SuffixOperators
SuffixOperators:
  children:
    - operators:
        rule: SuffixOperator
        vec: true
SuffixOperator:
  rules:
    - PlusPlus:
        child: false
    - MinusMinus:
        child: false
    - ObjectProperty
    - ObjectIndex
    - Call
ObjectProperty:
  children:
    - identifier
ObjectIndex:
  children:
    - expression
PrimaryExpression:
  polymorphic_enum:
    return_type: Expression
    rules:
      - Literal:
          wrap:
            enum_variant: Literal
      - FullyQualifiedName:
          wrap:
            enum_variant: Fqn
      - Closure:
          wrap:
            enum_variant: Closure
      - ParenthesizedExpression:
          return_build:
            kind: Expression
ParenthesizedExpression:
  children:
    - expression

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

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

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

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

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