ast.h

#ifndef AST_H
#define AST_H

#include <stdbool.h>
#include "token.h"

typedef enum {
    AST_MODULE,
    AST_BLOCK,

    AST_EXPR_STMT,
    AST_ASSIGN_STMT,
    AST_RETURN_STMT,
    AST_IF_STMT,
    AST_FOR_STMT,
    AST_WHILE_STMT,
    AST_FUNCTION_DEF,
    AST_CLASS_DEF,
    AST_PASS_STMT,
    AST_BREAK_STMT,
    AST_CONTINUE_STMT,
    AST_IMPORT_STMT,

    AST_BINARY_EXPR,
    AST_UNARY_EXPR,
    AST_LITERAL_EXPR,
    AST_IDENTIFIER_EXPR,
    AST_GROUPING_EXPR,
    AST_CALL_EXPR,
    AST_MEMBER_EXPR,
    AST_LIST_EXPR,
    AST_DICT_EXPR,
    AST_INDEX_EXPR
} AstNodeType;

typedef struct AstNode AstNode;

typedef struct {
    AstNode** items;
    int count;
    int capacity;
} AstNodeArray;

typedef struct {
    Token* items;
    int count;
    int capacity;
} TokenList;

struct AstNode {
    AstNodeType type;
    Token token;
    const char* sourcePath;

    union {
        struct {
            AstNodeArray statements;
        } module;

        struct {
            AstNodeArray statements;
        } block;

        struct {
            AstNode* expression;
        } exprStmt;

        struct {
            AstNode* target;
            AstNode* value;
        } assignStmt;

        struct {
            AstNode* value;
        } returnStmt;

        struct {
            AstNode* condition;
            AstNode* thenBlock;
            AstNode* elseBranch;
        } ifStmt;

        struct {
            AstNode* target;
            AstNode* iterable;
            AstNode* body;
        } forStmt;

        struct {
            AstNode* condition;
            AstNode* body;
        } whileStmt;

        struct {
            Token name;
            TokenList parameters;
            AstNode* body;
        } functionDef;

        struct {
            Token name;
            AstNode* body;
        } classDef;

        struct {
            Token path;
            Token alias;
            bool hasAlias;
        } importStmt;

        struct {
            Token op;
            AstNode* left;
            AstNode* right;
        } binaryExpr;

        struct {
            Token op;
            AstNode* operand;
        } unaryExpr;

        struct {
            Token literal;
        } literalExpr;

        struct {
            Token name;
        } identifierExpr;

        struct {
            AstNode* expression;
        } groupingExpr;

        struct {
            AstNode* callee;
            AstNodeArray arguments;
        } callExpr;

        struct {
            AstNode* object;
            Token member;
        } memberExpr;

        struct {
            AstNodeArray elements;
        } listExpr;

        struct {
            AstNodeArray keys;
            AstNodeArray values;
        } dictExpr;

        struct {
            AstNode* object;
            AstNode* index;
        } indexExpr;
    } as;
};

void initAstNodeArray(AstNodeArray* array);
void pushAstNode(AstNodeArray* array, AstNode* node);
void freeAstNodeArray(AstNodeArray* array);

void initTokenList(TokenList* list);
void pushTokenList(TokenList* list, Token token);
void freeTokenList(TokenList* list);

AstNode* newAstNode(AstNodeType type, Token token);

AstNode* makeBinaryNode(Token op, AstNode* left, AstNode* right);
AstNode* makeUnaryNode(Token op, AstNode* operand);
AstNode* makeIdentifierNode(Token name);
AstNode* makeLiteralNode(Token literal);

void annotateAstSourcePath(AstNode* node, const char* sourcePath);

void printAst(const AstNode* node, int depth);
void freeAst(AstNode* node);

#endif