Bug fixes with the error system in the parser and updated the char to byte to make it clear that it is one byte

Author: TheDevConnor

src/helper/help.h

@@ -21,14 +21,14 @@
 
 /** Macro to access token at index in a token growable array */
 #define TOKEN_AT(i) (((Token *)tokens.data)[(i)])
-#define MAX_TOKENS 100
+#define MAX_TOKENS 300
 
 #define BAR_WIDTH 40
 
 /** Enable debug logs for arena allocator (comment to disable) */
 #define DEBUG_ARENA_ALLOC 1
 
-#define Luma_Compiler_version "v0.1.0"
+#define Luma_Compiler_version "v0.1.2"
 
 /** Error codes returned by the compiler */
 typedef enum {

src/parser/expr.c

@@ -92,8 +92,14 @@ Expr *unary(Parser *parser) {
   UnaryOp op = TOKEN_TO_UNOP_MAP[current.type_];
 
   if (op) {
-    p_advance(parser); // Consume the token
+    p_advance(parser);
     Expr *operand = parse_expr(parser, BP_UNARY);
+    if (!operand) {
+      parser_error(parser, "SyntaxError", parser->file_path,
+                   "Expected expression after unary operator", line, col,
+                   current.length);
+      return NULL;
+    }
     return create_unary_expr(parser->arena, op, operand, line, col);
   }
 
@@ -116,9 +122,16 @@ Expr *binary(Parser *parser, Expr *left, BindingPower bp) {
 
   Token current = p_current(parser);
   BinaryOp op = TOKEN_TO_BINOP_MAP[current.type_];
-  p_advance(parser); // Consume the token
+  p_advance(parser);
   Expr *right = parse_expr(parser, bp);
 
+  if (!right) {
+    parser_error(parser, "SyntaxError", parser->file_path,
+                 "Expected expression after binary operator", line, col,
+                 current.length);
+    return NULL;
+  }
+
   return create_binary_expr(parser->arena, op, left, right, line, col);
 }
 
@@ -509,24 +522,24 @@ Expr *free_expr(Parser *parser) {
 Expr *cast_expr(Parser *parser) {
   int line = p_current(parser).line;
   int col = p_current(parser).col;
-  
+
   p_advance(parser); // Advance past 'cast'
 
   p_consume(parser, TOK_LT,
             "Expected a '<' before you declare the type you want to cast to.");
-  
+
   Type *cast_type = parse_type(parser);
   // parse_type() has already advanced past the type
-  
+
   p_consume(parser, TOK_GT,
             "Expected a '>' after defining the type you want to cast to, but "
             "before defining what you are casting");
-  
+
   p_consume(parser, TOK_LPAREN,
             "Expected a '(' before defining what you are casting");
-  
+
   Expr *castee = parse_expr(parser, BP_NONE);
-  
+
   p_consume(parser, TOK_RPAREN,
             "Expected a ')' after defining what you are casting");
 
@@ -537,23 +550,23 @@ Expr *cast_expr(Parser *parser) {
 Expr *input_expr(Parser *parser) {
   int line = p_current(parser).line;
   int col = p_current(parser).col;
-  
+
   p_advance(parser); // Advance past 'input'
 
   p_consume(parser, TOK_LT,
             "Expected a '<' before you declare the type you want to input.");
-  
+
   Type *type = parse_type(parser);
   // parse_type() has already advanced past the type
-  
+
   p_consume(parser, TOK_GT,
             "Expected a '>' after defining the type you want to input");
-  
+
   p_consume(parser, TOK_LPAREN,
             "Expected a '(' before defining the input message");
-  
+
   Expr *msg = parse_expr(parser, BP_NONE);
-  
+
   p_consume(parser, TOK_RPAREN,
             "Expected a ')' after defining the input message");
 
@@ -622,13 +635,13 @@ Expr *syscall_expr(Parser *parser) {
 Expr *sizeof_expr(Parser *parser) {
   int line = p_current(parser).line;
   int col = p_current(parser).col;
-  
+
   p_advance(parser); // Advance past 'sizeof'
-  
+
   p_consume(parser, TOK_LT,
             "Expected a '<' before defining the var or type you want to get "
             "the size of.");
-  
+
   AstNode *object = NULL;
   bool is_type = false;
 
@@ -643,7 +656,7 @@ Expr *sizeof_expr(Parser *parser) {
     object = (AstNode *)parse_expr(parser, BP_NONE);
     is_type = false;
   }
-  
+
   p_consume(parser, TOK_GT,
             "Expected a '>' after defining the var or type you want to get the "
             "size of.");

src/parser/parser.c

@@ -109,6 +109,7 @@ Stmt *parse(GrowableArray *tks, ArenaAllocator *arena, BuildConfig *config) {
   Token module_tok = p_current(&parser);
   const char *module_name = parse_module_declaration(&parser);
   if (!module_name) {
+    error_report(); // CRITICAL: Report errors before returning
     return NULL;
   }
 
@@ -127,13 +128,15 @@ Stmt *parse(GrowableArray *tks, ArenaAllocator *arena, BuildConfig *config) {
   while (p_current(&parser).type_ != TOK_EOF) {
     Stmt *stmt = parse_stmt(&parser);
     if (!stmt) {
-      // Error already reported in parse_stmt
+      // CRITICAL: Report accumulated errors before returning
+      error_report();
       return NULL;
     }
 
     Stmt **slot = (Stmt **)growable_array_push(&stmts);
     if (!slot) {
       fprintf(stderr, "Out of memory while growing statements array\n");
+      error_report(); // Report any errors before returning
       return NULL;
     }
     *slot = stmt;
@@ -148,6 +151,7 @@ Stmt *parse(GrowableArray *tks, ArenaAllocator *arena, BuildConfig *config) {
   return create_program_node(parser.arena, (AstNode **)modules.data,
                              modules.count, 0, 0);
 }
+
 /**
  * @brief Gets the binding power (precedence) for a given token type
  *
@@ -524,8 +528,8 @@ Type *parse_type(Parser *parser) {
   case TOK_STRINGT:
   case TOK_VOID:
   case TOK_CHAR:
-  case TOK_STAR:     // Pointer type
-  case TOK_LBRACKET: // Array type
+  case TOK_STAR:       // Pointer type
+  case TOK_LBRACKET:   // Array type
   case TOK_IDENTIFIER: // Could be simple type or namespace::Type
     return tnud(parser);
 

src/parser/parser_utils.c

@@ -158,12 +158,17 @@ Token p_consume(Parser *psr, LumaTokenType type, const char *error_msg) {
   int line = p_current(psr).line;
   int col = p_current(psr).col;
 
-  if (p_current(psr).type_ == type)
+  if (p_current(psr).type_ == type) {
     return p_advance(psr);
-  else {
-    parser_error(psr, "SyntaxError", "unknown_file", error_msg, line, col,
+  } else {
+    parser_error(psr, "SyntaxError", psr->file_path, error_msg, line, col,
                  CURRENT_TOKEN_LENGTH(psr));
-    return (Token){.type_ = TOK_EOF}; // Return an error token
+
+    // CRITICAL: Set a flag or return a recognizable error token
+    // The parser should check for this and abort
+    Token error_tok = {
+        .type_ = TOK_EOF, .line = line, .col = col, .length = 0, .value = NULL};
+    return error_tok;
   }
 }