feat: implement Abstract Syntax Tree (AST) structure and node creation functions

Author: ProgrammerKR

include/ast.h

@@ -35,7 +35,8 @@ typedef enum {
   EXPR_BINARY, EXPR_UNARY, EXPR_LITERAL, EXPR_GROUPING,
   EXPR_VARIABLE, EXPR_ASSIGN, EXPR_LOGICAL, EXPR_CALL,
   EXPR_GET, EXPR_SET, EXPR_INDEX, EXPR_LIST,
-  EXPR_DICTIONARY, EXPR_TERNARY, EXPR_LAMBDA
+  EXPR_DICTIONARY, EXPR_TERNARY, EXPR_LAMBDA,
+  EXPR_AWAIT
 } ExprType;
 
 typedef enum {
@@ -102,6 +103,7 @@ typedef struct { ExprList *elements; } ListExpr;
 typedef struct { DictPairList *pairs; } DictionaryExpr;
 typedef struct { Expr *condition; Expr *true_branch; Expr *false_branch; } TernaryExpr;
 typedef struct { StringList *params; StmtList *body; } LambdaExpr;
+typedef struct { Expr *expression; } AwaitExpr;
 
 struct Expr {
   ExprType type;
@@ -113,14 +115,14 @@ struct Expr {
     GroupingExpr grouping; VariableExpr variable; AssignExpr assign;
     LogicalExpr logical; CallExpr call; GetExpr get; SetExpr set;
     IndexExpr index; ListExpr list; DictionaryExpr dictionary;
-    TernaryExpr ternary; LambdaExpr lambda;
+    TernaryExpr ternary; LambdaExpr lambda; AwaitExpr await_expr;
   } as;
 };
 
 // --- Statement Data Structures ---
 typedef struct { Expr *expression; } ExpressionStmt;
 typedef struct { char *name; Expr *initializer; TypeInfo type; bool is_const; } VarDeclStmt;
-typedef struct { char *name; StringList *params; StmtList *body; TypeInfo returnType; } FuncDeclStmt;
+typedef struct { char *name; StringList *params; StmtList *body; TypeInfo returnType; bool isAsync; } FuncDeclStmt;
 typedef struct { char *name; VariableExpr *superclass; StmtList *methods; } ClassDeclStmt;
 typedef struct { StringList *modules; } UseDeclStmt;
 typedef struct { Expr *condition; Stmt *then_branch; Stmt *else_branch; } IfStmt;
@@ -163,10 +165,11 @@ Expr *createListExpr(ExprList *elements, int line, int column);
 Expr *createDictionaryExpr(DictPairList *pairs, int line, int column);
 Expr *createTernaryExpr(Expr *cond, Expr *true_br, Expr *false_br, int line, int column);
 Expr *createLambdaExpr(StringList *params, StmtList *body, int line, int column);
+Expr *createAwaitExpr(Expr *expression, int line, int column);
 
 Stmt *createExpressionStmt(Expr *expression, int line, int column);
 Stmt *createVarDeclStmt(const char *name, Expr *init, bool is_const, int line, int column);
-Stmt *createFuncDeclStmt(const char *name, StringList *params, StmtList *body, int line, int column);
+Stmt *createFuncDeclStmt(const char *name, StringList *params, StmtList *body, bool isAsync, int line, int column);
 Stmt *createClassDeclStmt(const char *name, VariableExpr *super, StmtList *methods, int line, int column);
 Stmt *createUseDeclStmt(StringList *modules, int line, int column);
 Stmt *createIfStmt(Expr *cond, Stmt *then_br, Stmt *else_br, int line, int column);

src/compiler/parser/ast.c

@@ -303,6 +303,15 @@ Expr *createLambdaExpr(StringList *params, StmtList *body, int line,
   return expr;
 }
 
+Expr *createAwaitExpr(Expr *expression, int line, int column) {
+  Expr *expr = ALLOCATE(Expr, 1);
+  expr->type = EXPR_AWAIT;
+  expr->line = line;
+  expr->column = column;
+  expr->as.await_expr.expression = expression;
+  return expr;
+}
+
 // --- Statement Creation Functions ---
 
 Stmt *createExpressionStmt(Expr *expression, int line, int column) {
@@ -332,14 +341,15 @@ Stmt *createVarDeclStmt(const char *name, Expr *init, bool is_const, int line,
 }
 
 Stmt *createFuncDeclStmt(const char *name, StringList *params, StmtList *body,
-                         int line, int column) {
+                         bool isAsync, int line, int column) {
   Stmt *stmt = ALLOCATE(Stmt, 1);
   stmt->type = STMT_FUNC_DECL;
   stmt->line = line;
   stmt->column = column;
   stmt->as.func_decl.name = strdup(name);
   stmt->as.func_decl.params = params;
   stmt->as.func_decl.body = body;
+  stmt->as.func_decl.isAsync = isAsync; 
   return stmt;
 }
 
@@ -534,6 +544,9 @@ void freeExpr(Expr *expr) {
     freeStringList(expr->as.lambda.params);
     freeStmtList(expr->as.lambda.body);
     break;
+  case EXPR_AWAIT:
+    freeExpr(expr->as.await_expr.expression);
+    break;
   }
 
   FREE(Expr, expr);

src/compiler/parser/parser.c

@@ -161,8 +161,15 @@ StmtList *parse(Parser *parser) {
 // === Declarations ===
 
 static Stmt *declaration(Parser *p) {
+  if (match(p, 1, TOKEN_ASYNC)) {
+      if (match(p, 1, TOKEN_FUNC))
+          return funcDecl(p, "function", true);
+      // TODO: Handle async arrow functions if supported later
+      parserError(p, "Expect 'func' after 'async'.");
+      return NULL;
+  }
   if (match(p, 1, TOKEN_FUNC))
-    return funcDecl(p, "function");
+    return funcDecl(p, "function", false);
   if (match(p, 1, TOKEN_CLASS))
     return classDecl(p);
   if (match(p, 1, TOKEN_USE))
@@ -172,7 +179,7 @@ static Stmt *declaration(Parser *p) {
   return statement(p);
 }
 
-static Stmt *funcDecl(Parser *p, const char *kind) {
+static Stmt *funcDecl(Parser *p, const char *kind, bool isAsync) {
   (void)kind;
   Token nameToken = consume(p, TOKEN_IDENTIFIER, "Expect function name.");
   char *name = tokenToString(nameToken);
@@ -194,7 +201,7 @@ static Stmt *funcDecl(Parser *p, const char *kind) {
 
   StmtList *body = block(p);
 
-  Stmt *stmt = createFuncDeclStmt(name, params, body, nameToken.line, 0);
+  Stmt *stmt = createFuncDeclStmt(name, params, body, isAsync, nameToken.line, 0);
   free(name);
   return stmt;
 }
@@ -216,7 +223,23 @@ static Stmt *classDecl(Parser *p) {
 
   StmtList *methods = createStmtList();
   while (!check(p, TOKEN_RIGHT_BRACE) && !isAtEnd(p)) {
-    Stmt *method = funcDecl(p, "method");
+    bool isAsync = false; 
+    if (match(p, 1, TOKEN_ASYNC)) {
+        isAsync = true;
+        // consume FUNC if present (methods might just be identifier in some langs, but here it calls funcDecl which expects identifier)
+        // Wait, funcDecl starts with identifier consumption.
+        // check if `funcDecl` handles `func` keyword? No, `declaration` consumes `func` before calling `funcDecl`.
+        // So for methods in classDecl, how are they parsed? 
+        // `createClassDeclStmt` calls `funcDecl`.
+        // `classDecl` loop calls `funcDecl(p, "method")`.
+        // `funcDecl` consumes IDENTIFIER name.
+        // So methods don't have `func` keyword?
+        // Let's check `funcDecl` implementation:
+        // `Token nameToken = consume(p, TOKEN_IDENTIFIER, "Expect function name.");`
+        // So yes, methods are `methodName() {}`.
+    }
+    // Check if `async` was consumed. If so, pass true.
+    Stmt *method = funcDecl(p, "method", isAsync);
     appendStmt(methods, method);
   }
 
@@ -596,6 +619,11 @@ static Expr *factor(Parser *p) {
 }
 
 static Expr *unary(Parser *p) {
+  if (match(p, 1, TOKEN_AWAIT)) {
+      Token op = previous(p);
+      Expr *right = unary(p);
+      return createAwaitExpr(right, op.line, 0);
+  }
   if (match(p, 2, TOKEN_BANG, TOKEN_MINUS)) {
     Token op = previous(p);
     char *opStr = tokenToString(op);