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

12 files changed, 80 insertions, 80 deletions

diff --git a/Makefile b/Makefile
index 34b9a43..776581d 100644
--- a/Makefile
+++ b/Makefile
@@ -184,7 +184,7 @@ uninstall-ape:
 
 # Clean
 clean:
-	$(RM) $(OBJ_DIR) obj-ape $(TARGET) out.c plugins/*.so a.out*
+	$(RM) $(OBJ_DIR) obj-ape $(TARGET) out.c plugins/*.so a.out* out
 	@echo "=> Clean complete!"
 
 # Test
diff --git a/src/analysis/typecheck.c b/src/analysis/typecheck.c
index b1b7f24..a0a2df1 100644
--- a/src/analysis/typecheck.c
+++ b/src/analysis/typecheck.c
@@ -29,10 +29,10 @@ static void tc_exit_scope(TypeChecker *tc)
     Scope *old = tc->current_scope;
     tc->current_scope = old->parent;
 
-    Symbol *sym = old->symbols;
+    ZenSymbol *sym = old->symbols;
     while (sym)
     {
-        Symbol *next = sym->next;
+        ZenSymbol *next = sym->next;
         free(sym);
         sym = next;
     }
@@ -41,8 +41,8 @@ static void tc_exit_scope(TypeChecker *tc)
 
 static void tc_add_symbol(TypeChecker *tc, const char *name, Type *type, Token t)
 {
-    Symbol *s = malloc(sizeof(Symbol));
-    memset(s, 0, sizeof(Symbol));
+    ZenSymbol *s = malloc(sizeof(ZenSymbol));
+    memset(s, 0, sizeof(ZenSymbol));
     s->name = strdup(name);
     s->type_info = type;
     s->decl_token = t;
@@ -50,12 +50,12 @@ static void tc_add_symbol(TypeChecker *tc, const char *name, Type *type, Token t
     tc->current_scope->symbols = s;
 }
 
-static Symbol *tc_lookup(TypeChecker *tc, const char *name)
+static ZenSymbol *tc_lookup(TypeChecker *tc, const char *name)
 {
     Scope *s = tc->current_scope;
     while (s)
     {
-        Symbol *curr = s->symbols;
+        ZenSymbol *curr = s->symbols;
         while (curr)
         {
             if (0 == strcmp(curr->name, name))
@@ -77,7 +77,7 @@ static int is_safe_to_copy(TypeChecker *tc, Type *t)
     return is_type_copy(tc->pctx, t);
 }
 
-static void check_use_validity(TypeChecker *tc, ASTNode *var_node, Symbol *sym)
+static void check_use_validity(TypeChecker *tc, ASTNode *var_node, ZenSymbol *sym)
 {
     if (!sym || !var_node)
     {
@@ -95,7 +95,7 @@ static void check_use_validity(TypeChecker *tc, ASTNode *var_node, Symbol *sym)
     }
 }
 
-static void mark_symbol_moved(TypeChecker *tc, Symbol *sym, ASTNode *context_node)
+static void mark_symbol_moved(TypeChecker *tc, ZenSymbol *sym, ASTNode *context_node)
 {
     (void)context_node;
     if (!sym)
@@ -111,7 +111,7 @@ static void mark_symbol_moved(TypeChecker *tc, Symbol *sym, ASTNode *context_nod
     }
 }
 
-static void mark_symbol_valid(TypeChecker *tc, Symbol *sym)
+static void mark_symbol_valid(TypeChecker *tc, ZenSymbol *sym)
 {
     (void)tc;
     if (sym)
@@ -135,7 +135,7 @@ static void check_expr_binary(TypeChecker *tc, ASTNode *node)
         // If RHS is a var, it might Move
         if (node->binary.right->type == NODE_EXPR_VAR)
         {
-            Symbol *rhs_sym = tc_lookup(tc, node->binary.right->var_ref.name);
+            ZenSymbol *rhs_sym = tc_lookup(tc, node->binary.right->var_ref.name);
             if (rhs_sym)
             {
                 mark_symbol_moved(tc, rhs_sym, node);
@@ -145,7 +145,7 @@ static void check_expr_binary(TypeChecker *tc, ASTNode *node)
         // LHS is being (re-)initialized, so it becomes Valid.
         if (node->binary.left->type == NODE_EXPR_VAR)
         {
-            Symbol *lhs_sym = tc_lookup(tc, node->binary.left->var_ref.name);
+            ZenSymbol *lhs_sym = tc_lookup(tc, node->binary.left->var_ref.name);
             if (lhs_sym)
             {
                 mark_symbol_valid(tc, lhs_sym);
@@ -168,7 +168,7 @@ static void check_expr_call(TypeChecker *tc, ASTNode *node)
         // If passed by ref (UNARY '&'), the child was checked but Is Not A Var Node itself.
         if (arg->type == NODE_EXPR_VAR)
         {
-            Symbol *sym = tc_lookup(tc, arg->var_ref.name);
+            ZenSymbol *sym = tc_lookup(tc, arg->var_ref.name);
             if (sym)
             {
                 mark_symbol_moved(tc, sym, node);
@@ -250,7 +250,7 @@ static void check_var_decl(TypeChecker *tc, ASTNode *node)
         // Move Analysis: If initializing from another variable, it moves.
         if (node->var_decl.init_expr->type == NODE_EXPR_VAR)
         {
-            Symbol *init_sym = tc_lookup(tc, node->var_decl.init_expr->var_ref.name);
+            ZenSymbol *init_sym = tc_lookup(tc, node->var_decl.init_expr->var_ref.name);
             if (init_sym)
             {
                 mark_symbol_moved(tc, init_sym, node);
@@ -292,7 +292,7 @@ static void check_function(TypeChecker *tc, ASTNode *node)
 
 static void check_expr_var(TypeChecker *tc, ASTNode *node)
 {
-    Symbol *sym = tc_lookup(tc, node->var_ref.name);
+    ZenSymbol *sym = tc_lookup(tc, node->var_ref.name);
     if (!sym)
     {
         // Check global functions/contexts if not found in locals
@@ -372,7 +372,7 @@ static void check_node(TypeChecker *tc, ASTNode *node)
             // If returning a variable by value, it is moved.
             if (node->ret.value->type == NODE_EXPR_VAR)
             {
-                Symbol *sym = tc_lookup(tc, node->ret.value->var_ref.name);
+                ZenSymbol *sym = tc_lookup(tc, node->ret.value->var_ref.name);
                 if (sym)
                 {
                     mark_symbol_moved(tc, sym, node);
diff --git a/src/codegen/codegen_utils.c b/src/codegen/codegen_utils.c
index 6283bce..c48f4eb 100644
--- a/src/codegen/codegen_utils.c
+++ b/src/codegen/codegen_utils.c
@@ -186,7 +186,7 @@ char *infer_type(ParserContext *ctx, ASTNode *node)
 
     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)
         {
             if (sym->type_name)
@@ -273,7 +273,7 @@ char *infer_type(ParserContext *ctx, ASTNode *node)
 
         if (node->call.callee->type == NODE_EXPR_VAR)
         {
-            Symbol *sym = find_symbol_entry(ctx, node->call.callee->var_ref.name);
+            ZenSymbol *sym = find_symbol_entry(ctx, node->call.callee->var_ref.name);
             if (sym && sym->type_info && sym->type_info->kind == TYPE_FUNCTION &&
                 sym->type_info->inner)
             {
diff --git a/src/lsp/lsp_analysis.c b/src/lsp/lsp_analysis.c
index 9fe42f9..2a07990 100644
--- a/src/lsp/lsp_analysis.c
+++ b/src/lsp/lsp_analysis.c
@@ -367,7 +367,7 @@ void lsp_completion(const char *uri, int line, int col, int id)
                     strncpy(var_name, ptr + start_ident, len);
                     var_name[len] = 0;
 
-                    Symbol *sym = find_symbol_in_all(g_project->ctx, var_name);
+                    ZenSymbol *sym = find_symbol_in_all(g_project->ctx, var_name);
                     char *type_name = NULL;
                     if (sym)
                     {
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);
diff --git a/src/zprep.h b/src/zprep.h
index 4d71c28..23db911 100644
--- a/src/zprep.h
+++ b/src/zprep.h
@@ -10,7 +10,7 @@
 #include <unistd.h>
 
 #ifdef __COSMOPOLITAN__
-#include <cosmopolitan.h>
+#include <cosmo.h>
 #define z_is_windows() IsWindows()
 #else
 #ifdef _WIN32