Include correct header file and refactor code to prevent redefinition.v0.1.3bexperimental

7 files changed, 60 insertions, 60 deletions

diff --git a/src/parser/parser.h b/src/parser/parser.h
index e1d6bb9..7353570 100644
--- a/src/parser/parser.h
+++ b/src/parser/parser.h
@@ -32,7 +32,7 @@ ASTNode *parse_program(ParserContext *ctx, Lexer *l);
 extern ParserContext *g_parser_ctx;
 
 // Symbol table
-typedef struct Symbol
+typedef struct ZenSymbol
 {
     char *name;
     char *type_name;
@@ -44,12 +44,12 @@ typedef struct Symbol
     int is_def;
     int const_int_val;
     int is_moved;
-    struct Symbol *next;
-} Symbol;
+    struct ZenSymbol *next;
+} ZenSymbol;
 
 typedef struct Scope
 {
-    Symbol *symbols;
+    ZenSymbol *symbols;
     struct Scope *parent;
 } Scope;
 
@@ -256,7 +256,7 @@ struct ParserContext
     void (*on_error)(void *data, Token t, const char *msg);
 
     // LSP: Flat symbol list (persists after parsing for LSP queries)
-    Symbol *all_symbols;
+    ZenSymbol *all_symbols;
 
     // External C interop: suppress undefined warnings for external symbols
     int has_external_includes; // Set when include <...> is used
@@ -299,7 +299,7 @@ char *consume_and_rewrite(ParserContext *ctx, Lexer *l);
 int is_c_reserved_word(const char *name);
 void warn_c_reserved_word(Token t, const char *name);
 
-// Symbol table
+// ZenSymbol table
 void enter_scope(ParserContext *ctx);
 void exit_scope(ParserContext *ctx);
 void add_symbol(ParserContext *ctx, const char *n, const char *t, Type *type_info);
@@ -307,8 +307,8 @@ void add_symbol_with_token(ParserContext *ctx, const char *n, const char *t, Typ
                            Token tok);
 Type *find_symbol_type_info(ParserContext *ctx, const char *n);
 char *find_symbol_type(ParserContext *ctx, const char *n);
-Symbol *find_symbol_entry(ParserContext *ctx, const char *n);
-Symbol *find_symbol_in_all(ParserContext *ctx,
+ZenSymbol *find_symbol_entry(ParserContext *ctx, const char *n);
+ZenSymbol *find_symbol_in_all(ParserContext *ctx,
                            const char *n); // LSP flat lookup
 char *find_similar_symbol(ParserContext *ctx, const char *name);
 
diff --git a/src/parser/parser_decl.c b/src/parser/parser_decl.c
index 5d5af1e..c5df863 100644
--- a/src/parser/parser_decl.c
+++ b/src/parser/parser_decl.c
@@ -150,7 +150,7 @@ ASTNode *parse_function(ParserContext *ctx, Lexer *l, int is_async)
     // scope for body) Only check if we parsed a body (not a prototype) function
     if (body && ctx->current_scope)
     {
-        Symbol *sym = ctx->current_scope->symbols;
+        ZenSymbol *sym = ctx->current_scope->symbols;
         while (sym)
         {
             // Check if unused and not prefixed with '_' (conventional ignore)
@@ -624,7 +624,7 @@ ASTNode *parse_var_decl(ParserContext *ctx, Lexer *l)
     // NEW: Capture Const Integer Values
     if (init && init->type == NODE_EXPR_LITERAL && init->literal.type_kind == LITERAL_INT)
     {
-        Symbol *s = find_symbol_entry(ctx, name); // Helper to find the struct
+        ZenSymbol *s = find_symbol_entry(ctx, name); // Helper to find the struct
         if (s)
         {
             s->is_const_value = 1;
@@ -669,7 +669,7 @@ ASTNode *parse_var_decl(ParserContext *ctx, Lexer *l)
         Type *t = find_symbol_type_info(ctx, init->var_ref.name);
         if (!t)
         {
-            Symbol *s = find_symbol_entry(ctx, init->var_ref.name);
+            ZenSymbol *s = find_symbol_entry(ctx, init->var_ref.name);
             if (s)
             {
                 t = s->type_info;
@@ -677,7 +677,7 @@ ASTNode *parse_var_decl(ParserContext *ctx, Lexer *l)
         }
         if (!is_type_copy(ctx, t))
         {
-            Symbol *s = find_symbol_entry(ctx, init->var_ref.name);
+            ZenSymbol *s = find_symbol_entry(ctx, init->var_ref.name);
             if (s)
             {
                 s->is_moved = 1;
@@ -752,7 +752,7 @@ ASTNode *parse_def(ParserContext *ctx, Lexer *l)
 
     // Use is_def flag for manifest constants
     add_symbol(ctx, ns, type_str ? type_str : "unknown", type_obj);
-    Symbol *sym_entry = find_symbol_entry(ctx, ns);
+    ZenSymbol *sym_entry = find_symbol_entry(ctx, ns);
     if (sym_entry)
     {
         sym_entry->is_def = 1;
@@ -770,7 +770,7 @@ ASTNode *parse_def(ParserContext *ctx, Lexer *l)
             Token val_tok = lexer_peek(l);
             int val = atoi(token_strdup(val_tok)); // quick check
 
-            Symbol *s = find_symbol_entry(ctx, ns);
+            ZenSymbol *s = find_symbol_entry(ctx, ns);
             if (s)
             {
                 s->is_const_value = 1;
diff --git a/src/parser/parser_expr.c b/src/parser/parser_expr.c
index b07b544..638d668 100644
--- a/src/parser/parser_expr.c
+++ b/src/parser/parser_expr.c
@@ -133,7 +133,7 @@ void check_move_usage(ParserContext *ctx, ASTNode *node, Token t)
     }
     if (node->type == NODE_EXPR_VAR)
     {
-        Symbol *sym = find_symbol_entry(ctx, node->var_ref.name);
+        ZenSymbol *sym = find_symbol_entry(ctx, node->var_ref.name);
         if (sym && sym->is_moved)
         {
             zpanic_at(t, "Use of moved value '%s'", node->var_ref.name);
@@ -716,7 +716,7 @@ void analyze_lambda_captures(ParserContext *ctx, ASTNode *lambda)
         int is_found = 0;
         while (s)
         {
-            Symbol *cur = s->symbols;
+            ZenSymbol *cur = s->symbols;
             while (cur)
             {
                 if (0 == strcmp(cur->name, var_name))
@@ -993,7 +993,7 @@ static ASTNode *create_fstring_block(ParserContext *ctx, const char *content)
 
         if (expr_node && expr_node->type == NODE_EXPR_VAR)
         {
-            Symbol *sym = find_symbol_entry(ctx, expr_node->var_ref.name);
+            ZenSymbol *sym = find_symbol_entry(ctx, expr_node->var_ref.name);
             if (sym)
             {
                 sym->is_used = 1;
@@ -2328,7 +2328,7 @@ ASTNode *parse_primary(ParserContext *ctx, Lexer *l)
                         Type *t = find_symbol_type_info(ctx, arg->var_ref.name);
                         if (!t)
                         {
-                            Symbol *s = find_symbol_entry(ctx, arg->var_ref.name);
+                            ZenSymbol *s = find_symbol_entry(ctx, arg->var_ref.name);
                             if (s)
                             {
                                 t = s->type_info;
@@ -2337,7 +2337,7 @@ ASTNode *parse_primary(ParserContext *ctx, Lexer *l)
 
                         if (!is_type_copy(ctx, t))
                         {
-                            Symbol *s = find_symbol_entry(ctx, arg->var_ref.name);
+                            ZenSymbol *s = find_symbol_entry(ctx, arg->var_ref.name);
                             if (s)
                             {
                                 s->is_moved = 1;
@@ -2587,7 +2587,7 @@ ASTNode *parse_primary(ParserContext *ctx, Lexer *l)
                         Type *t = find_symbol_type_info(ctx, arg->var_ref.name);
                         if (!t)
                         {
-                            Symbol *s = find_symbol_entry(ctx, arg->var_ref.name);
+                            ZenSymbol *s = find_symbol_entry(ctx, arg->var_ref.name);
                             if (s)
                             {
                                 t = s->type_info;
@@ -2596,7 +2596,7 @@ ASTNode *parse_primary(ParserContext *ctx, Lexer *l)
 
                         if (!is_type_copy(ctx, t))
                         {
-                            Symbol *s = find_symbol_entry(ctx, arg->var_ref.name);
+                            ZenSymbol *s = find_symbol_entry(ctx, arg->var_ref.name);
                             if (s)
                             {
                                 s->is_moved = 1;
@@ -2647,7 +2647,7 @@ ASTNode *parse_primary(ParserContext *ctx, Lexer *l)
         }
         else
         {
-            Symbol *sym = find_symbol_entry(ctx, acc);
+            ZenSymbol *sym = find_symbol_entry(ctx, acc);
             if (sym && sym->is_def && sym->is_const_value)
             {
                 // Constant Folding for 'def', emits literal
@@ -2998,7 +2998,7 @@ ASTNode *parse_primary(ParserContext *ctx, Lexer *l)
                         Type *t = find_symbol_type_info(ctx, arg->var_ref.name);
                         if (!t)
                         {
-                            Symbol *s = find_symbol_entry(ctx, arg->var_ref.name);
+                            ZenSymbol *s = find_symbol_entry(ctx, arg->var_ref.name);
                             if (s)
                             {
                                 t = s->type_info;
@@ -3007,7 +3007,7 @@ ASTNode *parse_primary(ParserContext *ctx, Lexer *l)
 
                         if (!is_type_copy(ctx, t))
                         {
-                            Symbol *s = find_symbol_entry(ctx, arg->var_ref.name);
+                            ZenSymbol *s = find_symbol_entry(ctx, arg->var_ref.name);
                             if (s)
                             {
                                 s->is_moved = 1;
@@ -3746,7 +3746,7 @@ ASTNode *parse_expr_prec(ParserContext *ctx, Lexer *l, Precedence min_prec)
 
         if (is_token(t, "&") && operand->type == NODE_EXPR_VAR)
         {
-            Symbol *s = find_symbol_entry(ctx, operand->var_ref.name);
+            ZenSymbol *s = find_symbol_entry(ctx, operand->var_ref.name);
             if (s && s->is_def)
             {
                 zpanic_at(t,
@@ -4282,7 +4282,7 @@ ASTNode *parse_expr_prec(ParserContext *ctx, Lexer *l, Precedence min_prec)
                         Type *t = find_symbol_type_info(ctx, arg->var_ref.name);
                         if (!t)
                         {
-                            Symbol *s = find_symbol_entry(ctx, arg->var_ref.name);
+                            ZenSymbol *s = find_symbol_entry(ctx, arg->var_ref.name);
                             if (s)
                             {
                                 t = s->type_info;
@@ -4291,7 +4291,7 @@ ASTNode *parse_expr_prec(ParserContext *ctx, Lexer *l, Precedence min_prec)
 
                         if (!is_type_copy(ctx, t))
                         {
-                            Symbol *s = find_symbol_entry(ctx, arg->var_ref.name);
+                            ZenSymbol *s = find_symbol_entry(ctx, arg->var_ref.name);
                             if (s)
                             {
                                 s->is_moved = 1;
@@ -4882,7 +4882,7 @@ ASTNode *parse_expr_prec(ParserContext *ctx, Lexer *l, Precedence min_prec)
                 // If type info not on var, try looking up symbol
                 if (!t)
                 {
-                    Symbol *s = find_symbol_entry(ctx, rhs->var_ref.name);
+                    ZenSymbol *s = find_symbol_entry(ctx, rhs->var_ref.name);
                     if (s)
                     {
                         t = s->type_info;
@@ -4891,7 +4891,7 @@ ASTNode *parse_expr_prec(ParserContext *ctx, Lexer *l, Precedence min_prec)
 
                 if (!is_type_copy(ctx, t))
                 {
-                    Symbol *s = find_symbol_entry(ctx, rhs->var_ref.name);
+                    ZenSymbol *s = find_symbol_entry(ctx, rhs->var_ref.name);
                     if (s)
                     {
                         s->is_moved = 1;
@@ -4902,7 +4902,7 @@ ASTNode *parse_expr_prec(ParserContext *ctx, Lexer *l, Precedence min_prec)
             // 3. LHS is being written: Resurrect (it is now valid)
             if (lhs->type == NODE_EXPR_VAR)
             {
-                Symbol *s = find_symbol_entry(ctx, lhs->var_ref.name);
+                ZenSymbol *s = find_symbol_entry(ctx, lhs->var_ref.name);
                 if (s)
                 {
                     s->is_moved = 0;
@@ -5283,7 +5283,7 @@ ASTNode *parse_expr_prec(ParserContext *ctx, Lexer *l, Precedence min_prec)
                         // If rhs is a variable reference without type_info, look it up
                         if (!rt && rhs->type == NODE_EXPR_VAR)
                         {
-                            Symbol *sym = find_symbol_entry(ctx, rhs->var_ref.name);
+                            ZenSymbol *sym = find_symbol_entry(ctx, rhs->var_ref.name);
                             if (sym && sym->type_info)
                             {
                                 rt = sym->type_info;
@@ -5341,7 +5341,7 @@ ASTNode *parse_expr_prec(ParserContext *ctx, Lexer *l, Precedence min_prec)
             // Ensure type_info is set for variables (critical for inference)
             if (lhs->type == NODE_EXPR_VAR && !lhs->type_info)
             {
-                Symbol *s = find_symbol_entry(ctx, lhs->var_ref.name);
+                ZenSymbol *s = find_symbol_entry(ctx, lhs->var_ref.name);
                 if (s)
                 {
                     lhs->type_info = s->type_info;
@@ -5349,7 +5349,7 @@ ASTNode *parse_expr_prec(ParserContext *ctx, Lexer *l, Precedence min_prec)
             }
             if (rhs->type == NODE_EXPR_VAR && !rhs->type_info)
             {
-                Symbol *s = find_symbol_entry(ctx, rhs->var_ref.name);
+                ZenSymbol *s = find_symbol_entry(ctx, rhs->var_ref.name);
                 if (s)
                 {
                     rhs->type_info = s->type_info;
@@ -5363,10 +5363,10 @@ ASTNode *parse_expr_prec(ParserContext *ctx, Lexer *l, Precedence min_prec)
                 rhs->type_info->kind != TYPE_UNKNOWN)
             {
                 // Infer LHS type from RHS
-                Symbol *sym = find_symbol_entry(ctx, lhs->var_ref.name);
+                ZenSymbol *sym = find_symbol_entry(ctx, lhs->var_ref.name);
                 if (sym)
                 {
-                    // Update Symbol
+                    // Update ZenSymbol
                     sym->type_info = rhs->type_info;
                     sym->type_name = type_to_string(rhs->type_info);
 
@@ -5382,10 +5382,10 @@ ASTNode *parse_expr_prec(ParserContext *ctx, Lexer *l, Precedence min_prec)
                 lhs->type_info->kind != TYPE_UNKNOWN)
             {
                 // Infer RHS type from LHS
-                Symbol *sym = find_symbol_entry(ctx, rhs->var_ref.name);
+                ZenSymbol *sym = find_symbol_entry(ctx, rhs->var_ref.name);
                 if (sym)
                 {
-                    // Update Symbol
+                    // Update ZenSymbol
                     sym->type_info = lhs->type_info;
                     sym->type_name = type_to_string(lhs->type_info);
 
@@ -5516,10 +5516,10 @@ ASTNode *parse_expr_prec(ParserContext *ctx, Lexer *l, Precedence min_prec)
                             rhs->type_info->kind != TYPE_UNKNOWN)
                         {
                             // Infer LHS type from RHS
-                            Symbol *sym = find_symbol_entry(ctx, lhs->var_ref.name);
+                            ZenSymbol *sym = find_symbol_entry(ctx, lhs->var_ref.name);
                             if (sym)
                             {
-                                // Update Symbol
+                                // Update ZenSymbol
                                 sym->type_info = rhs->type_info;
                                 sym->type_name = type_to_string(rhs->type_info);
 
@@ -5538,10 +5538,10 @@ ASTNode *parse_expr_prec(ParserContext *ctx, Lexer *l, Precedence min_prec)
                             lhs->type_info->kind != TYPE_UNKNOWN)
                         {
                             // Infer RHS type from LHS
-                            Symbol *sym = find_symbol_entry(ctx, rhs->var_ref.name);
+                            ZenSymbol *sym = find_symbol_entry(ctx, rhs->var_ref.name);
                             if (sym)
                             {
-                                // Update Symbol
+                                // Update ZenSymbol
                                 sym->type_info = lhs->type_info;
                                 sym->type_name = type_to_string(lhs->type_info);
 
@@ -5637,7 +5637,7 @@ ASTNode *parse_arrow_lambda_single(ParserContext *ctx, Lexer *l, char *param_nam
     }
 
     // Update parameter types from symbol table (in case inference happened)
-    Symbol *sym = find_symbol_entry(ctx, param_name);
+    ZenSymbol *sym = find_symbol_entry(ctx, param_name);
     if (sym && sym->type_info && sym->type_info->kind != TYPE_UNKNOWN)
     {
         free(lambda->lambda.param_types[0]);
diff --git a/src/parser/parser_stmt.c b/src/parser/parser_stmt.c
index 303f6ac..9782a26 100644
--- a/src/parser/parser_stmt.c
+++ b/src/parser/parser_stmt.c
@@ -1463,7 +1463,7 @@ char *process_printf_sugar(ParserContext *ctx, const char *content, int newline,
                 if (t.type == TOK_IDENT)
                 {
                     char *name = token_strdup(t);
-                    Symbol *sym = find_symbol_entry(ctx, name);
+                    ZenSymbol *sym = find_symbol_entry(ctx, name);
                     if (sym)
                     {
                         sym->is_used = 1;
@@ -1933,7 +1933,7 @@ ASTNode *parse_statement(ParserContext *ctx, Lexer *l)
         s = parse_var_decl(ctx, l);
         s->var_decl.is_autofree = 1;
         // Mark symbol as autofree to suppress unused variable warning
-        Symbol *sym = find_symbol_entry(ctx, s->var_decl.name);
+        ZenSymbol *sym = find_symbol_entry(ctx, s->var_decl.name);
         if (sym)
         {
             sym->is_autofree = 1;
@@ -2617,7 +2617,7 @@ ASTNode *parse_block(ParserContext *ctx, Lexer *l)
     // Check for unused variables in this block scope
     if (ctx->current_scope && !ctx->is_repl)
     {
-        Symbol *sym = ctx->current_scope->symbols;
+        ZenSymbol *sym = ctx->current_scope->symbols;
         while (sym)
         {
             // Skip special names and already warned
diff --git a/src/parser/parser_struct.c b/src/parser/parser_struct.c
index 8eed017..e776bb8 100644
--- a/src/parser/parser_struct.c
+++ b/src/parser/parser_struct.c
@@ -205,7 +205,7 @@ ASTNode *parse_impl(ParserContext *ctx, Lexer *l)
         // RAII: Check for "Drop" trait implementation
         if (strcmp(name1, "Drop") == 0)
         {
-            Symbol *s = find_symbol_entry(ctx, name2);
+            ZenSymbol *s = find_symbol_entry(ctx, name2);
             if (s && s->type_info)
             {
                 s->type_info->traits.has_drop = 1;
@@ -224,7 +224,7 @@ ASTNode *parse_impl(ParserContext *ctx, Lexer *l)
         // Iterator: Check for "Iterable" trait implementation
         else if (strcmp(name1, "Iterable") == 0)
         {
-            Symbol *s = find_symbol_entry(ctx, name2);
+            ZenSymbol *s = find_symbol_entry(ctx, name2);
             if (s && s->type_info)
             {
                 s->type_info->traits.has_iterable = 1;
diff --git a/src/parser/parser_type.c b/src/parser/parser_type.c
index 0585baa..c01f061 100644
--- a/src/parser/parser_type.c
+++ b/src/parser/parser_type.c
@@ -634,7 +634,7 @@ Type *parse_type_base(ParserContext *ctx, Lexer *l)
             {
                 // Look up in symbol table for constant propagation
                 char *name = token_strdup(size_tok);
-                Symbol *sym = find_symbol_entry(ctx, name);
+                ZenSymbol *sym = find_symbol_entry(ctx, name);
                 if (sym && sym->is_const_value)
                 {
                     size = sym->const_int_val;
@@ -846,7 +846,7 @@ Type *parse_type_formal(ParserContext *ctx, Lexer *l)
         {
             Token t = lexer_peek(l);
             char *name = token_strdup(t);
-            Symbol *sym = find_symbol_entry(ctx, name);
+            ZenSymbol *sym = find_symbol_entry(ctx, name);
             if (sym && sym->is_const_value)
             {
                 size = sym->const_int_val;
diff --git a/src/parser/parser_utils.c b/src/parser/parser_utils.c
index 496db9e..385d36c 100644
--- a/src/parser/parser_utils.c
+++ b/src/parser/parser_utils.c
@@ -125,7 +125,7 @@ void exit_scope(ParserContext *ctx)
     }
 
     // Check for unused variables
-    Symbol *sym = ctx->current_scope->symbols;
+    ZenSymbol *sym = ctx->current_scope->symbols;
     while (sym)
     {
         if (!sym->is_used && strcmp(sym->name, "self") != 0 && sym->name[0] != '_')
@@ -156,7 +156,7 @@ void add_symbol_with_token(ParserContext *ctx, const char *n, const char *t, Typ
         Scope *p = ctx->current_scope->parent;
         while (p)
         {
-            Symbol *sh = p->symbols;
+            ZenSymbol *sh = p->symbols;
             while (sh)
             {
                 if (strcmp(sh->name, n) == 0)
@@ -173,7 +173,7 @@ void add_symbol_with_token(ParserContext *ctx, const char *n, const char *t, Typ
             p = p->parent;
         }
     }
-    Symbol *s = xmalloc(sizeof(Symbol));
+    ZenSymbol *s = xmalloc(sizeof(ZenSymbol));
     s->name = xstrdup(n);
     s->type_name = t ? xstrdup(t) : NULL;
     s->type_info = type_info;
@@ -184,7 +184,7 @@ void add_symbol_with_token(ParserContext *ctx, const char *n, const char *t, Typ
     ctx->current_scope->symbols = s;
 
     // LSP: Also add to flat list (for persistent access after scope exit)
-    Symbol *lsp_copy = xmalloc(sizeof(Symbol));
+    ZenSymbol *lsp_copy = xmalloc(sizeof(ZenSymbol));
     *lsp_copy = *s;
     lsp_copy->next = ctx->all_symbols;
     ctx->all_symbols = lsp_copy;
@@ -199,7 +199,7 @@ Type *find_symbol_type_info(ParserContext *ctx, const char *n)
     Scope *s = ctx->current_scope;
     while (s)
     {
-        Symbol *sym = s->symbols;
+        ZenSymbol *sym = s->symbols;
         while (sym)
         {
             if (strcmp(sym->name, n) == 0)
@@ -222,7 +222,7 @@ char *find_symbol_type(ParserContext *ctx, const char *n)
     Scope *s = ctx->current_scope;
     while (s)
     {
-        Symbol *sym = s->symbols;
+        ZenSymbol *sym = s->symbols;
         while (sym)
         {
             if (strcmp(sym->name, n) == 0)
@@ -236,7 +236,7 @@ char *find_symbol_type(ParserContext *ctx, const char *n)
     return NULL;
 }
 
-Symbol *find_symbol_entry(ParserContext *ctx, const char *n)
+ZenSymbol *find_symbol_entry(ParserContext *ctx, const char *n)
 {
     if (!ctx->current_scope)
     {
@@ -245,7 +245,7 @@ Symbol *find_symbol_entry(ParserContext *ctx, const char *n)
     Scope *s = ctx->current_scope;
     while (s)
     {
-        Symbol *sym = s->symbols;
+        ZenSymbol *sym = s->symbols;
         while (sym)
         {
             if (strcmp(sym->name, n) == 0)
@@ -260,9 +260,9 @@ Symbol *find_symbol_entry(ParserContext *ctx, const char *n)
 }
 
 // LSP: Search flat symbol list (works after scopes are destroyed).
-Symbol *find_symbol_in_all(ParserContext *ctx, const char *n)
+ZenSymbol *find_symbol_in_all(ParserContext *ctx, const char *n)
 {
-    Symbol *sym = ctx->all_symbols;
+    ZenSymbol *sym = ctx->all_symbols;
     while (sym)
     {
         if (strcmp(sym->name, n) == 0)
@@ -3423,7 +3423,7 @@ char *find_similar_symbol(ParserContext *ctx, const char *name)
     Scope *s = ctx->current_scope;
     while (s)
     {
-        Symbol *sym = s->symbols;
+        ZenSymbol *sym = s->symbols;
         while (sym)
         {
             int dist = levenshtein(name, sym->name);