Improvements for the standard library + '@ctype'.

6 files changed, 67 insertions, 7 deletions

diff --git a/src/ast/ast.h b/src/ast/ast.h
index 71d9943..4498d7c 100644
--- a/src/ast/ast.h
+++ b/src/ast/ast.h
@@ -229,6 +229,8 @@ struct ASTNode
             int cuda_device; // @device -> __device__
             int cuda_host;   // @host -> __host__
 
+            char **c_type_overrides; // @ctype("...") per parameter
+
             Attribute *attributes; // Custom attributes
         } func;
 
diff --git a/src/codegen/codegen_utils.c b/src/codegen/codegen_utils.c
index 391ebd3..0d03661 100644
--- a/src/codegen/codegen_utils.c
+++ b/src/codegen/codegen_utils.c
@@ -714,7 +714,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,6 +729,7 @@ 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];
diff --git a/src/parser/parser.h b/src/parser/parser.h
index 262c359..23c2920 100644
--- a/src/parser/parser.h
+++ b/src/parser/parser.h
@@ -561,7 +561,8 @@ ASTNode *parse_arrow_lambda_multi(ParserContext *ctx, Lexer *l, char **param_nam
  * @brief Parses and converts arguments.
  */
 char *parse_and_convert_args(ParserContext *ctx, Lexer *l, char ***defaults_out, int *count_out,
-                             Type ***types_out, char ***names_out, int *is_varargs_out);
+                             Type ***types_out, char ***names_out, int *is_varargs_out,
+                             char ***ctype_overrides_out);
 
 /**
  * @brief Checks if a file has been imported.
diff --git a/src/parser/parser_decl.c b/src/parser/parser_decl.c
index c96ca36..93a124d 100644
--- a/src/parser/parser_decl.c
+++ b/src/parser/parser_decl.c
@@ -99,10 +99,11 @@ ASTNode *parse_function(ParserContext *ctx, Lexer *l, int is_async)
     int count;
     Type **arg_types;
     char **param_names;
+    char **ctype_overrides;
     int is_varargs = 0;
 
-    char *args =
-        parse_and_convert_args(ctx, l, &defaults, &count, &arg_types, &param_names, &is_varargs);
+    char *args = parse_and_convert_args(ctx, l, &defaults, &count, &arg_types, &param_names,
+                                        &is_varargs, &ctype_overrides);
 
     char *ret = "void";
     Type *ret_type_obj = type_new(TYPE_VOID);
@@ -191,6 +192,7 @@ ASTNode *parse_function(ParserContext *ctx, Lexer *l, int is_async)
     node->func.defaults = defaults;
     node->func.ret_type_info = ret_type_obj;
     node->func.is_varargs = is_varargs;
+    node->func.c_type_overrides = ctype_overrides;
 
     if (gen_param)
     {
diff --git a/src/parser/parser_struct.c b/src/parser/parser_struct.c
index 82dd346..109eeee 100644
--- a/src/parser/parser_struct.c
+++ b/src/parser/parser_struct.c
@@ -100,7 +100,7 @@ ASTNode *parse_trait(ParserContext *ctx, Lexer *l)
         char **param_names = NULL;
         int is_varargs = 0;
         char *args = parse_and_convert_args(ctx, l, &defaults, &arg_count, &arg_types, &param_names,
-                                            &is_varargs);
+                                            &is_varargs, NULL);
 
         char *ret = xstrdup("void");
         if (lexer_peek(l).type == TOK_ARROW)
diff --git a/src/parser/parser_utils.c b/src/parser/parser_utils.c
index 48418b6..28d2c11 100644
--- a/src/parser/parser_utils.c
+++ b/src/parser/parser_utils.c
@@ -3392,7 +3392,8 @@ char *consume_and_rewrite(ParserContext *ctx, Lexer *l)
 }
 
 char *parse_and_convert_args(ParserContext *ctx, Lexer *l, char ***defaults_out, int *count_out,
-                             Type ***types_out, char ***names_out, int *is_varargs_out)
+                             Type ***types_out, char ***names_out, int *is_varargs_out,
+                             char ***ctype_overrides_out)
 {
     Token t = lexer_next(l);
     if (t.type != TOK_LPAREN)
@@ -3406,18 +3407,52 @@ char *parse_and_convert_args(ParserContext *ctx, Lexer *l, char ***defaults_out,
     char **defaults = xmalloc(sizeof(char *) * 16);
     Type **types = xmalloc(sizeof(Type *) * 16);
     char **names = xmalloc(sizeof(char *) * 16);
+    char **ctype_overrides = xmalloc(sizeof(char *) * 16);
 
     for (int i = 0; i < 16; i++)
     {
         defaults[i] = NULL;
         types[i] = NULL;
         names[i] = NULL;
+        ctype_overrides[i] = NULL;
     }
 
     if (lexer_peek(l).type != TOK_RPAREN)
     {
         while (1)
         {
+            // Check for @ctype("...") before parameter
+            char *ctype_override = NULL;
+            if (lexer_peek(l).type == TOK_AT)
+            {
+                lexer_next(l); // eat @
+                Token attr = lexer_next(l);
+                if (attr.type == TOK_IDENT && attr.len == 5 && strncmp(attr.start, "ctype", 5) == 0)
+                {
+                    if (lexer_next(l).type != TOK_LPAREN)
+                    {
+                        zpanic_at(lexer_peek(l), "Expected ( after @ctype");
+                    }
+                    Token ctype_tok = lexer_next(l);
+                    if (ctype_tok.type != TOK_STRING)
+                    {
+                        zpanic_at(ctype_tok, "@ctype requires a string argument");
+                    }
+                    // Extract string content (strip quotes)
+                    ctype_override = xmalloc(ctype_tok.len - 1);
+                    strncpy(ctype_override, ctype_tok.start + 1, ctype_tok.len - 2);
+                    ctype_override[ctype_tok.len - 2] = 0;
+                    if (lexer_next(l).type != TOK_RPAREN)
+                    {
+                        zpanic_at(lexer_peek(l), "Expected ) after @ctype string");
+                    }
+                }
+                else
+                {
+                    zpanic_at(attr, "Unknown parameter attribute @%.*s", attr.len, attr.start);
+                }
+            }
+
             Token t = lexer_next(l);
             // Handle 'self'
             if (t.type == TOK_IDENT && strncmp(t.start, "self", 4) == 0 && t.len == 4)
@@ -3470,6 +3505,7 @@ char *parse_and_convert_args(ParserContext *ctx, Lexer *l, char ***defaults_out,
                     types[count] = type_new_ptr(type_new(TYPE_VOID));
                     add_symbol(ctx, "self", "void*", types[count]);
                 }
+                ctype_overrides[count] = ctype_override;
                 count++;
             }
             else
@@ -3514,11 +3550,20 @@ char *parse_and_convert_args(ParserContext *ctx, Lexer *l, char ***defaults_out,
                 }
                 else
                 {
-                    strcat(buf, type_str);
+                    // Use @ctype override if present
+                    if (ctype_override)
+                    {
+                        strcat(buf, ctype_override);
+                    }
+                    else
+                    {
+                        strcat(buf, type_str);
+                    }
                     strcat(buf, " ");
                     strcat(buf, name);
                 }
 
+                ctype_overrides[count] = ctype_override;
                 count++;
 
                 if (lexer_peek(l).type == TOK_OP && is_token(lexer_peek(l), "="))
@@ -3593,6 +3638,10 @@ char *parse_and_convert_args(ParserContext *ctx, Lexer *l, char ***defaults_out,
     *count_out = count;
     *types_out = types;
     *names_out = names;
+    if (ctype_overrides_out)
+    {
+        *ctype_overrides_out = ctype_overrides;
+    }
     return buf;
 }