ast.h

#ifndef SPUDPLATE_AST_H
#define SPUDPLATE_AST_H
 
#include <cstdint>
#include <memory>
#include <optional>
#include <string>
#include <variant>
#include <vector>
 
#include "spudplate/token.h"
 
namespace spudplate {
 
struct StringLiteralExpr {
    std::string value;  
    int line;    
    int column;  
};
 
struct IntegerLiteralExpr {
    int value;  
    int line;    
    int column;  
};
 
struct BoolLiteralExpr {
    bool value;  
    int line;    
    int column;  
};
 
struct IdentifierExpr {
    std::string name;  
    int line;    
    int column;  
};
 
// Forward declare Expr so recursive types can hold pointers to it
struct Expr;
using ExprPtr = std::unique_ptr<Expr>;
 
struct UnaryExpr {
    TokenType op;     
    ExprPtr operand;  
    int line;    
    int column;  
};
 
struct BinaryExpr {
    TokenType op;   
    ExprPtr left;   
    ExprPtr right;  
    int line;    
    int column;  
};
 
struct FunctionCallExpr {
    std::string name;                  
    std::vector<ExprPtr> arguments;    
    int line;    
    int column;  
};
 
struct TemplateStringExpr {
    std::vector<std::variant<std::string, ExprPtr>> parts;  
    int line;    
    int column;  
};
 
using ExprData = std::variant<StringLiteralExpr, IntegerLiteralExpr, BoolLiteralExpr,
                              IdentifierExpr, UnaryExpr, BinaryExpr, FunctionCallExpr,
                              TemplateStringExpr>;
 
struct Expr {
    ExprData data;  
};
 
enum class VarType { String, Bool, Int };
 
// ---------------------------------------------------------------------------
// Path expression types
// ---------------------------------------------------------------------------
 
struct PathLiteral {
    std::string value;  
    int line;    
    int column;  
};
 
struct PathVar {
    std::string name;  
    int line;    
    int column;  
};
 
struct PathInterp {
    ExprPtr expression;  
    int line;    
    int column;  
};
 
using PathSegment = std::variant<PathLiteral, PathVar, PathInterp>;
 
struct PathExpr {
    std::vector<PathSegment> segments;  
    int line;                           
    int column;                         
};
 
struct FileFromSource {
    PathExpr path;  
    bool verbatim;  
};
 
struct FileContentSource {
    ExprPtr value;  
};
 
using FileSource = std::variant<FileFromSource, FileContentSource>;
 
// ---------------------------------------------------------------------------
// Statement types
// ---------------------------------------------------------------------------
 
struct AskStmt {
    std::string name;                         
    std::string prompt;                       
    VarType var_type;                         
    std::optional<ExprPtr> default_value;     
    std::vector<ExprPtr> options;             
    std::optional<ExprPtr> when_clause;       
    int line;    
    int column;  
};
 
struct LetStmt {
    std::string name;  
    ExprPtr value;     
    int line;    
    int column;  
};
 
struct AssignStmt {
    std::string name;  
    ExprPtr value;     
    int line;    
    int column;  
};
 
struct MkdirStmt {
    PathExpr path;                         
    std::optional<std::string> alias;      
    bool mkdir_p;                          
    std::optional<PathExpr> from_source;   
    bool verbatim;                         
    std::optional<int> mode;               
    std::optional<ExprPtr> when_clause;    
    int line;    
    int column;  
};
 
struct FileStmt {
    PathExpr path;                        
    std::optional<std::string> alias;     
    FileSource source;                    
    bool append;                          
    std::optional<int> mode;              
    std::optional<ExprPtr> when_clause;   
    int line;    
    int column;  
};
 
// Forward declare Stmt so RepeatStmt can hold a vector of them
struct Stmt;
using StmtPtr = std::unique_ptr<Stmt>;
 
struct RepeatStmt {
    std::string collection_var;          
    std::string iterator_var;            
    std::vector<StmtPtr> body;           
    std::optional<ExprPtr> when_clause;  
    int line;    
    int column;  
};
 
struct CopyStmt {
    PathExpr source;                     
    PathExpr destination;                
    bool verbatim;                       
    std::optional<ExprPtr> when_clause;  
    int line;    
    int column;  
};
 
struct RunStmt {
    ExprPtr command;                     
    std::optional<PathExpr> cwd;         
    std::optional<ExprPtr> timeout;      
    std::optional<ExprPtr> when_clause;  
    int line;    
    int column;  
};
 
struct IncludeStmt {
    std::string name;                          
    std::optional<std::uint32_t> version_pin;  
    std::optional<ExprPtr> when_clause;        
    int line;    
    int column;  
};
 
struct IfStmt {
    ExprPtr condition;            
    std::vector<StmtPtr> body;    
    int line;    
    int column;  
};
 
using StmtData = std::variant<AskStmt, LetStmt, AssignStmt, MkdirStmt, FileStmt,
                              RepeatStmt, CopyStmt, IncludeStmt, RunStmt,
                              IfStmt>;
 
struct Stmt {
    StmtData data;  
};
 
struct Program {
    std::vector<StmtPtr> statements;  
};
 
}  // namespace spudplate
 
#endif  // SPUDPLATE_AST_H