Merge branch 'main' of https://github.com/z-libs/Zen-C into patch-1

6 files changed, 415 insertions, 141 deletions

diff --git a/src/codegen/codegen.c b/src/codegen/codegen.c
index a66f179..384820b 100644
--- a/src/codegen/codegen.c
+++ b/src/codegen/codegen.c
@@ -1,4 +1,3 @@
-
 #include "codegen.h"
 #include "zprep.h"
 #include "../constants.h"
@@ -59,12 +58,58 @@ static void codegen_var_expr(ParserContext *ctx, ASTNode *node, FILE *out)
         if (node->var_ref.suggestion && !ctx->silent_warnings)
         {
             char msg[256];
-            sprintf(msg, "Undefined variable '%s'", node->var_ref.name);
             char help[256];
-            sprintf(help, "Did you mean '%s'?", node->var_ref.suggestion);
+            snprintf(msg, sizeof(msg), "Undefined variable '%s'", node->var_ref.name);
+            snprintf(help, sizeof(help), "Did you mean '%s'?", node->var_ref.suggestion);
             zwarn_at(node->token, "%s\n   = help: %s", msg, help);
         }
     }
+
+    // Check for static method call pattern: Type::method or Slice<T>::method
+    char *double_colon = strstr(node->var_ref.name, "::");
+    if (double_colon)
+    {
+        // Extract type name and method name
+        int type_len = double_colon - node->var_ref.name;
+        char *type_name = xmalloc(type_len + 1);
+        strncpy(type_name, node->var_ref.name, type_len);
+        type_name[type_len] = 0;
+
+        char *method_name = double_colon + 2; // Skip ::
+
+        // Handle generic types: Slice<int> -> Slice_int
+        char mangled_type[256];
+        if (strchr(type_name, '<'))
+        {
+            // Generic type - need to mangle it
+            char *lt = strchr(type_name, '<');
+            char *gt = strchr(type_name, '>');
+
+            if (lt && gt)
+            {
+                // Extract base type and type argument
+                *lt = 0;
+                char *type_arg = lt + 1;
+                *gt = 0;
+
+                sprintf(mangled_type, "%s_%s", type_name, type_arg);
+            }
+            else
+            {
+                strcpy(mangled_type, type_name);
+            }
+        }
+        else
+        {
+            strcpy(mangled_type, type_name);
+        }
+
+        // Output as Type__method
+        fprintf(out, "%s__%s", mangled_type, method_name);
+        free(type_name);
+        return;
+    }
+
     fprintf(out, "%s", node->var_ref.name);
 }
 
@@ -146,7 +191,6 @@ void codegen_expression(ParserContext *ctx, ASTNode *node, FILE *out)
         else if ((strcmp(node->binary.op, "==") == 0 || strcmp(node->binary.op, "!=") == 0))
         {
             char *t1 = infer_type(ctx, node->binary.left);
-
             int is_ptr = 0;
             if (t1)
             {
@@ -161,19 +205,16 @@ void codegen_expression(ParserContext *ctx, ASTNode *node, FILE *out)
                     }
                     int resolved = 0;
                     ASTNode *alias = global_user_structs;
-                    if (alias)
+                    while (alias)
                     {
-                        while (alias)
+                        if (alias->type == NODE_TYPE_ALIAS &&
+                            strcmp(check, alias->type_alias.alias) == 0)
                         {
-                            if (alias->type == NODE_TYPE_ALIAS &&
-                                strcmp(check, alias->type_alias.alias) == 0)
-                            {
-                                check = alias->type_alias.original_type;
-                                resolved = 1;
-                                break;
-                            }
-                            alias = alias->next;
+                            check = alias->type_alias.original_type;
+                            resolved = 1;
+                            break;
                         }
+                        alias = alias->next;
                     }
                     if (!resolved)
                     {
@@ -183,8 +224,8 @@ void codegen_expression(ParserContext *ctx, ASTNode *node, FILE *out)
             }
 
             int is_basic = IS_BASIC_TYPE(t1);
-
             ASTNode *def = t1 ? find_struct_def(ctx, t1) : NULL;
+
             if (t1 && def && (def->type == NODE_STRUCT || def->type == NODE_ENUM) && !is_basic &&
                 !is_ptr)
             {
@@ -239,8 +280,6 @@ void codegen_expression(ParserContext *ctx, ASTNode *node, FILE *out)
             else if (t1 && (strcmp(t1, "string") == 0 || strcmp(t1, "char*") == 0 ||
                             strcmp(t1, "const char*") == 0))
             {
-                // Check if comparing to NULL - don't use strcmp for NULL comparisons
-                char *t2 = infer_type(ctx, node->binary.right);
                 int is_null_compare = 0;
                 if (node->binary.right->type == NODE_EXPR_VAR &&
                     strcmp(node->binary.right->var_ref.name, "NULL") == 0)
@@ -252,9 +291,28 @@ void codegen_expression(ParserContext *ctx, ASTNode *node, FILE *out)
                 {
                     is_null_compare = 1;
                 }
+                else if (node->binary.right->type == NODE_EXPR_LITERAL &&
+                         node->binary.right->literal.type_kind == LITERAL_INT &&
+                         node->binary.right->literal.int_val == 0)
+                {
+                    is_null_compare = 1;
+                }
+                else if (node->binary.left->type == NODE_EXPR_LITERAL &&
+                         node->binary.left->literal.type_kind == LITERAL_INT &&
+                         node->binary.left->literal.int_val == 0)
+                {
+                    is_null_compare = 1;
+                }
 
-                if (!is_null_compare && strcmp(t1, "string") == 0 && t2 &&
-                    strcmp(t2, "string") == 0)
+                if (is_null_compare)
+                {
+                    fprintf(out, "(");
+                    codegen_expression(ctx, node->binary.left, out);
+                    fprintf(out, " %s ", node->binary.op);
+                    codegen_expression(ctx, node->binary.right, out);
+                    fprintf(out, ")");
+                }
+                else
                 {
                     fprintf(out, "(strcmp(");
                     codegen_expression(ctx, node->binary.left, out);
@@ -269,19 +327,6 @@ void codegen_expression(ParserContext *ctx, ASTNode *node, FILE *out)
                         fprintf(out, ") != 0)");
                     }
                 }
-                else
-                {
-                    // Direct pointer comparison
-                    fprintf(out, "(");
-                    codegen_expression(ctx, node->binary.left, out);
-                    fprintf(out, " %s ", node->binary.op);
-                    codegen_expression(ctx, node->binary.right, out);
-                    fprintf(out, ")");
-                }
-                if (t2)
-                {
-                    free(t2);
-                }
             }
             else
             {
@@ -291,6 +336,10 @@ void codegen_expression(ParserContext *ctx, ASTNode *node, FILE *out)
                 codegen_expression(ctx, node->binary.right, out);
                 fprintf(out, ")");
             }
+            if (t1)
+            {
+                free(t1);
+            }
         }
         else
         {
@@ -354,7 +403,7 @@ void codegen_expression(ParserContext *ctx, ASTNode *node, FILE *out)
                 if (def && def->type == NODE_ENUM)
                 {
                     char mangled[256];
-                    sprintf(mangled, "%s_%s", target->var_ref.name, method);
+                    snprintf(mangled, sizeof(mangled), "%s_%s", target->var_ref.name, method);
                     FuncSig *sig = find_func(ctx, mangled);
                     if (sig)
                     {
@@ -363,7 +412,7 @@ void codegen_expression(ParserContext *ctx, ASTNode *node, FILE *out)
                         int arg_idx = 0;
                         while (arg)
                         {
-                            if (arg_idx > 0 && arg)
+                            if (arg_idx > 0)
                             {
                                 fprintf(out, ", ");
                             }
@@ -371,7 +420,6 @@ void codegen_expression(ParserContext *ctx, ASTNode *node, FILE *out)
                             Type *param_t =
                                 (arg_idx < sig->total_args) ? sig->arg_types[arg_idx] : NULL;
 
-                            // Tuple Packing Logic
                             if (param_t && param_t->kind == TYPE_STRUCT &&
                                 strncmp(param_t->name, "Tuple_", 6) == 0 && sig->total_args == 1 &&
                                 node->call.arg_count > 1)
@@ -389,7 +437,7 @@ void codegen_expression(ParserContext *ctx, ASTNode *node, FILE *out)
                                     arg = arg->next;
                                 }
                                 fprintf(out, "}");
-                                break; // All args consumed
+                                break;
                             }
 
                             codegen_expression(ctx, arg, out);
@@ -409,7 +457,7 @@ void codegen_expression(ParserContext *ctx, ASTNode *node, FILE *out)
                 char *ptr = strchr(clean, '*');
                 if (ptr)
                 {
-                    *ptr = 0;
+                    *ptr = '\0';
                 }
 
                 char *base = clean;
@@ -418,11 +466,43 @@ void codegen_expression(ParserContext *ctx, ASTNode *node, FILE *out)
                     base += 7;
                 }
 
+                char *mangled_base = base;
+                char base_buf[256];
+
+                // Mangle generic types: Slice<int> -> Slice_int, Vec<Point> -> Vec_Point
+                char *lt = strchr(base, '<');
+                if (lt)
+                {
+                    char *gt = strchr(lt, '>');
+                    if (gt)
+                    {
+                        int prefix_len = lt - base;
+                        int arg_len = gt - lt - 1;
+                        snprintf(base_buf, 255, "%.*s_%.*s", prefix_len, base, arg_len, lt + 1);
+                        mangled_base = base_buf;
+                    }
+                }
+
                 if (!strchr(type, '*') && target->type == NODE_EXPR_CALL)
                 {
-                    fprintf(out, "({ %s _t = ", type);
+                    char *type_mangled = type;
+                    char type_buf[256];
+                    char *t_lt = strchr(type, '<');
+                    if (t_lt)
+                    {
+                        char *t_gt = strchr(t_lt, '>');
+                        if (t_gt)
+                        {
+                            int p_len = t_lt - type;
+                            int a_len = t_gt - t_lt - 1;
+                            snprintf(type_buf, 255, "%.*s_%.*s", p_len, type, a_len, t_lt + 1);
+                            type_mangled = type_buf;
+                        }
+                    }
+
+                    fprintf(out, "({ %s _t = ", type_mangled);
                     codegen_expression(ctx, target, out);
-                    fprintf(out, "; %s__%s(&_t", base, method);
+                    fprintf(out, "; %s__%s(&_t", mangled_base, method);
                     ASTNode *arg = node->call.args;
                     while (arg)
                     {
@@ -435,36 +515,34 @@ void codegen_expression(ParserContext *ctx, ASTNode *node, FILE *out)
                 else
                 {
                     // Mixin Lookup Logic
-                    char *call_base = base;
+                    char *call_base = mangled_base;
+
                     int need_cast = 0;
                     char mixin_func_name[128];
-                    sprintf(mixin_func_name, "%s__%s", base, method);
+                    snprintf(mixin_func_name, sizeof(mixin_func_name), "%s__%s", call_base, method);
 
                     char *resolved_method_suffix = NULL;
 
                     if (!find_func(ctx, mixin_func_name))
                     {
-                        // Try resolving as a trait method: Struct__Trait_Method
                         StructRef *ref = ctx->parsed_impls_list;
                         while (ref)
                         {
-                            if (ref->node && ref->node->type == NODE_IMPL_TRAIT)
+                            if (ref->node && ref->node->type == NODE_IMPL_TRAIT &&
+                                strcmp(ref->node->impl_trait.target_type, base) == 0)
                             {
-                                if (strcmp(ref->node->impl_trait.target_type, base) == 0)
+                                char trait_mangled[256];
+                                snprintf(trait_mangled, sizeof(trait_mangled), "%s__%s_%s", base,
+                                         ref->node->impl_trait.trait_name, method);
+                                if (find_func(ctx, trait_mangled))
                                 {
-                                    char trait_mangled[256];
-                                    sprintf(trait_mangled, "%s__%s_%s", base,
-                                            ref->node->impl_trait.trait_name, method);
-                                    if (find_func(ctx, trait_mangled))
-                                    {
-                                        char *suffix =
-                                            xmalloc(strlen(ref->node->impl_trait.trait_name) +
-                                                    strlen(method) + 2);
-                                        sprintf(suffix, "%s_%s", ref->node->impl_trait.trait_name,
-                                                method);
-                                        resolved_method_suffix = suffix;
-                                        break;
-                                    }
+                                    size_t suffix_len = strlen(ref->node->impl_trait.trait_name) +
+                                                        strlen(method) + 2;
+                                    char *suffix = xmalloc(suffix_len);
+                                    snprintf(suffix, suffix_len, "%s_%s",
+                                             ref->node->impl_trait.trait_name, method);
+                                    resolved_method_suffix = suffix;
+                                    break;
                                 }
                             }
                             ref = ref->next;
@@ -479,15 +557,14 @@ void codegen_expression(ParserContext *ctx, ASTNode *node, FILE *out)
                                 if (it->impl_node && it->impl_node->type == NODE_IMPL_TRAIT)
                                 {
                                     tname = it->impl_node->impl_trait.trait_name;
-                                }
-                                if (tname)
-                                {
                                     char trait_mangled[512];
-                                    sprintf(trait_mangled, "%s__%s_%s", base, tname, method);
+                                    snprintf(trait_mangled, sizeof(trait_mangled), "%s__%s_%s",
+                                             base, tname, method);
                                     if (find_func(ctx, trait_mangled))
                                     {
-                                        char *suffix = xmalloc(strlen(tname) + strlen(method) + 2);
-                                        sprintf(suffix, "%s_%s", tname, method);
+                                        size_t suffix_len = strlen(tname) + strlen(method) + 2;
+                                        char *suffix = xmalloc(suffix_len);
+                                        snprintf(suffix, suffix_len, "%s_%s", tname, method);
                                         resolved_method_suffix = suffix;
                                         break;
                                     }
@@ -502,15 +579,14 @@ void codegen_expression(ParserContext *ctx, ASTNode *node, FILE *out)
                         }
                         else
                         {
-                            // Method not found on primary struct, check mixins
                             ASTNode *def = find_struct_def(ctx, base);
                             if (def && def->type == NODE_STRUCT && def->strct.used_structs)
                             {
                                 for (int k = 0; k < def->strct.used_struct_count; k++)
                                 {
                                     char mixin_check[128];
-                                    sprintf(mixin_check, "%s__%s", def->strct.used_structs[k],
-                                            method);
+                                    snprintf(mixin_check, sizeof(mixin_check), "%s__%s",
+                                             def->strct.used_structs[k], method);
                                     if (find_func(ctx, mixin_check))
                                     {
                                         call_base = def->strct.used_structs[k];
@@ -540,11 +616,22 @@ void codegen_expression(ParserContext *ctx, ASTNode *node, FILE *out)
                         arg = arg->next;
                     }
                     fprintf(out, ")");
+
+                    if (resolved_method_suffix)
+                    {
+                        free(resolved_method_suffix);
+                    }
                 }
                 free(clean);
+                free(type);
                 return;
             }
+            if (type)
+            {
+                free(type);
+            }
         }
+
         if (node->call.callee->type == NODE_EXPR_VAR)
         {
             ASTNode *def = find_struct_def(ctx, node->call.callee->var_ref.name);
@@ -600,26 +687,6 @@ void codegen_expression(ParserContext *ctx, ASTNode *node, FILE *out)
 
         if (node->call.arg_names && node->call.callee->type == NODE_EXPR_VAR)
         {
-            char *fn_name = node->call.callee->var_ref.name;
-            FuncSig *sig = find_func(ctx, fn_name);
-
-            if (sig && sig->arg_types)
-            {
-                for (int p = 0; p < sig->total_args; p++)
-                {
-                    ASTNode *arg = node->call.args;
-
-                    for (int i = 0; i < node->call.arg_count && arg; i++, arg = arg->next)
-                    {
-                        if (node->call.arg_names[i] && p < node->call.arg_count)
-                        {
-
-                            // For now, emit in order provided...
-                        }
-                    }
-                }
-            }
-
             ASTNode *arg = node->call.args;
             int first = 1;
             while (arg)
@@ -666,11 +733,7 @@ void codegen_expression(ParserContext *ctx, ASTNode *node, FILE *out)
                              strncmp(param_t->name, "Tuple_", 6) == 0 && sig->total_args == 1 &&
                              node->call.arg_count > 1)
                     {
-                        // Implicit Tuple Packing:
-                        // Function expects 1 Tuple argument, but call has multiple args -> Pack
-                        // them
                         fprintf(out, "(%s){", param_t->name);
-
                         ASTNode *curr = arg;
                         int first_field = 1;
                         while (curr)
@@ -685,8 +748,6 @@ void codegen_expression(ParserContext *ctx, ASTNode *node, FILE *out)
                         }
                         fprintf(out, "}");
                         handled = 1;
-
-                        // Advance main loop iterator to end
                         arg = NULL;
                     }
                 }
@@ -695,7 +756,7 @@ void codegen_expression(ParserContext *ctx, ASTNode *node, FILE *out)
                 {
                     if (arg == NULL)
                     {
-                        break; // Tuple packed all args
+                        break;
                     }
                 }
                 else
@@ -720,16 +781,12 @@ void codegen_expression(ParserContext *ctx, ASTNode *node, FILE *out)
     case NODE_EXPR_MEMBER:
         if (strcmp(node->member.field, "len") == 0)
         {
-            if (node->member.target->type_info)
+            if (node->member.target->type_info &&
+                node->member.target->type_info->kind == TYPE_ARRAY &&
+                node->member.target->type_info->array_size > 0)
             {
-                if (node->member.target->type_info->kind == TYPE_ARRAY)
-                {
-                    if (node->member.target->type_info->array_size > 0)
-                    {
-                        fprintf(out, "%d", node->member.target->type_info->array_size);
-                        break;
-                    }
-                }
+                fprintf(out, "%d", node->member.target->type_info->array_size);
+                break;
             }
         }
 
@@ -751,16 +808,7 @@ void codegen_expression(ParserContext *ctx, ASTNode *node, FILE *out)
         }
         else
         {
-            if (node->member.target->type == NODE_EXPR_CAST)
-            {
-                fprintf(out, "(");
-            }
             codegen_expression(ctx, node->member.target, out);
-            if (node->member.target->type == NODE_EXPR_CAST)
-            {
-                fprintf(out, ")");
-            }
-            // Verify actual type instead of trusting is_pointer_access flag
             char *lt = infer_type(ctx, node->member.target);
             int actually_ptr = 0;
             if (lt && (lt[strlen(lt) - 1] == '*' || strstr(lt, "*")))
@@ -771,6 +819,7 @@ void codegen_expression(ParserContext *ctx, ASTNode *node, FILE *out)
             {
                 free(lt);
             }
+
             char *field = node->member.field;
             if (field && field[0] >= '0' && field[0] <= '9')
             {
@@ -793,7 +842,8 @@ void codegen_expression(ParserContext *ctx, ASTNode *node, FILE *out)
                 is_slice_struct = 1;
             }
         }
-        if (node->index.array->resolved_type)
+
+        if (!is_slice_struct && node->index.array->resolved_type)
         {
             if (strncmp(node->index.array->resolved_type, "Slice_", 6) == 0)
             {
@@ -910,7 +960,7 @@ void codegen_expression(ParserContext *ctx, ASTNode *node, FILE *out)
             }
             else
             {
-                fprintf(out, "/* UNSAFE: Full Slice on unknown size */ 0; ");
+                fprintf(out, "0; ");
             }
         }
 
@@ -926,6 +976,10 @@ void codegen_expression(ParserContext *ctx, ASTNode *node, FILE *out)
             fprintf(out, "(Slice_%s){ .data = _arr + _start, .len = _len, .cap = _len }; })",
                     tname);
         }
+        if (tname && strcmp(tname, "unknown") != 0)
+        {
+            free(tname);
+        }
         break;
     }
     case NODE_BLOCK:
@@ -1016,9 +1070,7 @@ void codegen_expression(ParserContext *ctx, ASTNode *node, FILE *out)
         break;
     case NODE_PLUGIN:
     {
-        // Plugin registry - declare external plugins
         ZPlugin *found = zptr_find_plugin(node->plugin_stmt.plugin_name);
-
         if (found)
         {
             ZApi api = {.filename = g_current_filename ? g_current_filename : "input.zc",
@@ -1098,14 +1150,102 @@ void codegen_expression(ParserContext *ctx, ASTNode *node, FILE *out)
         break;
     }
     case NODE_EXPR_CAST:
-        fprintf(out, "(%s)(", node->cast.target_type);
+    {
+        const char *t = node->cast.target_type;
+        const char *mapped = t;
+        if (strcmp(t, "c_int") == 0)
+        {
+            mapped = "int";
+        }
+        else if (strcmp(t, "c_uint") == 0)
+        {
+            mapped = "unsigned int";
+        }
+        else if (strcmp(t, "c_long") == 0)
+        {
+            mapped = "long";
+        }
+        else if (strcmp(t, "c_ulong") == 0)
+        {
+            mapped = "unsigned long";
+        }
+        else if (strcmp(t, "c_short") == 0)
+        {
+            mapped = "short";
+        }
+        else if (strcmp(t, "c_ushort") == 0)
+        {
+            mapped = "unsigned short";
+        }
+        else if (strcmp(t, "c_char") == 0)
+        {
+            mapped = "char";
+        }
+        else if (strcmp(t, "c_uchar") == 0)
+        {
+            mapped = "unsigned char";
+        }
+        else if (strcmp(t, "int") == 0)
+        {
+            mapped = "int32_t";
+        }
+        else if (strcmp(t, "uint") == 0)
+        {
+            mapped = "unsigned int";
+        }
+
+        fprintf(out, "((%s)(", mapped);
         codegen_expression(ctx, node->cast.expr, out);
-        fprintf(out, ")");
+        fprintf(out, "))");
         break;
+    }
     case NODE_EXPR_SIZEOF:
         if (node->size_of.target_type)
         {
-            fprintf(out, "sizeof(%s)", node->size_of.target_type);
+            const char *t = node->size_of.target_type;
+            const char *mapped = t;
+            if (strcmp(t, "c_int") == 0)
+            {
+                mapped = "int";
+            }
+            else if (strcmp(t, "c_uint") == 0)
+            {
+                mapped = "unsigned int";
+            }
+            else if (strcmp(t, "c_long") == 0)
+            {
+                mapped = "long";
+            }
+            else if (strcmp(t, "c_ulong") == 0)
+            {
+                mapped = "unsigned long";
+            }
+            else if (strcmp(t, "c_short") == 0)
+            {
+                mapped = "short";
+            }
+            else if (strcmp(t, "c_ushort") == 0)
+            {
+                mapped = "unsigned short";
+            }
+            else if (strcmp(t, "c_char") == 0)
+            {
+                mapped = "char";
+            }
+            else if (strcmp(t, "c_uchar") == 0)
+            {
+                mapped = "unsigned char";
+            }
+            else if (strcmp(t, "int") == 0)
+            {
+                mapped = "int32_t"; // Strict mapping
+            }
+            else if (strcmp(t, "uint") == 0)
+            {
+                mapped = "unsigned int"; // uint alias
+            }
+
+            fprintf(out, "sizeof(%s)", mapped);
         }
         else
         {
@@ -1131,20 +1271,19 @@ void codegen_expression(ParserContext *ctx, ASTNode *node, FILE *out)
     {
         Type *t = node->reflection.target_type;
         if (node->reflection.kind == 0)
-        { // @type_name
+        {
             char *s = codegen_type_to_string(t);
             fprintf(out, "\"%s\"", s);
             free(s);
         }
         else
-        { // @fields
+        {
             if (t->kind != TYPE_STRUCT || !t->name)
             {
                 fprintf(out, "((void*)0)");
                 break;
             }
             char *sname = t->name;
-            // Find definition
             ASTNode *def = find_struct_def(ctx, sname);
             if (!def)
             {
diff --git a/src/codegen/codegen.h b/src/codegen/codegen.h
index b3e971d..89614f7 100644
--- a/src/codegen/codegen.h
+++ b/src/codegen/codegen.h
@@ -48,7 +48,7 @@ char *replace_string_type(const char *args);
 const char *parse_original_method_name(const char *mangled);
 void emit_auto_type(ParserContext *ctx, ASTNode *init_expr, Token t, FILE *out);
 char *codegen_type_to_string(Type *t);
-void emit_func_signature(FILE *out, ASTNode *func, const char *name_override);
+void emit_func_signature(ParserContext *ctx, FILE *out, ASTNode *func, const char *name_override);
 char *strip_template_suffix(const char *name);
 int emit_move_invalidation(ParserContext *ctx, ASTNode *node, FILE *out);
 void codegen_expression_with_move(ParserContext *ctx, ASTNode *node, FILE *out);
@@ -66,7 +66,7 @@ void emit_trait_defs(ASTNode *node, FILE *out);
 void emit_enum_protos(ASTNode *node, FILE *out);
 void emit_globals(ParserContext *ctx, ASTNode *node, FILE *out);
 void emit_lambda_defs(ParserContext *ctx, FILE *out);
-void emit_protos(ASTNode *node, FILE *out);
+void emit_protos(ParserContext *ctx, ASTNode *node, FILE *out);
 void emit_impl_vtables(ParserContext *ctx, FILE *out);
 
 /**
diff --git a/src/codegen/codegen_decl.c b/src/codegen/codegen_decl.c
index 0b78676..1623ffc 100644
--- a/src/codegen/codegen_decl.c
+++ b/src/codegen/codegen_decl.c
@@ -50,6 +50,7 @@ void emit_preamble(ParserContext *ctx, FILE *out)
     else
     {
         // Standard hosted preamble.
+        fputs("#define _GNU_SOURCE\n", out);
         fputs("#include <stdio.h>\n#include <stdlib.h>\n#include "
               "<stddef.h>\n#include <string.h>\n",
               out);
@@ -698,7 +699,7 @@ void emit_globals(ParserContext *ctx, ASTNode *node, FILE *out)
 }
 
 // Emit function prototypes
-void emit_protos(ASTNode *node, FILE *out)
+void emit_protos(ParserContext *ctx, ASTNode *node, FILE *out)
 {
     ASTNode *f = node;
     while (f)
@@ -721,7 +722,7 @@ void emit_protos(ASTNode *node, FILE *out)
             }
             else
             {
-                emit_func_signature(out, f, NULL);
+                emit_func_signature(ctx, out, f, NULL);
                 fprintf(out, ";\n");
             }
         }
@@ -799,7 +800,7 @@ void emit_protos(ASTNode *node, FILE *out)
                 }
                 else
                 {
-                    emit_func_signature(out, m, proto);
+                    emit_func_signature(ctx, out, m, proto);
                     fprintf(out, ";\n");
                 }
 
@@ -1129,12 +1130,23 @@ void print_type_defs(ParserContext *ctx, FILE *out, ASTNode *nodes)
         fprintf(out, "typedef struct Tuple_%s Tuple_%s;\nstruct Tuple_%s { ", t->sig, t->sig,
                 t->sig);
         char *s = xstrdup(t->sig);
-        char *p = strtok(s, "_");
+        char *current = s;
+        char *next_sep = strstr(current, "__");
         int i = 0;
-        while (p)
+        while (current)
         {
-            fprintf(out, "%s v%d; ", p, i++);
-            p = strtok(NULL, "_");
+            if (next_sep)
+            {
+                *next_sep = 0;
+                fprintf(out, "%s v%d; ", current, i++);
+                current = next_sep + 2;
+                next_sep = strstr(current, "__");
+            }
+            else
+            {
+                fprintf(out, "%s v%d; ", current, i++);
+                break;
+            }
         }
         free(s);
         fprintf(out, "};\n");
diff --git a/src/codegen/codegen_main.c b/src/codegen/codegen_main.c
index a140070..82fc3ce 100644
--- a/src/codegen/codegen_main.c
+++ b/src/codegen/codegen_main.c
@@ -448,6 +448,39 @@ void codegen_node(ParserContext *ctx, ASTNode *node, FILE *out)
         emit_type_aliases(kids, out);  // Emit local aliases (redundant but safe)
         emit_trait_defs(kids, out);
 
+        // Also emit traits from parsed_globals_list (from auto-imported files like std/mem.zc)
+        // but only if they weren't already emitted from kids
+        StructRef *trait_ref = ctx->parsed_globals_list;
+        while (trait_ref)
+        {
+            if (trait_ref->node && trait_ref->node->type == NODE_TRAIT)
+            {
+                // Check if this trait was already in kids (explicitly imported)
+                int already_in_kids = 0;
+                ASTNode *k = kids;
+                while (k)
+                {
+                    if (k->type == NODE_TRAIT && k->trait.name && trait_ref->node->trait.name &&
+                        strcmp(k->trait.name, trait_ref->node->trait.name) == 0)
+                    {
+                        already_in_kids = 1;
+                        break;
+                    }
+                    k = k->next;
+                }
+
+                if (!already_in_kids)
+                {
+                    // Create a temporary single-node list for emit_trait_defs
+                    ASTNode *saved_next = trait_ref->node->next;
+                    trait_ref->node->next = NULL;
+                    emit_trait_defs(trait_ref->node, out);
+                    trait_ref->node->next = saved_next;
+                }
+            }
+            trait_ref = trait_ref->next;
+        }
+
         // Track emitted raw statements to prevent duplicates
         EmittedContent *emitted_raw = NULL;
 
@@ -616,7 +649,7 @@ void codegen_node(ParserContext *ctx, ASTNode *node, FILE *out)
             }
         }
 
-        emit_protos(merged_funcs, out);
+        emit_protos(ctx, merged_funcs, out);
 
         emit_impl_vtables(ctx, out);
 
diff --git a/src/codegen/codegen_stmt.c b/src/codegen/codegen_stmt.c
index 2f9a2ba..7828ecf 100644
--- a/src/codegen/codegen_stmt.c
+++ b/src/codegen/codegen_stmt.c
@@ -750,7 +750,7 @@ void codegen_node_single(ParserContext *ctx, ASTNode *node, FILE *out)
         {
             fprintf(out, "inline ");
         }
-        emit_func_signature(out, node, NULL);
+        emit_func_signature(ctx, out, node, NULL);
         fprintf(out, "\n");
         fprintf(out, "{\n");
         char *prev_ret = g_current_func_ret_type;
diff --git a/src/codegen/codegen_utils.c b/src/codegen/codegen_utils.c
index 391ebd3..92c5395 100644
--- a/src/codegen/codegen_utils.c
+++ b/src/codegen/codegen_utils.c
@@ -41,7 +41,7 @@ char *strip_template_suffix(const char *name)
 }
 
 // Helper to emit C declaration (handle arrays, function pointers correctly)
-void emit_c_decl(FILE *out, const char *type_str, const char *name)
+void emit_c_decl(ParserContext *ctx, FILE *out, const char *type_str, const char *name)
 {
     char *bracket = strchr(type_str, '[');
     char *generic = strchr(type_str, '<');
@@ -64,9 +64,34 @@ void emit_c_decl(FILE *out, const char *type_str, const char *name)
     }
     else if (generic && (!bracket || generic < bracket))
     {
-        // Strip generic part for C output
-        int base_len = generic - type_str;
-        fprintf(out, "%.*s %s", base_len, type_str, name);
+        char mangled_candidate[256];
+        char *gt = strchr(generic, '>');
+        int success = 0;
+
+        if (gt)
+        {
+            int base_len = generic - type_str;
+            int arg_len = gt - generic - 1;
+
+            // Limit check
+            if (base_len + arg_len + 2 < 256)
+            {
+                snprintf(mangled_candidate, 256, "%.*s_%.*s", base_len, type_str, arg_len,
+                         generic + 1);
+
+                if (find_struct_def_codegen(ctx, mangled_candidate))
+                {
+                    fprintf(out, "%s %s", mangled_candidate, name);
+                    success = 1;
+                }
+            }
+        }
+
+        if (!success)
+        {
+            int base_len = generic - type_str;
+            fprintf(out, "%.*s %s", base_len, type_str, name);
+        }
 
         if (bracket)
         {
@@ -87,8 +112,7 @@ void emit_c_decl(FILE *out, const char *type_str, const char *name)
 // Helper to emit variable declarations with array types.
 void emit_var_decl_type(ParserContext *ctx, FILE *out, const char *type_str, const char *var_name)
 {
-    (void)ctx;
-    emit_c_decl(out, type_str, var_name);
+    emit_c_decl(ctx, out, type_str, var_name);
 }
 
 // Find struct definition
@@ -169,6 +193,7 @@ char *infer_type(ParserContext *ctx, ASTNode *node)
     {
         return NULL;
     }
+
     if (node->resolved_type && strcmp(node->resolved_type, "unknown") != 0 &&
         strcmp(node->resolved_type, "void*") != 0)
     {
@@ -302,6 +327,65 @@ char *infer_type(ParserContext *ctx, ASTNode *node)
                     return extracted;
                 }
             }
+
+            // Find the struct/enum definition and look for "Ok" or "val"
+            char *search_name = inner_type;
+            if (strncmp(search_name, "struct ", 7) == 0)
+            {
+                search_name += 7;
+            }
+
+            ASTNode *def = find_struct_def_codegen(ctx, search_name);
+            if (!def)
+            {
+                // check enums list explicitly if not found in instantiated list
+                StructRef *er = ctx->parsed_enums_list;
+                while (er)
+                {
+                    if (er->node && er->node->type == NODE_ENUM &&
+                        strcmp(er->node->enm.name, search_name) == 0)
+                    {
+                        def = er->node;
+                        break;
+                    }
+                    er = er->next;
+                }
+            }
+
+            if (def)
+            {
+                if (def->type == NODE_ENUM)
+                {
+                    // Look for "Ok" variant
+                    ASTNode *var = def->enm.variants;
+                    while (var)
+                    {
+                        if (var->variant.name && strcmp(var->variant.name, "Ok") == 0)
+                        {
+                            if (var->variant.payload)
+                            {
+                                return codegen_type_to_string(var->variant.payload);
+                            }
+                            // Ok with no payload? Then it's void/u0.
+                            return "void";
+                        }
+                        var = var->next;
+                    }
+                }
+                else if (def->type == NODE_STRUCT)
+                {
+                    // Look for "val" field
+                    ASTNode *field = def->strct.fields;
+                    while (field)
+                    {
+                        if (field->field.name && strcmp(field->field.name, "val") == 0)
+                        {
+                            return xstrdup(field->field.type);
+                        }
+                        field = field->next;
+                    }
+                }
+            }
         }
     }
 
@@ -644,7 +728,7 @@ char *codegen_type_to_string(Type *t)
 }
 
 // Emit function signature using Type info for correct C codegen
-void emit_func_signature(FILE *out, ASTNode *func, const char *name_override)
+void emit_func_signature(ParserContext *ctx, FILE *out, ASTNode *func, const char *name_override)
 {
     if (!func || func->type != NODE_FUNCTION)
     {
@@ -714,7 +798,12 @@ void emit_func_signature(FILE *out, ASTNode *func, const char *name_override)
             }
 
             char *type_str = NULL;
-            if (func->func.arg_types && func->func.arg_types[i])
+            // Check for @ctype override first
+            if (func->func.c_type_overrides && func->func.c_type_overrides[i])
+            {
+                type_str = xstrdup(func->func.c_type_overrides[i]);
+            }
+            else if (func->func.arg_types && func->func.arg_types[i])
             {
                 type_str = codegen_type_to_string(func->func.arg_types[i]);
             }
@@ -724,13 +813,14 @@ void emit_func_signature(FILE *out, ASTNode *func, const char *name_override)
             }
 
             const char *name = "";
+
             if (func->func.param_names && func->func.param_names[i])
             {
                 name = func->func.param_names[i];
             }
 
             // check if array type
-            emit_c_decl(out, type_str, name);
+            emit_c_decl(ctx, out, type_str, name);
             free(type_str);
         }
         if (func->func.is_varargs)