AST.hpp

Go to the documentation of this file.

#pragma once
#include <iostream>
#include <memory>
#include <string>
#include <utility>
#include <vector>
#include <filesystem>
#include <format>
#include <phsint.hpp>

namespace Phasor
{
enum class TokenType : u8
{
    Identifier,
    Number,
    String,
    Keyword,
    Symbol,
    EndOfFile,
    Unknown
};

struct Token
{
    TokenType   type;
    std::string lexeme;
    size_t      line;
    size_t      column;
};

namespace AST
{
 
// Forward declarations
struct Node;
struct Expression;
struct Statement;
struct Program;

struct Node
{
    virtual ~Node() = default;
    virtual void print(int indent = 0) const = 0;
    size_t       line = 0;
    size_t       column = 0;
};

struct Expression : public Node
{
};

struct Statement : public Node
{
};

struct Program : public Node
{
    std::vector<std::unique_ptr<Statement>> statements;
    void                                    print(int indent = 0) const override
    {
        for (const auto &stmt : statements)
        {
            stmt->print(indent);
        }
    }
};

struct TypeNode : public Node
{
    std::string      name;
    bool             isPointer = false;
    std::vector<int> arrayDimensions;
 
    TypeNode(std::string n, bool ptr = false, std::vector<int> dims = {})
        : name(std::move(n)), isPointer(ptr), arrayDimensions(std::move(dims))
    {
    }
    void print(int indent = 0) const override
    {
        std::cout << std::format("{:>{}}Type: {}\n", "", indent, name);
        for (int dim : arrayDimensions)
        {
            std::cout << std::format("{:>{}}ArrayDim: {}\n", "", indent + 2, dim);
        }
    }
};

struct NumberExpr : public Expression
{
    std::string value;
    NumberExpr(std::string v) : value(std::move(v))
    {
    }
    void print(int indent = 0) const override
    {
        std::cout << std::format("{:>{}}Number: {}\n", "", indent, value);
    }
};

struct StringExpr : public Expression
{
    std::string value;
    StringExpr(std::string v) : value(std::move(v))
    {
    }
    void print(int indent = 0) const override
    {
 
        std::cout << std::format("{:>{}}String: {}\n", "", indent, value);
    }
};

struct IdentifierExpr : public Expression
{
    std::string name;
    IdentifierExpr(std::string n) : name(std::move(n))
    {
    }
    void print(int indent = 0) const override
    {
        std::cout << std::format("{:>{}}Identifier: {}\n", "", indent, name);
    }
};

struct BooleanExpr : public Expression
{
    bool value;
    BooleanExpr(bool v) : value(v)
    {
    }
    void print(int indent = 0) const override
    {
        std::cout << std::format("{:>{}}Boolean: {}\n", "", indent, value);
    }
};

struct NullExpr : public Expression
{
    void print(int indent = 0) const override
    {
        std::cout << std::string(indent, ' ') << "Null\n";
    }
};

enum class UnaryOp : u8
{
    Negate,     // -x
    Not,        // !x
    AddressOf,  // &x
    Dereference // *x
};

enum class BinaryOp : u8
{
    Add,
    Subtract,
    Multiply,
    Divide,
    Modulo,
    And,
    Or,
    Equal,
    NotEqual,
    LessThan,
    GreaterThan,
    LessEqual,
    GreaterEqual
};

enum class PostfixOp : u8
{
    Increment, // x++
    Decrement  // x--
};

struct PostfixExpr : public Expression
{
    PostfixOp                   op;
    std::unique_ptr<Expression> operand;
 
    PostfixExpr(PostfixOp o, std::unique_ptr<Expression> expr) : op(o), operand(std::move(expr))
    {
    }
 
    void print(int indent = 0) const override
    {
        std::cout << std::string(indent, ' ') << "PostfixExpr: ";
        switch (op)
        {
        case PostfixOp::Increment:
            std::cout << "++\n";
            break;
        case PostfixOp::Decrement:
            std::cout << "--\n";
            break;
        }
        operand->print(indent + 2);
    }
};

struct UnaryExpr : public Expression
{
    UnaryOp                     op;
    std::unique_ptr<Expression> operand;
 
    UnaryExpr(UnaryOp o, std::unique_ptr<Expression> expr) : op(o), operand(std::move(expr))
    {
    }
 
    void print(int indent = 0) const override
    {
        std::cout << std::string(indent, ' ') << "UnaryExpr: ";
        switch (op)
        {
        case UnaryOp::Negate:
            std::cout << "-\n";
            break;
        case UnaryOp::Not:
            std::cout << "!\n";
            break;
        case UnaryOp::AddressOf:
            std::cout << "&\n";
            break;
        case UnaryOp::Dereference:
            std::cout << "*\n";
            break;
        }
        operand->print(indent + 2);
    }
};

struct BinaryExpr : public Expression
{
    std::unique_ptr<Expression> left;
    BinaryOp                    op;
    std::unique_ptr<Expression> right;
 
    BinaryExpr(std::unique_ptr<Expression> l, BinaryOp o, std::unique_ptr<Expression> r)
        : left(std::move(l)), op(o), right(std::move(r))
    {
    }
 
    void print(int indent = 0) const override
    {
        std::cout << std::string(indent, ' ') << "BinaryExpr: ";
        switch (op)
        {
        case BinaryOp::Add:
            std::cout << "+\n";
            break;
        case BinaryOp::Subtract:
            std::cout << "-\n";
            break;
        case BinaryOp::Multiply:
            std::cout << "*\n";
            break;
        case BinaryOp::Divide:
            std::cout << "/\n";
            break;
        case BinaryOp::Modulo:
            std::cout << "%\n";
            break;
        case BinaryOp::And:
            std::cout << "&&\n";
            break;
        case BinaryOp::Or:
            std::cout << "||\n";
            break;
        case BinaryOp::Equal:
            std::cout << "==\n";
            break;
        case BinaryOp::NotEqual:
            std::cout << "!=\n";
            break;
        case BinaryOp::LessThan:
            std::cout << "<\n";
            break;
        case BinaryOp::GreaterThan:
            std::cout << ">\n";
            break;
        case BinaryOp::LessEqual:
            std::cout << "<=\n";
            break;
        case BinaryOp::GreaterEqual:
            std::cout << ">=\n";
            break;
        }
        left->print(indent + 2);
        right->print(indent + 2);
    }
};

struct ArrayAccessExpr : public Expression
{
    std::unique_ptr<Expression> array;
    std::unique_ptr<Expression> index;
 
    ArrayAccessExpr(std::unique_ptr<Expression> arr, std::unique_ptr<Expression> idx)
        : array(std::move(arr)), index(std::move(idx))
    {
    }
 
    void print(int indent = 0) const override
    {
        std::cout << std::string(indent, ' ') << "ArrayAccess:\n";
        array->print(indent + 2);
        std::cout << std::string(indent + 2, ' ') << "Index:\n";
        index->print(indent + 4);
    }
};

struct ArrayLiteralExpr : public Expression
{
    std::vector<std::unique_ptr<Expression>> elements;
    ArrayLiteralExpr(std::vector<std::unique_ptr<Expression>> elems) : elements(std::move(elems))
    {
    }
    void print(int indent = 0) const override
    {
        std::cout << std::string(indent, ' ') << "ArrayLiteral:\n";
        for (const auto &elem : elements)
        {
            elem->print(indent + 2);
        }
    }
};

struct MemberAccessExpr : public Expression
{
    std::unique_ptr<Expression> object;
    std::string                 member;
 
    MemberAccessExpr(std::unique_ptr<Expression> obj, std::string mem) : object(std::move(obj)), member(std::move(mem))
    {
    }
 
    void print(int indent = 0) const override
    {
        std::cout << std::string(indent, ' ') << "MemberAccess: ." << member << "\n";
        object->print(indent + 2);
    }
};

struct CallExpr : public Expression
{
    std::string                              callee;
    std::vector<std::unique_ptr<Expression>> arguments;
 
    CallExpr(std::string name, std::vector<std::unique_ptr<Expression>> args)
        : callee(std::move(name)), arguments(std::move(args))
    {
    }
 
    void print(int indent = 0) const override
    {
        std::cout << std::string(indent, ' ') << "CallExpr: " << callee << "\n";
        for (const auto &arg : arguments)
        {
            arg->print(indent + 2);
        }
    }
};

struct AssignmentExpr : public Expression
{
    std::unique_ptr<Expression> target;
    std::unique_ptr<Expression> value;
 
    AssignmentExpr(std::unique_ptr<Expression> t, std::unique_ptr<Expression> v)
        : target(std::move(t)), value(std::move(v))
    {
    }
 
    void print(int indent = 0) const override
    {
        std::cout << std::string(indent, ' ') << "AssignmentExpr:\n";
        std::cout << std::string(indent + 2, ' ') << "Target:\n";
        target->print(indent + 4);
        std::cout << std::string(indent + 2, ' ') << "Value:\n";
        value->print(indent + 4);
    }
};

struct VarDecl : public Statement
{
    std::string                 name;
    std::unique_ptr<Expression> initializer;
    VarDecl(std::string n, std::unique_ptr<Expression> init) : name(std::move(n)), initializer(std::move(init))
    {
    }
    void print(int indent = 0) const override
    {
        std::cout << std::string(indent, ' ') << "VarDecl: " << name << "\n";
        if (initializer)
        {
            initializer->print(indent + 2);
        }
    }
};

struct ExpressionStmt : public Statement
{
    std::unique_ptr<Expression> expression;
    ExpressionStmt(std::unique_ptr<Expression> expr) : expression(std::move(expr))
    {
    }
    void print(int indent = 0) const override
    {
        expression->print(indent);
    }
};

struct PrintStmt : public Statement
{
    std::unique_ptr<Expression> expression;
    PrintStmt(std::unique_ptr<Expression> expr) : expression(std::move(expr))
    {
    }
    void print(int indent = 0) const override
    {
        std::cout << std::string(indent, ' ') << "PrintStmt:\n";
        expression->print(indent + 2);
    }
};

struct IncludeStmt : public Statement
{
    std::filesystem::path modulePath;
    IncludeStmt(std::filesystem::path path) : modulePath(std::move(path))
    {
    }
    void print(int indent = 0) const override
    {
        std::cout << std::format("{:>{}}IncludeStmt: {}\n", "", indent, modulePath.string());
    }
};

struct ImportStmt : public Statement
{
    std::string modulePath;
    ImportStmt(std::string path) : modulePath(std::move(path))
    {
    }
    void print(int indent = 0) const override
    {
        std::cout << std::string(indent, ' ') << "ImportStmt: " << modulePath << "\n";
    }
};

struct ExportStmt : public Statement
{
    std::unique_ptr<Statement> declaration;
    ExportStmt(std::unique_ptr<Statement> decl) : declaration(std::move(decl))
    {
    }
    void print(int indent = 0) const override
    {
        std::cout << std::string(indent, ' ') << "ExportStmt:\n";
        declaration->print(indent + 2);
    }
};

struct BlockStmt : public Statement
{
    std::vector<std::unique_ptr<Statement>> statements;
    BlockStmt(std::vector<std::unique_ptr<Statement>> stmts) : statements(std::move(stmts))
    {
    }
    void print(int indent = 0) const override
    {
        std::cout << std::string(indent, ' ') << "BlockStmt:\n";
        for (const auto &stmt : statements)
        {
            stmt->print(indent + 2);
        }
    }
};

struct ReturnStmt : public Statement
{
    std::unique_ptr<Expression> value;
    ReturnStmt(std::unique_ptr<Expression> val) : value(std::move(val))
    {
    }
    void print(int indent = 0) const override
    {
        std::cout << std::string(indent, ' ') << "ReturnStmt:\n";
        if (value)
        {
            value->print(indent + 2);
        }
    }
};

struct BreakStmt : public Statement
{
    void print(int indent = 0) const override
    {
        std::cout << std::string(indent, ' ') << "BreakStmt\n";
    }
};

struct ContinueStmt : public Statement
{
    void print(int indent = 0) const override
    {
        std::cout << std::string(indent, ' ') << "ContinueStmt\n";
    }
};

struct IfStmt : public Statement
{
    std::unique_ptr<Expression> condition;
    std::unique_ptr<Statement>  thenBranch;
    std::unique_ptr<Statement>  elseBranch;
 
    IfStmt(std::unique_ptr<Expression> cond, std::unique_ptr<Statement> thenB, std::unique_ptr<Statement> elseB)
        : condition(std::move(cond)), thenBranch(std::move(thenB)), elseBranch(std::move(elseB))
    {
    }
 
    void print(int indent = 0) const override
    {
        std::cout << std::string(indent, ' ') << "IfStmt:\n";
        condition->print(indent + 2);
        thenBranch->print(indent + 2);
        if (elseBranch)
        {
            std::cout << std::string(indent, ' ') << "Else:\n";
            elseBranch->print(indent + 2);
        }
    }
};

struct WhileStmt : public Statement
{
    std::unique_ptr<Expression> condition;
    std::unique_ptr<Statement>  body;
 
    WhileStmt(std::unique_ptr<Expression> cond, std::unique_ptr<Statement> b)
        : condition(std::move(cond)), body(std::move(b))
    {
    }
 
    void print(int indent = 0) const override
    {
        std::cout << std::string(indent, ' ') << "WhileStmt:\n";
        condition->print(indent + 2);
        body->print(indent + 2);
    }
};

struct ForStmt : public Statement
{
    std::unique_ptr<Statement>  initializer;
    std::unique_ptr<Expression> condition;
    std::unique_ptr<Expression> increment;
    std::unique_ptr<Statement>  body;
 
    ForStmt(std::unique_ptr<Statement> init, std::unique_ptr<Expression> cond, std::unique_ptr<Expression> incr,
            std::unique_ptr<Statement> b)
        : initializer(std::move(init)), condition(std::move(cond)), increment(std::move(incr)), body(std::move(b))
    {
    }
 
    void print(int indent = 0) const override
    {
        std::cout << std::string(indent, ' ') << "ForStmt:\n";
        if (initializer)
        {
            initializer->print(indent + 2);
        }
        if (condition)
        {
            condition->print(indent + 2);
        }
        if (increment)
        {
            increment->print(indent + 2);
        }
        body->print(indent + 2);
    }
};

struct UnsafeBlockStmt : public Statement
{
    std::unique_ptr<BlockStmt> block;
    UnsafeBlockStmt(std::unique_ptr<BlockStmt> b) : block(std::move(b))
    {
    }
    void print(int indent = 0) const override
    {
        std::cout << std::string(indent, ' ') << "UnsafeBlockStmt:\n";
        block->print(indent + 2);
    }
};

struct FunctionDecl : public Statement
{
    std::string name;
    struct Param
    {
        std::string               name;
        std::unique_ptr<TypeNode> type;
    };
    std::vector<Param>         params;
    std::unique_ptr<TypeNode>  returnType;
    std::unique_ptr<BlockStmt> body;
 
    FunctionDecl(std::string n, std::vector<Param> p, std::unique_ptr<TypeNode> rt, std::unique_ptr<BlockStmt> b)
        : name(std::move(n)), params(std::move(p)), returnType(std::move(rt)), body(std::move(b))
    {
    }
 
    void print(int indent = 0) const override
    {
        std::cout << std::string(indent, ' ') << "FunctionDecl: " << name << "\n";
        for (const auto &param : params)
        {
            std::cout << std::string(indent + 2, ' ') << "Param: " << param.name << " Type: ";
            param.type->print(0);
        }
        std::cout << std::string(indent + 2, ' ') << "Return Type: ";
        if (returnType)
        {
            returnType->print(0);
        }
        else
        {
            std::cout << "void\n";
        }
        if (body)
        {
            body->print(indent + 2);
        }
    }
};

struct StructField
{
    std::string               name;
    std::unique_ptr<TypeNode> type;
 
    StructField(std::string n, std::unique_ptr<TypeNode> t) : name(std::move(n)), type(std::move(t))
    {
    }
};

struct StructDecl : public Statement
{
    std::string              name;
    std::vector<StructField> fields;
 
    StructDecl(std::string n, std::vector<StructField> f) : name(std::move(n)), fields(std::move(f))
    {
    }
 
    void print(int indent = 0) const override
    {
        std::cout << std::string(indent, ' ') << "StructDecl: " << name << "\n";
        for (const auto &field : fields)
        {
            std::cout << std::string(indent + 2, ' ') << field.name << ": ";
            field.type->print(0);
        }
    }
};

struct StructInstanceExpr : public Expression
{
    std::string                                                      structName;
    std::vector<std::pair<std::string, std::unique_ptr<Expression>>> fieldValues;
 
    StructInstanceExpr(std::string name, std::vector<std::pair<std::string, std::unique_ptr<Expression>>> fields)
        : structName(std::move(name)), fieldValues(std::move(fields))
    {
    }
 
    void print(int indent = 0) const override
    {
        std::cout << std::string(indent, ' ') << "StructInstance: " << structName << "\n";
        for (const auto &field : fieldValues)
        {
            std::cout << std::string(indent + 2, ' ') << field.first << ":\n";
            field.second->print(indent + 4);
        }
    }
};

struct FieldAccessExpr : public Expression
{
    std::unique_ptr<Expression> object;
    std::string                 fieldName;
 
    FieldAccessExpr(std::unique_ptr<Expression> obj, std::string field)
        : object(std::move(obj)), fieldName(std::move(field))
    {
    }
 
    void print(int indent = 0) const override
    {
        std::cout << std::string(indent, ' ') << "FieldAccess: ." << fieldName << "\n";
        object->print(indent + 2);
    }
};

struct CaseClause
{
    std::unique_ptr<Expression>             value;
    std::vector<std::unique_ptr<Statement>> statements;
 
    CaseClause(std::unique_ptr<Expression> v, std::vector<std::unique_ptr<Statement>> stmts)
        : value(std::move(v)), statements(std::move(stmts))
    {
    }
};

struct SwitchStmt : public Statement
{
    std::unique_ptr<Expression>             expr;
    std::vector<CaseClause>                 cases;
    std::vector<std::unique_ptr<Statement>> defaultStmts;
 
    SwitchStmt(std::unique_ptr<Expression> e, std::vector<CaseClause> c, std::vector<std::unique_ptr<Statement>> d)
        : expr(std::move(e)), cases(std::move(c)), defaultStmts(std::move(d))
    {
    }
 
    void print(int indent = 0) const override
    {
        std::cout << std::string(indent, ' ') << "SwitchStmt:\n";
        expr->print(indent + 2);
        for (const auto &c : cases)
        {
            std::cout << std::string(indent + 2, ' ') << "case:\n";
            c.value->print(indent + 4);
            for (const auto &stmt : c.statements)
            {
                stmt->print(indent + 4);
            }
        }
        if (!defaultStmts.empty())
        {
            std::cout << std::string(indent + 2, ' ') << "default:\n";
            for (const auto &stmt : defaultStmts)
            {
                stmt->print(indent + 4);
            }
        }
    }
};
} // namespace AST
} // namespace Phasor