fix(abi): 修复void类型的ABI计算缺少break语句

在scc_type_abi.c文件中，void类型的case分支缺少break语句，
导致执行流程错误地进入下一个case分支。

feat(ast): 为参数声明添加索引字段

在ast_def.h头文件中为参数声明结构体添加param_idx字段，
用于跟踪参数在函数参数列表中的位置索引。

feat(ast): 更新参数初始化函数以支持索引参数

修改scc_ast.h中的scc_ast_decl_param_init函数签名，
添加参数索引idx参数，并将该值存储到参数声明结构体中。

feat(ast2ir): 添加IR转换上下文的值使用提示选项

在ast2ir.h中为scc_ast2ir_ctx_t结构体添加hint_using_value字段，
控制参数转换时是使用值还是分配内存的方式。

fix(ast2ir): 正确处理void类型到IR的转换

当遇到大小为0的类型（如void）时，直接返回void类型，
而不是尝试匹配其他大小分支。

refactor(ast2ir): 统一基本块引用类型为value_ref

将逻辑表达式、条件语句、循环语句中的基本块引用类型
从bblock_ref_t改为value_ref_t，保持类型一致性。

fix(ast2ir): 修正函数引用空值检查

使用SCC_IR_REF_nullptr常量替代0进行函数引用的空值检查，
提高代码的可读性和正确性。

refactor(ast2ir): 简化参数处理逻辑

移除不必要的函数参数获取和命名设置逻辑，
通过递归调用scc_ast2ir_decl来处理参数声明。

feat(ast2ir): 实现参数声明到IR的转换

为参数声明添加完整的IR转换逻辑，包括类型转换、
参数引用创建和内存分配处理。

refactor(ast2ir): 更新哈希表初始化接口

适配新的哈希表初始化函数签名，添加userdata参数支持，
并初始化hint_using_value字段为false。

refactor(ir): 移除函数参数的预分配逻辑

删除IR构建器中函数参数的预分配和循环添加逻辑，
简化函数开始构建的处理流程。

refactor(ir): 更新类型哈希表键值处理

修改类型哈希表的哈希和比较函数以接受模块参数，
正确处理空引用情况并支持新的键值传递方式。

fix(ir): 修复IR转储中的字符串格式

移除IR函数转储时多余的换行符，确保输出格式正确。

refactor(ir): 更新模块哈希表初始化

适配哈希表初始化接口变更，添加userdata参数，
并为各种向量预留UID 0作为无效引用。

fix(ir): 修复模块清理中的循环起始索引

将模块清理循环的起始索引从0改为1，跳过预留的
无效引用项，避免访问空指针。

refactor(ir): 调整向量和哈希表操作顺序

调整模块中向量push和哈希表set的操作顺序，
确保数据一致性和正确的UID分配。

chore(build): 移除ir2mcode模块相关文件

移除ir2mcode相关的头文件和源文件，这些组件
将在后续重构中重新设计或替换。

libs/parser/src/parse_type.c

@@ -947,9 +947,12 @@ static void parse_parameter_type_list(scc_parser_t *parser,
         }
 
         // TODO Check validation
-        param = SCC_AST_CAST_TO(scc_ast_decl_t, decl);
-        Assert(param->base.type = SCC_AST_DECL_VAR);
-        param->base.type = SCC_AST_DECL_PARAM;
+        param = scc_malloc(sizeof(scc_ast_decl_t));
+        Assert(param != nullptr);
+        scc_ast_decl_param_init(param, decl->var.type, decl->name,
+                                scc_vec_size(*params), decl->base.loc);
+        // FIXME free all node
+        scc_free(decl);
 
         scc_vec_push(*params, param);
 
@@ -968,7 +971,8 @@ static void parse_parameter_type_list(scc_parser_t *parser,
             Assert(type != nullptr);
             scc_ast_type_builtin_init(type, SCC_AST_BUILTIN_TYPE_VA_LIST,
                                       tok_ptr->loc);
-            scc_ast_decl_param_init(param, type, nullptr, tok_ptr->loc);
+            scc_ast_decl_param_init(param, type, nullptr, scc_vec_size(*params),
+                                    tok_ptr->loc);
             scc_parser_next_consume(parser, nullptr);
             scc_vec_push(*params, param);
             break;

libs/parser/src/sema_symtab.c

@@ -3,9 +3,7 @@
 void scc_sema_symtab_init(scc_sema_symtab_t *symtab) {
     symtab->root_scope.parent = nullptr;
 
-    scc_hashtable_init(&symtab->root_scope.symbols,
-                       (scc_hashtable_hash_func_t)scc_strhash32,
-                       (scc_hashtable_equal_func_t)scc_strcmp);
+    scc_hashtable_cstr_init(&symtab->root_scope.symbols);
     symtab->current_scope = &symtab->root_scope;
 }
 
@@ -23,9 +21,7 @@ void scc_sema_symtab_enter_scope(scc_sema_symtab_t *symtab) {
         return;
     }
     scope->parent = symtab->current_scope;
-    scc_hashtable_init(&scope->symbols,
-                       (scc_hashtable_hash_func_t)scc_strhash32,
-                       (scc_hashtable_equal_func_t)scc_strcmp);
+    scc_hashtable_cstr_init(&scope->symbols);
     symtab->current_scope = scope;
 }
 

libs/parser/tests/test_parse_type.c

@@ -168,7 +168,7 @@ static void test_function_type(void) {
     {
         // int (void)
         scc_ast_decl_t void_param;
-        scc_ast_decl_param_init(&void_param, &void_type, nullptr,
+        scc_ast_decl_param_init(&void_param, &void_type, nullptr, 0,
                                 scc_pos_create());
 
         scc_ast_decl_vec_t params;
@@ -189,9 +189,9 @@ static void test_function_type(void) {
                                   scc_pos_create());
 
         scc_ast_decl_t param_int, param_float;
-        scc_ast_decl_param_init(&param_int, &int_type, nullptr,
+        scc_ast_decl_param_init(&param_int, &int_type, nullptr, 0,
                                 scc_pos_create());
-        scc_ast_decl_param_init(&param_float, &float_type, nullptr,
+        scc_ast_decl_param_init(&param_float, &float_type, nullptr, 1,
                                 scc_pos_create());
 
         scc_ast_decl_vec_t params;
@@ -213,9 +213,9 @@ static void test_function_type(void) {
                                   scc_pos_create());
 
         scc_ast_decl_t param_int, param_var;
-        scc_ast_decl_param_init(&param_int, &int_type, nullptr,
+        scc_ast_decl_param_init(&param_int, &int_type, nullptr, 0,
                                 scc_pos_create());
-        scc_ast_decl_param_init(&param_var, &va_list_type, "...",
+        scc_ast_decl_param_init(&param_var, &va_list_type, "...", 1,
                                 scc_pos_create());
 
         scc_ast_decl_vec_t params;
@@ -242,7 +242,7 @@ static void test_function_type(void) {
     {
         // int (*)(void)
         scc_ast_decl_t void_param;
-        scc_ast_decl_param_init(&void_param, &void_type, nullptr,
+        scc_ast_decl_param_init(&void_param, &void_type, nullptr, 0,
                                 scc_pos_create());
 
         scc_ast_decl_vec_t params;
@@ -495,7 +495,7 @@ static void test_hard_type(void) {
     {
         // 1) 函数类型 int (void)
         scc_ast_decl_t void_param;
-        scc_ast_decl_param_init(&void_param, &void_type, nullptr,
+        scc_ast_decl_param_init(&void_param, &void_type, nullptr, 0,
                                 scc_pos_create());
         scc_ast_decl_vec_t params;
         scc_vec_init(params);
@@ -543,7 +543,7 @@ static void test_hard_type(void) {
 
         // 3) 函数类型，返回上述指针，无参数
         scc_ast_decl_t void_param;
-        scc_ast_decl_param_init(&void_param, &void_type, nullptr,
+        scc_ast_decl_param_init(&void_param, &void_type, nullptr, 0,
                                 scc_pos_create());
         scc_ast_decl_vec_t params;
         scc_vec_init(params);
@@ -566,7 +566,7 @@ static void test_hard_type(void) {
     {
         // 1) 函数类型 int (void)
         scc_ast_decl_t void_param;
-        scc_ast_decl_param_init(&void_param, &void_type, nullptr,
+        scc_ast_decl_param_init(&void_param, &void_type, nullptr, 0,
                                 scc_pos_create());
         scc_ast_decl_vec_t params;
         scc_vec_init(params);

libs/parser/tests/test_parse_unit.c

@@ -43,7 +43,7 @@ static void test_parser_unit(void) {
         scc_ast_type_t func_type;
         scc_ast_decl_vec_t func_params;
         scc_ast_decl_t void_decl;
-        scc_ast_decl_param_init(&void_decl, &void_type, nullptr,
+        scc_ast_decl_param_init(&void_decl, &void_type, nullptr, 0,
                                 scc_pos_create());
         scc_ast_decl_t *array[] = {&void_decl};
         scc_vec_unsafe_from_static_array(func_params, array);
@@ -67,7 +67,7 @@ static void test_parser_unit(void) {
         scc_ast_type_t func_type;
         scc_ast_decl_vec_t func_params;
         scc_ast_decl_t void_decl;
-        scc_ast_decl_param_init(&void_decl, &void_type, nullptr,
+        scc_ast_decl_param_init(&void_decl, &void_type, nullptr, 0,
                                 scc_pos_create());
         scc_ast_decl_t *array[] = {&void_decl};
         scc_vec_unsafe_from_static_array(func_params, array);
@@ -116,7 +116,7 @@ static void test_parser_unit(void) {
         scc_ast_type_t func_type;
         scc_ast_decl_vec_t func_params;
         scc_ast_decl_t void_decl;
-        scc_ast_decl_param_init(&void_decl, &void_type, nullptr,
+        scc_ast_decl_param_init(&void_decl, &void_type, nullptr, 0,
                                 scc_pos_create());
         scc_ast_decl_t *array[] = {&void_decl};
         scc_vec_unsafe_from_static_array(func_params, array);
@@ -319,14 +319,14 @@ static void test_parser_unit(void) {
     {
         scc_ast_decl_vec_t params;
         scc_ast_decl_t param0;
-        scc_ast_decl_param_init(&param0, (scc_ast_type_t *)&int_type, "a",
+        scc_ast_decl_param_init(&param0, (scc_ast_type_t *)&int_type, "a", 0,
                                 scc_pos_create());
         scc_ast_decl_t param1;
-        scc_ast_decl_param_init(&param1, (scc_ast_type_t *)&int_type, "b",
+        scc_ast_decl_param_init(&param1, (scc_ast_type_t *)&int_type, "b", 1,
                                 scc_pos_create());
         scc_ast_decl_t param2;
         scc_ast_decl_param_init(&param2, (scc_ast_type_t *)&va_list_type,
-                                nullptr, scc_pos_create());
+                                nullptr, 2, scc_pos_create());
         scc_ast_decl_t *params_array[] = {&param0, &param1, &param2};
         scc_vec_unsafe_from_static_array(params, params_array);
         scc_ast_type_t decl_func_type;
@@ -433,11 +433,11 @@ static void test_parser_unit(void) {
                                   scc_pos_create());
 
         scc_ast_decl_t param1;
-        scc_ast_decl_param_init(&param1, &type_type, "a", scc_pos_create());
+        scc_ast_decl_param_init(&param1, &type_type, "a", 0, scc_pos_create());
         scc_ast_decl_t param2;
-        scc_ast_decl_param_init(&param2, &int_type, "b", scc_pos_create());
+        scc_ast_decl_param_init(&param2, &int_type, "b", 1, scc_pos_create());
         scc_ast_decl_t param3;
-        scc_ast_decl_param_init(&param3, &va_list_type, nullptr,
+        scc_ast_decl_param_init(&param3, &va_list_type, nullptr, 2,
                                 scc_pos_create());
         scc_ast_decl_t *params_array[] = {&param1, &param2, &param3};
         scc_ast_decl_vec_t func_params;
@@ -495,7 +495,7 @@ static void test_parser_unit(void) {
 
         // 2. 参数声明
         scc_ast_decl_t param_decl;
-        scc_ast_decl_param_init(&param_decl, &ptr_to_char, "fmt",
+        scc_ast_decl_param_init(&param_decl, &ptr_to_char, "fmt", 0,
                                 scc_pos_create());
 
         // 3. 返回类型：void *
@@ -814,7 +814,7 @@ static void test_parser_unit(void) {
         scc_ast_type_t func_type;
         scc_ast_decl_vec_t func_params;
         scc_ast_decl_t void_decl;
-        scc_ast_decl_param_init(&void_decl, &void_type, nullptr,
+        scc_ast_decl_param_init(&void_decl, &void_type, nullptr, 0,
                                 scc_pos_create());
         scc_ast_decl_t *array[] = {&void_decl};
         scc_vec_unsafe_from_static_array(func_params, array);
@@ -841,12 +841,13 @@ static void test_parser_unit(void) {
         scc_ast_type_t func_hard_type;
 
         scc_ast_decl_t param1;
-        scc_ast_decl_param_init(&param1, &ptr_to_func, "bar", scc_pos_create());
+        scc_ast_decl_param_init(&param1, &ptr_to_func, "bar", 0,
+                                scc_pos_create());
         scc_ast_decl_t param2;
-        scc_ast_decl_param_init(&param2, &typedef_func_type, "a",
+        scc_ast_decl_param_init(&param2, &typedef_func_type, "a", 1,
                                 scc_pos_create());
         scc_ast_decl_t param3;
-        scc_ast_decl_param_init(&param1, &va_list_type, nullptr,
+        scc_ast_decl_param_init(&param1, &va_list_type, nullptr, 2,
                                 scc_pos_create());
         scc_ast_decl_t *func_hard_array[] = {&param1, &param2, &param3};
         scc_ast_decl_vec_t func_hard_params;