feat: introduce AST node creation functions and parser structure

Author: ProgrammerKR

src/compiler/parser/ast.c

@@ -312,6 +312,33 @@ Expr *createAwaitExpr(Expr *expression, int line, int column) {
   return expr;
 }
 
+Expr *createThisExpr(int line, int column) {
+  Expr *expr = ALLOCATE(Expr, 1);
+  expr->type = EXPR_THIS;
+  expr->line = line;
+  expr->column = column;
+  return expr;
+}
+
+Expr *createSuperExpr(const char *method, int line, int column) {
+  Expr *expr = ALLOCATE(Expr, 1);
+  expr->type = EXPR_SUPER;
+  expr->line = line;
+  expr->column = column;
+  expr->as.super_expr.method = method ? strdup(method) : NULL;
+  return expr;
+}
+
+Expr *createNewExpr(Expr *clazz, ExprList *args, int line, int column) {
+  Expr *expr = ALLOCATE(Expr, 1);
+  expr->type = EXPR_NEW;
+  expr->line = line;
+  expr->column = column;
+  expr->as.new_expr.clazz = clazz;
+  expr->as.new_expr.args = args;
+  return expr;
+}
+
 // --- Statement Creation Functions ---
 
 Stmt *createExpressionStmt(Expr *expression, int line, int column) {
@@ -573,6 +600,16 @@ void freeExpr(Expr *expr) {
   case EXPR_AWAIT:
     freeExpr(expr->as.await_expr.expression);
     break;
+  case EXPR_THIS:
+    // Nothing to free
+    break;
+  case EXPR_SUPER:
+    if (expr->as.super_expr.method) free(expr->as.super_expr.method);
+    break;
+  case EXPR_NEW:
+    freeExpr(expr->as.new_expr.clazz);
+    freeExprList(expr->as.new_expr.args);
+    break;
   }
 
   FREE(Expr, expr);

src/compiler/parser/parser.c

@@ -857,6 +857,47 @@ static Expr *primary(Parser *p) {
     return expr;
   }
 
+    return expr;
+  }
+
+  if (match(p, 1, TOKEN_THIS)) {
+      return createThisExpr(previous(p).line, 0);
+  }
+
+  if (match(p, 1, TOKEN_SUPER)) {
+      Token keyword = previous(p);
+      consume(p, TOKEN_DOT, "Expect '.' after 'super'.");
+      Token method = consume(p, TOKEN_IDENTIFIER, "Expect superclass method name.");
+      char *methodName = tokenToString(method);
+      Expr *expr = createSuperExpr(methodName, keyword.line, 0);
+      free(methodName);
+      return expr;
+  }
+
+  if (match(p, 1, TOKEN_NEW)) {
+      Token keyword = previous(p);
+      // createNewExpr expects an Expr* for the class/callee
+      // Parse the class name (or expression evaluating to class)
+      // Usually "new Identifier(args)" or "new Identifier"
+      // Let's assume syntax: new Primary() or new Primary
+      // Using call() logic but starting with primary?
+      // Actually standard: new CallExpr
+      // Parse primary for class
+      Expr *clazz = primary(p); // Recursive primary? `new Foo` -> variable `Foo`
+      
+      ExprList *args = createExprList();
+      if (match(p, 1, TOKEN_LEFT_PAREN)) {
+           if (!check(p, TOKEN_RIGHT_PAREN)) {
+             do {
+               appendExpr(args, expression(p));
+             } while (match(p, 1, TOKEN_COMMA));
+           }
+           consume(p, TOKEN_RIGHT_PAREN, "Expect ')' after arguments.");
+      }
+      
+      return createNewExpr(clazz, args, keyword.line, 0);
+  }
+
   if (match(p, 1, TOKEN_IDENTIFIER)) {
     Token token = previous(p);
     char *name = tokenToString(token);