Fix for #74

1 files changed, 395 insertions, 165 deletions

diff --git a/src/parser/parser_utils.c b/src/parser/parser_utils.c
index afd6f33..f1345ba 100644
--- a/src/parser/parser_utils.c
+++ b/src/parser/parser_utils.c
@@ -858,6 +858,57 @@ char *replace_in_string(const char *src, const char *old_w, const char *new_w)
         return src ? xstrdup(src) : NULL;
     }
 
+    // Check for multiple parameters (comma separated)
+    if (strchr(old_w, ','))
+    {
+        char *running_src = xstrdup(src);
+
+        char *p_ptr = (char *)old_w;
+        char *c_ptr = (char *)new_w;
+
+        while (*p_ptr && *c_ptr)
+        {
+            char *p_end = strchr(p_ptr, ',');
+            int p_len = p_end ? (p_end - p_ptr) : strlen(p_ptr);
+
+            char *c_end = strchr(c_ptr, ',');
+            int c_len = c_end ? (c_end - c_ptr) : strlen(c_ptr);
+
+            char *curr_p = xmalloc(p_len + 1);
+            strncpy(curr_p, p_ptr, p_len);
+            curr_p[p_len] = 0;
+
+            char *curr_c = xmalloc(c_len + 1);
+            strncpy(curr_c, c_ptr, c_len);
+            curr_c[c_len] = 0;
+
+            char *next_src = replace_in_string(running_src, curr_p, curr_c);
+            free(running_src);
+            running_src = next_src;
+
+            free(curr_p);
+            free(curr_c);
+
+            if (p_end)
+            {
+                p_ptr = p_end + 1;
+            }
+            else
+            {
+                break;
+            }
+            if (c_end)
+            {
+                c_ptr = c_end + 1;
+            }
+            else
+            {
+                break;
+            }
+        }
+        return running_src;
+    }
+
     char *result;
     int i, cnt = 0;
     int newWlen = strlen(new_w);
@@ -940,8 +991,50 @@ char *replace_type_str(const char *src, const char *param, const char *concrete,
         return NULL;
     }
 
-    if (strcmp(src, param) == 0)
+    // Handle multi-param match
+    if (param && concrete && strchr(param, ','))
+    {
+        char *p_ptr = (char *)param;
+        char *c_ptr = (char *)concrete;
+
+        while (*p_ptr && *c_ptr)
+        {
+            char *p_end = strchr(p_ptr, ',');
+            int p_len = p_end ? (p_end - p_ptr) : strlen(p_ptr);
+
+            char *c_end = strchr(c_ptr, ',');
+            int c_len = c_end ? (c_end - c_ptr) : strlen(c_ptr);
+
+            if (strlen(src) == p_len && strncmp(src, p_ptr, p_len) == 0)
+            {
+                char *ret = xmalloc(c_len + 1);
+                strncpy(ret, c_ptr, c_len);
+                ret[c_len] = 0;
+                return ret;
+            }
+
+            if (p_end)
+            {
+                p_ptr = p_end + 1;
+            }
+            else
+            {
+                break;
+            }
+            if (c_end)
+            {
+                c_ptr = c_end + 1;
+            }
+            else
+            {
+                break;
+            }
+        }
+    }
+
+    if (param && strcmp(src, param) == 0)
     {
+
         return xstrdup(concrete);
     }
 
@@ -964,21 +1057,46 @@ char *replace_type_str(const char *src, const char *param, const char *concrete,
 
     if (param && concrete && src)
     {
-        char suffix[256];
-        sprintf(suffix, "_%s", param);
+        // Construct mangled suffix from param ("F,S" -> "_F_S")
+        char p_suffix[1024];
+        p_suffix[0] = 0;
+
+        char *p_temp = xstrdup(param);
+        char *tok = strtok(p_temp, ",");
+        while (tok)
+        {
+            strcat(p_suffix, "_");
+            strcat(p_suffix, tok);
+            tok = strtok(NULL, ",");
+        }
+        free(p_temp);
+
         size_t slen = strlen(src);
-        size_t plen = strlen(suffix);
-        if (slen > plen && strcmp(src + slen - plen, suffix) == 0)
+        size_t plen = strlen(p_suffix);
+
+        if (slen >= plen && strcmp(src + slen - plen, p_suffix) == 0)
         {
-            // Ends with _T -> Replace suffix with _int (sanitize for pointers like
-            // JsonValue*)
-            char *clean_concrete = sanitize_mangled_name(concrete);
-            char *ret = xmalloc(slen - plen + strlen(clean_concrete) + 2);
+            // Construct replacement suffix from concrete ("int,float" -> "_int_float")
+            char c_suffix[1024];
+            c_suffix[0] = 0;
+
+            char *c_temp = xstrdup(concrete);
+            tok = strtok(c_temp, ",");
+            while (tok)
+            {
+                strcat(c_suffix, "_");
+                char *clean = sanitize_mangled_name(tok);
+                strcat(c_suffix, clean);
+                free(clean);
+                tok = strtok(NULL, ",");
+            }
+            free(c_temp);
+
+            // Perform replacement
+            char *ret = xmalloc(slen - plen + strlen(c_suffix) + 1);
             strncpy(ret, src, slen - plen);
             ret[slen - plen] = 0;
-            strcat(ret, "_");
-            strcat(ret, clean_concrete);
-            free(clean_concrete);
+            strcat(ret, c_suffix);
             return ret;
         }
     }
@@ -1025,6 +1143,111 @@ char *replace_type_str(const char *src, const char *param, const char *concrete,
 ASTNode *copy_ast_replacing(ASTNode *n, const char *p, const char *c, const char *os,
                             const char *ns);
 
+// Helper to create type from string (primitives or struct)
+Type *type_from_string_helper(const char *c)
+{
+    if (strcmp(c, "int") == 0)
+    {
+        return type_new(TYPE_INT);
+    }
+    if (strcmp(c, "float") == 0)
+    {
+        return type_new(TYPE_FLOAT);
+    }
+    if (strcmp(c, "void") == 0)
+    {
+        return type_new(TYPE_VOID);
+    }
+    if (strcmp(c, "string") == 0)
+    {
+        return type_new(TYPE_STRING);
+    }
+    if (strcmp(c, "bool") == 0)
+    {
+        return type_new(TYPE_BOOL);
+    }
+    if (strcmp(c, "char") == 0)
+    {
+        return type_new(TYPE_CHAR);
+    }
+    if (strcmp(c, "I8") == 0 || strcmp(c, "i8") == 0)
+    {
+        return type_new(TYPE_I8);
+    }
+    if (strcmp(c, "U8") == 0 || strcmp(c, "u8") == 0)
+    {
+        return type_new(TYPE_U8);
+    }
+    if (strcmp(c, "I16") == 0 || strcmp(c, "i16") == 0)
+    {
+        return type_new(TYPE_I16);
+    }
+    if (strcmp(c, "U16") == 0 || strcmp(c, "u16") == 0)
+    {
+        return type_new(TYPE_U16);
+    }
+    if (strcmp(c, "I32") == 0 || strcmp(c, "i32") == 0 || strcmp(c, "int32_t") == 0)
+    {
+        return type_new(TYPE_I32);
+    }
+    if (strcmp(c, "U32") == 0 || strcmp(c, "u32") == 0 || strcmp(c, "uint32_t") == 0)
+    {
+        return type_new(TYPE_U32);
+    }
+    if (strcmp(c, "I64") == 0 || strcmp(c, "i64") == 0 || strcmp(c, "int64_t") == 0)
+    {
+        return type_new(TYPE_I64);
+    }
+    if (strcmp(c, "U64") == 0 || strcmp(c, "u64") == 0 || strcmp(c, "uint64_t") == 0)
+    {
+        return type_new(TYPE_U64);
+    }
+    if (strcmp(c, "float") == 0 || strcmp(c, "f32") == 0)
+    {
+        return type_new(TYPE_F32);
+    }
+    if (strcmp(c, "double") == 0 || strcmp(c, "f64") == 0)
+    {
+        return type_new(TYPE_F64);
+    }
+    if (strcmp(c, "I128") == 0 || strcmp(c, "i128") == 0)
+    {
+        return type_new(TYPE_I128);
+    }
+    if (strcmp(c, "U128") == 0 || strcmp(c, "u128") == 0)
+    {
+        return type_new(TYPE_U128);
+    }
+    if (strcmp(c, "rune") == 0)
+    {
+        return type_new(TYPE_RUNE);
+    }
+    if (strcmp(c, "uint") == 0)
+    {
+        return type_new(TYPE_UINT);
+    }
+    if (strcmp(c, "double") == 0)
+    {
+        return type_new(TYPE_F64);
+    }
+    if (strcmp(c, "byte") == 0)
+    {
+        return type_new(TYPE_BYTE);
+    }
+    if (strcmp(c, "usize") == 0)
+    {
+        return type_new(TYPE_USIZE);
+    }
+    if (strcmp(c, "isize") == 0)
+    {
+        return type_new(TYPE_ISIZE);
+    }
+
+    Type *n = type_new(TYPE_STRUCT);
+    n->name = sanitize_mangled_name(c);
+    return n;
+}
+
 Type *replace_type_formal(Type *t, const char *p, const char *c, const char *os, const char *ns)
 {
     if (!t)
@@ -1032,155 +1255,54 @@ Type *replace_type_formal(Type *t, const char *p, const char *c, const char *os,
         return NULL;
     }
 
-    if ((t->kind == TYPE_STRUCT || t->kind == TYPE_GENERIC) && t->name && strcmp(t->name, p) == 0)
+    // Exact Match Logic (with multi-param splitting)
+    if ((t->kind == TYPE_STRUCT || t->kind == TYPE_GENERIC) && t->name)
     {
-        if (strcmp(c, "int") == 0)
-        {
-            return type_new(TYPE_INT);
-        }
-        if (strcmp(c, "float") == 0)
-        {
-            return type_new(TYPE_FLOAT);
-        }
-        if (strcmp(c, "void") == 0)
-        {
-            return type_new(TYPE_VOID);
-        }
-        if (strcmp(c, "string") == 0)
-        {
-            return type_new(TYPE_STRING);
-        }
-        if (strcmp(c, "bool") == 0)
-        {
-            return type_new(TYPE_BOOL);
-        }
-        if (strcmp(c, "char") == 0)
-        {
-            return type_new(TYPE_CHAR);
-        }
 
-        if (strcmp(c, "I8") == 0)
-        {
-            return type_new(TYPE_I8);
-        }
-        if (strcmp(c, "U8") == 0)
-        {
-            return type_new(TYPE_U8);
-        }
-        if (strcmp(c, "I16") == 0)
-        {
-            return type_new(TYPE_I16);
-        }
-        if (strcmp(c, "U16") == 0)
-        {
-            return type_new(TYPE_U16);
-        }
-        if (strcmp(c, "I32") == 0)
-        {
-            return type_new(TYPE_I32);
-        }
-        if (strcmp(c, "U32") == 0)
-        {
-            return type_new(TYPE_U32);
-        }
-        if (strcmp(c, "I64") == 0)
-        {
-            return type_new(TYPE_I64);
-        }
-        if (strcmp(c, "U64") == 0)
-        {
-            return type_new(TYPE_U64);
-        }
-        if (strcmp(c, "F32") == 0)
-        {
-            return type_new(TYPE_F32);
-        }
-        if (strcmp(c, "f32") == 0)
+        if (p && c && strchr(p, ','))
         {
-            return type_new(TYPE_F32);
-        }
-        if (strcmp(c, "F64") == 0)
-        {
-            return type_new(TYPE_F64);
-        }
-        if (strcmp(c, "f64") == 0)
-        {
-            return type_new(TYPE_F64);
-        }
+            char *p_ptr = (char *)p;
+            char *c_ptr = (char *)c;
+            while (*p_ptr && *c_ptr)
+            {
+                char *p_end = strchr(p_ptr, ',');
+                int p_len = p_end ? (p_end - p_ptr) : strlen(p_ptr);
+                char *c_end = strchr(c_ptr, ',');
+                int c_len = c_end ? (c_end - c_ptr) : strlen(c_ptr);
 
-        if (strcmp(c, "usize") == 0)
-        {
-            return type_new(TYPE_USIZE);
-        }
-        if (strcmp(c, "isize") == 0)
-        {
-            return type_new(TYPE_ISIZE);
-        }
-        if (strcmp(c, "byte") == 0)
-        {
-            return type_new(TYPE_BYTE);
-        }
-        if (strcmp(c, "I128") == 0)
-        {
-            return type_new(TYPE_I128);
-        }
-        if (strcmp(c, "U128") == 0)
-        {
-            return type_new(TYPE_U128);
-        }
-        if (strcmp(c, "i8") == 0)
-        {
-            return type_new(TYPE_I8);
-        }
-        if (strcmp(c, "u8") == 0)
-        {
-            return type_new(TYPE_U8);
-        }
-        if (strcmp(c, "i16") == 0)
-        {
-            return type_new(TYPE_I16);
-        }
-        if (strcmp(c, "u16") == 0)
-        {
-            return type_new(TYPE_U16);
-        }
-        if (strcmp(c, "i32") == 0)
-        {
-            return type_new(TYPE_I32);
-        }
-        if (strcmp(c, "u32") == 0)
-        {
-            return type_new(TYPE_U32);
-        }
-        if (strcmp(c, "i64") == 0)
-        {
-            return type_new(TYPE_I64);
-        }
-        if (strcmp(c, "u64") == 0)
-        {
-            return type_new(TYPE_U64);
-        }
-        if (strcmp(c, "i128") == 0)
-        {
-            return type_new(TYPE_I128);
-        }
-        if (strcmp(c, "u128") == 0)
-        {
-            return type_new(TYPE_U128);
-        }
+                if (strlen(t->name) == p_len && strncmp(t->name, p_ptr, p_len) == 0)
+                {
+                    char *c_part = xmalloc(c_len + 1);
+                    strncpy(c_part, c_ptr, c_len);
+                    c_part[c_len] = 0;
 
-        if (strcmp(c, "rune") == 0)
-        {
-            return type_new(TYPE_RUNE);
+                    Type *res = type_from_string_helper(c_part);
+                    free(c_part);
+                    return res;
+                }
+                if (p_end)
+                {
+                    p_ptr = p_end + 1;
+                }
+                else
+                {
+                    break;
+                }
+                if (c_end)
+                {
+                    c_ptr = c_end + 1;
+                }
+                else
+                {
+                    break;
+                }
+            }
         }
-        if (strcmp(c, "uint") == 0)
+        else if (strcmp(t->name, p) == 0)
         {
-            return type_new(TYPE_UINT);
-        }
 
-        Type *n = type_new(TYPE_STRUCT);
-        n->name = sanitize_mangled_name(c);
-        return n;
+            return type_from_string_helper(c);
+        }
     }
 
     Type *n = xmalloc(sizeof(Type));
@@ -1195,26 +1317,46 @@ Type *replace_type_formal(Type *t, const char *p, const char *c, const char *os,
             n->arg_count = 0;
             n->args = NULL;
         }
-
         else if (p && c)
         {
-            char suffix[256];
-            sprintf(suffix, "_%s", p); // e.g. "_T"
+            // Suffix Match Logic (with multi-param splitting)
+            char p_suffix[1024];
+            p_suffix[0] = 0;
+
+            char *p_temp = xstrdup(p);
+            char *tok = strtok(p_temp, ",");
+            while (tok)
+            {
+                strcat(p_suffix, "_");
+                strcat(p_suffix, tok);
+                tok = strtok(NULL, ",");
+            }
+            free(p_temp);
+
             size_t nlen = strlen(t->name);
-            size_t slen = strlen(suffix);
+            size_t slen = strlen(p_suffix);
 
-            if (nlen > slen && strcmp(t->name + nlen - slen, suffix) == 0)
+            if (nlen >= slen && strcmp(t->name + nlen - slen, p_suffix) == 0)
             {
-                // It ends in _T. Replace with _int (c), sanitizing for pointers
-                char *clean_c = sanitize_mangled_name(c);
-                char *new_name = xmalloc(nlen - slen + strlen(clean_c) + 2);
+                char c_suffix[1024];
+                c_suffix[0] = 0;
+                char *c_temp = xstrdup(c);
+                tok = strtok(c_temp, ",");
+                while (tok)
+                {
+                    strcat(c_suffix, "_");
+                    char *clean = sanitize_mangled_name(tok);
+                    strcat(c_suffix, clean);
+                    free(clean);
+                    tok = strtok(NULL, ",");
+                }
+                free(c_temp);
+
+                char *new_name = xmalloc(nlen - slen + strlen(c_suffix) + 1);
                 strncpy(new_name, t->name, nlen - slen);
                 new_name[nlen - slen] = 0;
-                strcat(new_name, "_");
-                strcat(new_name, clean_c);
-                free(clean_c);
+                strcat(new_name, c_suffix);
                 n->name = new_name;
-                // Ensure it's concrete to prevent double mangling later
                 n->kind = TYPE_STRUCT;
                 n->arg_count = 0;
                 n->args = NULL;
@@ -1622,6 +1764,92 @@ char *instantiate_function_template(ParserContext *ctx, const char *name, const
     }
 
     const char *subst_arg = unmangled_type ? unmangled_type : concrete_type;
+
+    // Scan the original return type for generic struct patterns like "Triple_X_Y_Z"
+    // and instantiate them with the concrete types
+    if (tpl->func_node && tpl->func_node->func.ret_type)
+    {
+        const char *ret = tpl->func_node->func.ret_type;
+
+        // Build the param suffix (e.g., for "X,Y,Z" -> "_X_Y_Z")
+        char param_suffix[256];
+        param_suffix[0] = 0;
+        char *tmp = xstrdup(tpl->generic_param);
+        char *tokp = strtok(tmp, ",");
+        while (tokp)
+        {
+            strcat(param_suffix, "_");
+            strcat(param_suffix, tokp);
+            tokp = strtok(NULL, ",");
+        }
+        free(tmp);
+
+        // Check if ret_type ends with param_suffix (e.g., "Triple_X_Y_Z" ends with "_X_Y_Z")
+        size_t ret_len = strlen(ret);
+        size_t suffix_len = strlen(param_suffix);
+        if (ret_len > suffix_len && strcmp(ret + ret_len - suffix_len, param_suffix) == 0)
+        {
+            // Extract base struct name (e.g., "Triple" from "Triple_X_Y_Z")
+            size_t base_len = ret_len - suffix_len;
+            char *struct_base = xmalloc(base_len + 1);
+            strncpy(struct_base, ret, base_len);
+            struct_base[base_len] = 0;
+
+            // Check if it's a known generic template
+            GenericTemplate *gt = ctx->templates;
+            while (gt && strcmp(gt->name, struct_base) != 0)
+            {
+                gt = gt->next;
+            }
+            if (gt)
+            {
+                // Parse the concrete types from unmangled_type or concrete_type
+                const char *types_src = unmangled_type ? unmangled_type : concrete_type;
+
+                // Count params in template
+                int template_param_count = 1;
+                for (const char *p = tpl->generic_param; *p; p++)
+                {
+                    if (*p == ',')
+                    {
+                        template_param_count++;
+                    }
+                }
+
+                // Split concrete types
+                char **args = xmalloc(sizeof(char *) * template_param_count);
+                int arg_count = 0;
+                char *types_copy = xstrdup(types_src);
+                char *tok = strtok(types_copy, ",");
+                while (tok && arg_count < template_param_count)
+                {
+                    args[arg_count++] = xstrdup(tok);
+                    tok = strtok(NULL, ",");
+                }
+                free(types_copy);
+
+                // Now instantiate the struct with these args
+                Token dummy_tok = {0};
+                if (arg_count == 1)
+                {
+                    instantiate_generic(ctx, struct_base, args[0], args[0], dummy_tok);
+                }
+                else if (arg_count > 1)
+                {
+                    instantiate_generic_multi(ctx, struct_base, args, arg_count, dummy_tok);
+                }
+
+                // Cleanup
+                for (int i = 0; i < arg_count; i++)
+                {
+                    free(args[i]);
+                }
+                free(args);
+            }
+            free(struct_base);
+        }
+    }
+
     ASTNode *new_fn = copy_ast_replacing(tpl->func_node, tpl->generic_param, subst_arg, NULL, NULL);
     if (!new_fn || new_fn->type != NODE_FUNCTION)
     {
@@ -2157,12 +2385,14 @@ void instantiate_generic_multi(ParserContext *ctx, const char *tpl, char **args,
         if (param_count > 0 && arg_count > 0)
         {
             // First substitution
+
             i->strct.fields = copy_fields_replacing(
                 ctx, fields, t->struct_node->strct.generic_params[0], args[0]);
 
             // Subsequent substitutions (for params B, C, etc.)
             for (int j = 1; j < param_count && j < arg_count; j++)
             {
+
                 ASTNode *tmp = copy_fields_replacing(
                     ctx, i->strct.fields, t->struct_node->strct.generic_params[j], args[j]);
                 // This leaks prev fields, but that's acceptable for now, still, TODO.