refactor(ast): 将AST类型系统重构为规范类型系统

- 将scc_ast_type_t替换为scc_ast_qual_type_t，引入规范类型概念
- 添加scc_ast_canonical_type_t联合体用于表示规范类型
- 修改头文件结构，移除大量内联初始化函数，改为使用AST上下文分配器
- 添加SCC_AST_ALLOC宏用于统一节点分配管理
- 更新builtin类型枚举定义，添加类型计数常量

feat(ast): 引入AST上下文管理器

- 创建scc_ast_ctx_t结构体用于管理AST节点生命周期
- 实现类型池化机制，支持内置类型的统一管理
- 添加canonical类型获取和分配接口

refactor(abi): 适配新的AST类型系统

- 更新头文件包含，从<scc_ir.h>改为<scc_hir.h>
- 适配函数参数类型，使用qual_type替代原始type
- 使用scc_ast_canon_type()函数获取规范类型进行处理

Co-authored-by: Copilot <copilot@github.com>

libs/abi/src/scc_type_abi.c

@@ -1,12 +1,12 @@
 #include <scc_ast.h>
-#include <scc_ir.h>
+#include <scc_hir.h>
 #include <scc_type_abi.h>
 
 void scc_abi_compute_ast_type_layout(const scc_abi_type_calc_t *ctx, void *type,
                                      scc_abi_type_layout_t *layout) {
-    scc_ast_type_t *ast_type = type;
+    scc_ast_qual_type_t *ast_type = type;
     scc_abi_base_type_kind_t kind = SCC_ABI_TYPE_VOID;
-    switch (ast_type->builtin.type) {
+    switch (scc_ast_canon_type(ast_type)->builtin.type) {
     case SCC_AST_BUILTIN_TYPE_VOID:
         kind = SCC_ABI_TYPE_VOID;
         break;
@@ -56,7 +56,8 @@ void scc_abi_compute_ast_type_layout(const scc_abi_type_calc_t *ctx, void *type,
         kind = SCC_ABI_TYPE_U_LONG_LONG;
         break;
     default:
-        Panic("Unsupported AST type: %d", ast_type->builtin.type);
+        Panic("Unsupported AST type: %d",
+              scc_ast_canon_type(ast_type)->builtin.type);
         break;
     }
     scc_abi_get_base_type_layout(ctx->impls, kind, layout);

libs/ast/include/scc_ast.h

@@ -3,599 +3,46 @@
 
 #include "scc_ast_def.h"
 
-// decls can be nullptr but maybe warning
+typedef struct scc_ast_ctx {
+    scc_ast_canon_type_vec_t canonical_type_pool;
+    scc_ast_canon_type_t *builtin_types[SCC_AST_BUILTIN_TYPE_COUNT];
+    scc_ast_node_vec_t all_nodes;
+} scc_ast_ctx_t;
+
+void scc_ast_ctx_init(scc_ast_ctx_t *ctx);
+void scc_ast_ctx_drop(scc_ast_ctx_t *ctx);
+
+scc_ast_canon_type_t *scc_ast_ctx_get_builtin_type(scc_ast_ctx_t *ctx,
+                                                   scc_ast_builtin_type_t kind);
+
+scc_ast_canon_type_t *scc_ast_ctx_alloc_type(scc_ast_ctx_t *ctx);
+
+static inline void *scc_ast_ctx_alloc_node(scc_ast_ctx_t *ctx, usize size) {
+    void *ptr = scc_malloc(size);
+    if (ptr == nullptr) {
+        Panic("Out of memory");
+    }
+    scc_memset(ptr, 0, size);
+    scc_vec_push(ctx->all_nodes, (scc_ast_node_t *)ptr);
+    return ptr;
+}
+
+#define SCC_AST_ALLOC(ctx, type)                                               \
+    ((type *)scc_ast_ctx_alloc_node(ctx, sizeof(type)))
+#define SCC_AST_ALLOC_QUAL_TYPE(ctx) SCC_AST_ALLOC(ctx, scc_ast_qual_type_t)
+#define SCC_AST_ALLOC_DECL(ctx) SCC_AST_ALLOC(ctx, scc_ast_decl_t)
+#define SCC_AST_ALLOC_EXPR(ctx) SCC_AST_ALLOC(ctx, scc_ast_expr_t)
+#define SCC_AST_ALLOC_STMT(ctx) SCC_AST_ALLOC(ctx, scc_ast_stmt_t)
+
+// have defined cannoical_type type
 static inline void
-scc_ast_translation_unit_init(scc_ast_translation_unit_t *translation_unit,
+scc_ast_type_builtin_init(scc_ast_qual_type_t *type, scc_ast_ctx_t *ctx,
-                              scc_ast_decl_vec_t *decls, scc_pos_t loc) {
+                          scc_ast_builtin_type_t builtin_type, scc_pos_t loc) {
-    Assert(translation_unit != nullptr);
-    translation_unit->base.type = SCC_AST_TRANSLATION_UNIT;
-    translation_unit->base.loc = loc;
-    if (decls == nullptr) {
-        scc_vec_init(translation_unit->declarations);
-    } else {
-        translation_unit->declarations = *decls;
-        scc_vec_init(*decls);
-    }
-}
-
-static inline void scc_ast_decl_list_init(scc_ast_decl_t *decl,
-                                          scc_ast_decl_vec_t *list_move,
-                                          scc_pos_t loc) {
-    Assert(decl != nullptr && list_move != nullptr);
-    decl->base.loc = loc;
-    decl->base.type = SCC_AST_DECL_LIST;
-    decl->name = nullptr;
-    decl->list.vars = *list_move;
-    scc_vec_init(*list_move);
-}
-
-// name and var_init can be nullptr
-static inline void scc_ast_decl_unsafe_val_init(scc_ast_decl_t *decl,
-                                                scc_ast_type_t *type,
-                                                const char *name,
-                                                scc_ast_expr_t *var_init,
-                                                scc_pos_t loc) {
-    Assert(decl != nullptr && type != nullptr);
-    decl->base.loc = loc;
-    decl->base.type = SCC_AST_DECL_VAR;
-    decl->name = name;
-    decl->var.type = type;
-    decl->var.init = var_init;
-}
-
-// var_init can be nullptr
-static inline void scc_ast_decl_val_init(scc_ast_decl_t *decl,
-                                         scc_ast_type_t *type, const char *name,
-                                         scc_ast_expr_t *var_init,
-                                         scc_pos_t loc) {
-    Assert(decl != nullptr && name != nullptr && type != nullptr);
-    decl->base.loc = loc;
-    decl->base.type = SCC_AST_DECL_VAR;
-    decl->name = name;
-    decl->var.type = type;
-    decl->var.init = var_init;
-}
-
-// body can be nullptr
-static inline void scc_ast_decl_func_init(scc_ast_decl_t *decl,
-                                          scc_ast_type_t *type,
-                                          const char *name,
-                                          scc_ast_stmt_t *body, scc_pos_t loc) {
-    Assert(decl != nullptr && name != nullptr && type != nullptr);
-    decl->base.loc = loc;
-    decl->base.type = SCC_AST_DECL_FUNC;
-    decl->name = name;
-    decl->func.type = type;
-    Assert(type->base.type == SCC_AST_TYPE_FUNCTION);
-    decl->func.body = body;
-}
-
-// name can be nullptr
-static inline void scc_ast_decl_param_init(scc_ast_decl_t *decl,
-                                           scc_ast_type_t *type,
-                                           const char *name, int idx,
-                                           scc_pos_t loc) {
-    Assert(decl != nullptr && type != nullptr);
-    decl->base.loc = loc;
-    decl->base.type = SCC_AST_DECL_PARAM;
-    decl->name = name;
-    decl->param.type = type;
-    decl->param.param_idx = idx;
-}
-
-static inline void _scc_ast_decl_record_init(scc_ast_decl_t *decl,
-                                             scc_ast_node_kind_t type,
-                                             const char *name,
-                                             scc_ast_decl_vec_t *fields_move,
-                                             scc_pos_t loc) {
-    Assert(decl != nullptr);
-    decl->base.loc = loc;
-    decl->base.type = type;
-    decl->name = name;
-    if (fields_move == nullptr) {
-        scc_vec_init(decl->record.fields);
-    } else {
-        decl->record.fields = *fields_move;
-        scc_vec_init(*fields_move);
-    }
-}
-
-// name and fields can be nullptr
-static inline void scc_ast_decl_struct_init(scc_ast_decl_t *decl,
-                                            const char *name,
-                                            scc_ast_decl_vec_t *fields_move,
-                                            scc_pos_t loc) {
-    _scc_ast_decl_record_init(decl, SCC_AST_DECL_STRUCT, name, fields_move,
-                              loc);
-}
-
-// name and fields can be nullptr
-static inline void scc_ast_decl_union_init(scc_ast_decl_t *decl,
-                                           const char *name,
-                                           scc_ast_decl_vec_t *fields_move,
-                                           scc_pos_t loc) {
-    _scc_ast_decl_record_init(decl, SCC_AST_DECL_UNION, name, fields_move, loc);
-}
-
-// name and fields can be nullptr
-static inline void scc_ast_decl_enum_init(scc_ast_decl_t *decl,
-                                          const char *name,
-                                          scc_ast_decl_vec_t *fields_move,
-                                          scc_pos_t loc) {
-    _scc_ast_decl_record_init(decl, SCC_AST_DECL_ENUM, name, fields_move, loc);
-}
-
-static inline void scc_ast_decl_typedef_init(scc_ast_decl_t *decl,
-                                             const char *name,
-                                             scc_ast_type_t *type,
-                                             scc_pos_t loc) {
-    Assert(decl != nullptr && name != nullptr && type != nullptr);
-    decl->base.loc = loc;
-    decl->base.type = SCC_AST_DECL_TYPEDEF;
-    decl->name = name;
-    decl->typedef_decl.type = type;
-}
-
-// items can be nullptr
-static inline void scc_ast_stmt_compound_init(
-    scc_ast_stmt_t *stmt, scc_ast_block_item_vec_t *items_move, scc_pos_t loc) {
-    Assert(stmt != nullptr);
-    stmt->base.loc = loc;
-    stmt->base.type = SCC_AST_STMT_COMPOUND;
-    if (items_move == nullptr) {
-        scc_vec_init(stmt->compound.block_items);
-    } else {
-        stmt->compound.block_items = *items_move;
-        scc_vec_init(*items_move);
-    }
-}
-
-// expr can be nullptr
-static inline void scc_ast_stmt_expr_init(scc_ast_stmt_t *stmt,
-                                          scc_ast_expr_t *expr, scc_pos_t loc) {
-    Assert(stmt != nullptr);
-    stmt->base.loc = loc;
-    stmt->base.type = SCC_AST_STMT_EXPR;
-    stmt->expr.expr = expr;
-}
-
-// opt_else can be nullptr
-static inline void scc_ast_stmt_if_init(scc_ast_stmt_t *stmt,
-                                        scc_ast_expr_t *cond,
-                                        scc_ast_stmt_t *then,
-                                        scc_ast_stmt_t *opt_else,
-                                        scc_pos_t loc) {
-    Assert(stmt != nullptr && cond != nullptr && then != nullptr);
-    stmt->base.loc = loc;
-    stmt->base.type = SCC_AST_STMT_IF;
-    stmt->if_stmt.cond = cond;
-    stmt->if_stmt.then_stmt = then;
-    stmt->if_stmt.opt_else_stmt = opt_else;
-}
-
-static inline void scc_ast_stmt_while_init(scc_ast_stmt_t *stmt,
-                                           scc_ast_expr_t *cond,
-                                           scc_ast_stmt_t *body,
-                                           scc_pos_t loc) {
-    Assert(stmt != nullptr && cond != nullptr && body != nullptr);
-    stmt->base.loc = loc;
-    stmt->base.type = SCC_AST_STMT_WHILE;
-    stmt->while_stmt.cond = cond;
-    stmt->while_stmt.body = body;
-}
-
-static inline void scc_ast_stmt_do_while_init(scc_ast_stmt_t *stmt,
-                                              scc_ast_expr_t *cond,
-                                              scc_ast_stmt_t *body,
-                                              scc_pos_t loc) {
-    Assert(stmt != nullptr && cond != nullptr && body != nullptr);
-    stmt->base.loc = loc;
-    stmt->base.type = SCC_AST_STMT_DO_WHILE;
-    stmt->while_stmt.cond = cond;
-    stmt->while_stmt.body = body;
-}
-
-// FIXME
-static inline void scc_ast_stmt_for_init(scc_ast_stmt_t *stmt,
-                                         scc_ast_node_t *init,
-                                         scc_ast_expr_t *cond,
-                                         scc_ast_expr_t *incr,
-                                         scc_ast_stmt_t *body, scc_pos_t loc) {
-    Assert(stmt != nullptr && body != nullptr);
-    stmt->base.loc = loc;
-    stmt->base.type = SCC_AST_STMT_FOR;
-    stmt->for_stmt.init = init;
-    stmt->for_stmt.cond = cond;
-    stmt->for_stmt.incr = incr;
-    stmt->for_stmt.body = body;
-}
-
-static inline void scc_ast_stmt_switch_init(scc_ast_stmt_t *stmt,
-                                            scc_ast_expr_t *cond,
-                                            scc_ast_stmt_t *body,
-                                            scc_pos_t loc) {
-    Assert(stmt != nullptr && cond != nullptr && body != nullptr);
-    stmt->base.loc = loc;
-    stmt->base.type = SCC_AST_STMT_SWITCH;
-    stmt->switch_stmt.cond = cond;
-    stmt->switch_stmt.body = body;
-}
-
-static inline void scc_ast_stmt_case_init(scc_ast_stmt_t *stmt,
-                                          scc_ast_expr_t *cond,
-                                          scc_ast_stmt_t *body, scc_pos_t loc) {
-    Assert(stmt != nullptr && cond != nullptr && body != nullptr);
-    stmt->base.loc = loc;
-    stmt->base.type = SCC_AST_STMT_CASE;
-    stmt->case_stmt.expr = cond;
-    stmt->case_stmt.stmt = body;
-}
-
-static inline void scc_ast_stmt_default_init(scc_ast_stmt_t *stmt,
-                                             scc_ast_stmt_t *body,
-                                             scc_pos_t loc) {
-    Assert(stmt != nullptr && body != nullptr);
-    stmt->base.loc = loc;
-    stmt->base.type = SCC_AST_STMT_DEFAULT;
-    stmt->default_stmt.stmt = body;
-}
-
-static inline void scc_ast_stmt_break_init(scc_ast_stmt_t *stmt,
-                                           scc_pos_t loc) {
-    Assert(stmt != nullptr);
-    stmt->base.loc = loc;
-    stmt->base.type = SCC_AST_STMT_BREAK;
-    stmt->jump._target = nullptr;
-}
-
-static inline void scc_ast_stmt_continue_init(scc_ast_stmt_t *stmt,
-                                              scc_pos_t loc) {
-    Assert(stmt != nullptr);
-    stmt->base.loc = loc;
-    stmt->base.type = SCC_AST_STMT_CONTINUE;
-    stmt->jump._target = nullptr;
-}
-
-// expr can be nullptr
-static inline void scc_ast_stmt_return_init(scc_ast_stmt_t *stmt,
-                                            scc_ast_expr_t *expr,
-                                            scc_pos_t loc) {
-    Assert(stmt != nullptr);
-    stmt->base.loc = loc;
-    stmt->base.type = SCC_AST_STMT_RETURN;
-    stmt->return_stmt.expr = expr;
-}
-
-static inline void scc_ast_stmt_goto_init(scc_ast_stmt_t *stmt,
-                                          const char *label, scc_pos_t loc) {
-    Assert(stmt != nullptr && label != nullptr);
-    stmt->base.loc = loc;
-    stmt->base.type = SCC_AST_STMT_GOTO;
-    stmt->goto_stmt.label = label;
-    stmt->goto_stmt._target = nullptr;
-}
-
-static inline void scc_ast_stmt_label_init(scc_ast_stmt_t *stmt,
-                                           const char *label,
-                                           scc_ast_stmt_t *body,
-                                           scc_pos_t loc) {
-    Assert(stmt != nullptr);
-    stmt->base.loc = loc;
-    stmt->base.type = SCC_AST_STMT_LABEL;
-    stmt->label_stmt.label = label;
-    stmt->label_stmt.stmt = body;
-}
-
-static inline void scc_ast_expr_binary_init(scc_ast_expr_t *expr,
-                                            scc_ast_expr_op_t op,
-                                            scc_ast_expr_t *lhs,
-                                            scc_ast_expr_t *rhs,
-                                            scc_pos_t loc) {
-    Assert(expr != nullptr && lhs != nullptr && rhs != nullptr);
-    expr->base.loc = loc;
-    expr->base.type = SCC_AST_EXPR_BINARY;
-    expr->binary.op = op;
-    expr->binary.lhs = lhs;
-    expr->binary.rhs = rhs;
-}
-
-static inline void scc_ast_expr_unary_init(scc_ast_expr_t *expr,
-                                           scc_ast_expr_op_t op,
-                                           scc_ast_expr_t *operand,
-                                           scc_pos_t loc) {
-    Assert(expr != nullptr && operand != nullptr);
-    expr->base.loc = loc;
-    expr->base.type = SCC_AST_EXPR_UNARY;
-    expr->unary.op = op;
-    expr->unary.operand = operand;
-}
-
-static inline void scc_ast_expr_cond_init(scc_ast_expr_t *expr,
-                                          scc_ast_expr_t *cond,
-                                          scc_ast_expr_t *then_expr,
-                                          scc_ast_expr_t *else_expr,
-                                          scc_pos_t loc) {
-    Assert(expr != nullptr && cond != nullptr && then_expr != nullptr &&
-           else_expr != nullptr);
-    expr->base.loc = loc;
-    expr->base.type = SCC_AST_EXPR_COND;
-    expr->cond.cond = cond;
-    expr->cond.then_expr = then_expr;
-    expr->cond.else_expr = else_expr;
-}
-
-// args can be nullptr
-static inline void scc_ast_expr_call_init(scc_ast_expr_t *expr,
-                                          scc_ast_expr_t *callee,
-                                          scc_ast_expr_vec_t *args,
-                                          scc_pos_t loc) {
-    Assert(expr != nullptr && callee != nullptr);
-    expr->base.loc = loc;
-    expr->base.type = SCC_AST_EXPR_CALL;
-    expr->call.callee = callee;
-    if (args == nullptr) {
-        scc_vec_init(expr->call.args);
-    } else {
-        expr->call.args = *args;
-    }
-}
-
-// SCC_AST_EXPR_ARRAY_SUBSCRIPT,  // 数组下标
-static inline void scc_ast_expr_array_subscript_init(scc_ast_expr_t *expr,
-                                                     scc_ast_expr_t *array,
-                                                     scc_ast_expr_t *index,
-                                                     scc_pos_t loc) {
-    Assert(expr != nullptr && array != nullptr && index != nullptr);
-    expr->base.loc = loc;
-    expr->base.type = SCC_AST_EXPR_ARRAY_SUBSCRIPT;
-    expr->subscript.array = array;
-    expr->subscript.index = index;
-}
-
-static inline void _scc_ast_expr_member_init(scc_ast_expr_t *expr,
-                                             scc_ast_node_kind_t type,
-                                             scc_ast_expr_t *object,
-                                             const char *member,
-                                             scc_pos_t loc) {
-    Assert(expr != nullptr && object != nullptr && member != nullptr);
-    expr->base.loc = loc;
-    expr->base.type = type;
-    expr->member.base = object;
-    expr->member.name = member;
-    expr->member._target_idx = 0;
-}
-
-static inline void scc_ast_expr_member_init(scc_ast_expr_t *expr,
-                                            scc_ast_expr_t *object,
-                                            const char *member, scc_pos_t loc) {
-    _scc_ast_expr_member_init(expr, SCC_AST_EXPR_MEMBER, object, member, loc);
-}
-
-static inline void scc_ast_expr_ptr_member_init(scc_ast_expr_t *expr,
-                                                scc_ast_expr_t *object,
-                                                const char *member,
-                                                scc_pos_t loc) {
-    _scc_ast_expr_member_init(expr, SCC_AST_EXPR_PTR_MEMBER, object, member,
-                              loc);
-}
-
-static inline void scc_ast_expr_cast_init(scc_ast_expr_t *expr,
-                                          scc_ast_type_t *type,
-                                          scc_ast_expr_t *operand,
-                                          scc_pos_t loc) {
-    Assert(expr != nullptr && type != nullptr && operand != nullptr);
-    expr->base.loc = loc;
-    expr->base.type = SCC_AST_EXPR_CAST;
-    expr->cast.type = type;
-    expr->cast.expr = operand;
-}
-
-// type and target_expr can be nullptr but it only one of them can be nullptr
-static inline void scc_ast_expr_sizeof_init(scc_ast_expr_t *expr,
-                                            scc_ast_type_t *type,
-                                            scc_ast_expr_t *target_expr,
-                                            scc_pos_t loc) {
-    Assert(expr != nullptr);
-    expr->base.loc = loc;
-    expr->base.type = SCC_AST_EXPR_SIZE_OF;
-    expr->attr_of.type = type;
-    expr->attr_of.expr = target_expr;
-}
-
-// type and target_expr can be nullptr but it only one of them can be nullptr
-static inline void scc_ast_expr_alignof_init(scc_ast_expr_t *expr,
-                                             scc_ast_type_t *type,
-                                             scc_ast_expr_t *target_expr,
-                                             scc_pos_t loc) {
-    Assert(expr != nullptr);
-    expr->base.loc = loc;
-    expr->base.type =
-        SCC_AST_EXPR_SIZE_OF; // 注意：这里使用了 SIZE_OF，可能需要改为 ALIGN_OF
-    expr->attr_of.type = type;
-    expr->attr_of.expr = target_expr;
-}
-
-// lhs_exprs and rhs_exprs can be nullptr
-static inline void scc_ast_expr_compound_init(scc_ast_expr_t *expr,
-                                              scc_ast_expr_t *base,
-                                              scc_ast_expr_vec_t *lhs_exprs,
-                                              scc_ast_expr_vec_t *rhs_exprs,
-                                              scc_pos_t loc) {
-    Assert(expr != nullptr && base != nullptr);
-    expr->base.loc = loc;
-    expr->base.type = SCC_AST_EXPR_COMPOUND;
-    expr->compound.base = base;
-
-    if (lhs_exprs == nullptr) {
-        scc_vec_init(expr->compound.lhs_exprs);
-    } else {
-        expr->compound.lhs_exprs = *lhs_exprs;
-        scc_vec_init(*lhs_exprs);
-    }
-
-    if (rhs_exprs == nullptr) {
-        scc_vec_init(expr->compound.rhs_exprs);
-    } else {
-        expr->compound.rhs_exprs = *rhs_exprs;
-        scc_vec_init(*rhs_exprs);
-    }
-}
-
-static inline void scc_ast_expr_literal_init(scc_ast_expr_t *expr,
-                                             scc_ast_node_kind_t type,
-                                             const char *value, cbool owned,
-                                             scc_pos_t loc) {
-    Assert(expr != nullptr && value != nullptr);
-    expr->base.loc = loc;
-    expr->base.type = type;
-    expr->literal.lexme = value;
-    expr->literal.owned = owned;
-}
-
-static inline void scc_ast_expr_literal_int_init(scc_ast_expr_t *expr,
-                                                 const char *value, cbool owned,
-                                                 scc_pos_t loc) {
-    scc_ast_expr_literal_init(expr, SCC_AST_EXPR_INT_LITERAL, value, owned,
-                              loc);
-}
-
-static inline void scc_ast_expr_literal_float_init(scc_ast_expr_t *expr,
-                                                   const char *value,
-                                                   cbool owned, scc_pos_t loc) {
-    scc_ast_expr_literal_init(expr, SCC_AST_EXPR_FLOAT_LITERAL, value, owned,
-                              loc);
-}
-static inline void scc_ast_expr_literal_char_init(scc_ast_expr_t *expr,
-                                                  const char *value,
-                                                  cbool owned, scc_pos_t loc) {
-    scc_ast_expr_literal_init(expr, SCC_AST_EXPR_CHAR_LITERAL, value, owned,
-                              loc);
-}
-static inline void scc_ast_expr_literal_string_init(scc_ast_expr_t *expr,
-                                                    const char *value,
-                                                    cbool owned,
-                                                    scc_pos_t loc) {
-    scc_ast_expr_literal_init(expr, SCC_AST_EXPR_STRING_LITERAL, value, owned,
-                              loc);
-}
-
-static inline void scc_ast_expr_identifier_init(scc_ast_expr_t *expr,
-                                                const char *name,
-                                                scc_pos_t loc) {
-    Assert(expr != nullptr && name != nullptr);
-    expr->base.loc = loc;
-    expr->base.type = SCC_AST_EXPR_IDENTIFIER;
-    expr->identifier.name = name;
-    expr->identifier._target = nullptr;
-}
-
-static inline void scc_ast_expr_lvalue_init(scc_ast_expr_t *expr,
-                                            scc_ast_type_t *type,
-                                            scc_pos_t loc) {
-    Assert(expr != nullptr && type != nullptr);
-    expr->base.loc = loc;
-    expr->base.type = SCC_AST_EXPR_LVALUE;
-    expr->lvalue.type = type;
-}
-
-// have defined builtin type
-static inline void scc_ast_type_builtin_init(scc_ast_type_t *type,
-                                             scc_ast_builtin_type_t builtin,
-                                             scc_pos_t loc) {
     Assert(type != nullptr);
     type->base.loc = loc;
     type->base.type = SCC_AST_TYPE_BUILTIN;
-    type->builtin.type = builtin;
+    type->type = scc_ast_ctx_get_builtin_type(ctx, builtin_type);
     type->quals = (scc_ast_decl_specifier_t){0}; // FIXME
 }
 
-static inline void scc_ast_type_pointer_init(scc_ast_type_t *type,
-                                             scc_ast_type_t *pointee,
-                                             scc_pos_t loc) {
-    Assert(type != nullptr && pointee != nullptr);
-    type->base.loc = loc;
-    type->base.type = SCC_AST_TYPE_POINTER;
-    type->quals = (scc_ast_decl_specifier_t){0}; // FIXME
-    type->pointer.pointee = pointee;
-}
-
-// size can be nullptr
-static inline void scc_ast_type_array_init(scc_ast_type_t *type,
-                                           scc_ast_type_t *element,
-                                           scc_ast_expr_t *size,
-                                           scc_pos_t loc) {
-    Assert(type != nullptr && element != nullptr);
-    type->base.loc = loc;
-    type->base.type = SCC_AST_TYPE_ARRAY;
-    type->quals = (scc_ast_decl_specifier_t){0}; // FIXME
-    type->array.element = element;
-    type->array.size = size;
-}
-
-// return_type and params can be nullptr
-static inline void scc_ast_type_function_init(scc_ast_type_t *type,
-                                              scc_ast_type_t *return_type,
-                                              scc_ast_decl_vec_t *params,
-                                              scc_pos_t loc) {
-    Assert(type != nullptr);
-    type->base.loc = loc;
-    type->base.type = SCC_AST_TYPE_FUNCTION;
-    type->function.return_type = return_type;
-    type->quals = (scc_ast_decl_specifier_t){0}; // FIXME
-    if (params == nullptr) {
-        scc_vec_init(type->function.params);
-    } else {
-        type->function.params = *params;
-        scc_vec_init(*params);
-    }
-}
-
-static inline void _scc_ast_type_record_init(scc_ast_type_t *type,
-                                             scc_ast_node_kind_t type_kind,
-                                             const char *name,
-                                             scc_ast_decl_t *decl,
-                                             scc_pos_t loc) {
-    Assert(type != nullptr);
-    type->base.loc = loc;
-    type->base.type = type_kind;
-    type->quals = (scc_ast_decl_specifier_t){0}; // FIXME
-    type->record.name = name;
-    type->record.decl = decl;
-}
-
-// name and decl can be nullptr
-static inline void scc_ast_type_struct_init(scc_ast_type_t *type,
-                                            const char *name,
-                                            scc_ast_decl_t *decl,
-                                            scc_pos_t loc) {
-    _scc_ast_type_record_init(type, SCC_AST_TYPE_STRUCT, name, decl, loc);
-}
-
-// name and decl can be nullptr
-static inline void scc_ast_type_union_init(scc_ast_type_t *type,
-                                           const char *name,
-                                           scc_ast_decl_t *decl,
-                                           scc_pos_t loc) {
-    _scc_ast_type_record_init(type, SCC_AST_TYPE_UNION, name, decl, loc);
-}
-
-// name and decl can be nullptr
-static inline void scc_ast_type_enum_init(scc_ast_type_t *type,
-                                          const char *name,
-                                          scc_ast_decl_t *decl, scc_pos_t loc) {
-    _scc_ast_type_record_init(type, SCC_AST_TYPE_ENUM, name, decl, loc);
-}
-
-static inline void scc_ast_type_typedef_init(scc_ast_type_t *type,
-                                             const char *name,
-                                             scc_ast_decl_t *target,
-                                             scc_pos_t loc) {
-    Assert(type != nullptr && target != nullptr);
-    type->base.loc = loc;
-    type->base.type = SCC_AST_TYPE_TYPEDEF;
-    type->quals = (scc_ast_decl_specifier_t){0}; // FIXME
-    type->typedef_type.name = name;
-    type->typedef_type.decl = target;
-}
-
 #endif /* __SCC_AST_H__*/

libs/ast/include/scc_ast_def.h

@@ -64,7 +64,7 @@ typedef enum {
     scc_ast_expr_t_END,      // 表达式结束
 
     // 类型
-    scc_ast_type_t_BEGIN,  // 类型开始
+    scc_ast_qual_type_t_BEGIN, // 类型开始
     SCC_AST_TYPE_BUILTIN,      // 内置类型
     SCC_AST_TYPE_POINTER,      // 指针类型
     SCC_AST_TYPE_ARRAY,        // 数组类型
@@ -73,7 +73,7 @@ typedef enum {
     SCC_AST_TYPE_UNION,        // 联合类型
     SCC_AST_TYPE_ENUM,         // 枚举类型
     SCC_AST_TYPE_TYPEDEF,      // typedef 类型
-    scc_ast_type_t_END,    // 类型结束
+    scc_ast_qual_type_t_END,   // 类型结束
 
     // 其他
     scc_ast_translation_unit_t_BEGIN,
@@ -85,6 +85,7 @@ typedef struct scc_ast_node {
     scc_ast_node_kind_t type;
     scc_pos_t loc;
 } scc_ast_node_t;
+typedef SCC_VEC(scc_ast_node_t *) scc_ast_node_vec_t;
 
 #define SCC_AST_CAST_TO(kind, expr)                                            \
     ((kind *)(Assert(((scc_ast_node_t *)expr)->type > kind##_BEGIN &&          \
@@ -126,6 +127,8 @@ typedef enum {
     SCC_AST_BUILTIN_TYPE_COMPLEX_FLOAT,
     SCC_AST_BUILTIN_TYPE_COMPLEX_DOUBLE,
     SCC_AST_BUILTIN_TYPE_COMPLEX_LONG_DOUBLE,
+
+    SCC_AST_BUILTIN_TYPE_COUNT,
 } scc_ast_builtin_type_t;
 
 /**
@@ -147,13 +150,14 @@ typedef struct {
     cbool is_inline;
 } scc_ast_decl_specifier_t;
 
-// 前向声明
+typedef union scc_ast_canonical_type scc_ast_canon_type_t;
-typedef struct scc_ast_type scc_ast_type_t;
+typedef struct scc_ast_qual_type scc_ast_qual_type_t;
 typedef struct scc_ast_expr scc_ast_expr_t;
 typedef struct scc_ast_stmt scc_ast_stmt_t;
 typedef struct scc_ast_decl scc_ast_decl_t;
 
-typedef SCC_VEC(scc_ast_type_t *) scc_ast_type_vec_t;
+typedef SCC_VEC(scc_ast_canon_type_t *) scc_ast_canon_type_vec_t;
+typedef SCC_VEC(scc_ast_qual_type_t *) scc_ast_qual_type_vec_t;
 typedef SCC_VEC(scc_ast_expr_t *) scc_ast_expr_vec_t;
 typedef SCC_VEC(scc_ast_stmt_t *) scc_ast_stmt_vec_t;
 typedef SCC_VEC(scc_ast_decl_t *) scc_ast_decl_vec_t;
@@ -161,25 +165,20 @@ typedef SCC_VEC(scc_ast_decl_t *) scc_ast_decl_vec_t;
 // 通过指针实现泛型 only stmt or decl
 typedef SCC_VEC(scc_ast_node_t *) scc_ast_block_item_vec_t;
 
-/**
+// 规范类型 Canonical Type
- * @brief 类型表示
+union scc_ast_canonical_type {
- */
-struct scc_ast_type {
-    scc_ast_node_t base;
-    scc_ast_decl_specifier_t quals;
-    union {
     struct {
         scc_ast_builtin_type_t type;
     } builtin;
     struct {
-            scc_ast_type_t *pointee;
+        scc_ast_qual_type_t *pointee;
     } pointer;
     struct {
-            scc_ast_type_t *element;
+        scc_ast_qual_type_t *element;
         scc_ast_expr_t *size; // 可为 nullptr <=> 不定长数组
     } array;
     struct {
-            scc_ast_type_t *return_type;
+        scc_ast_qual_type_t *return_type;
         scc_ast_decl_vec_t params; // va_list <=> ...
     } function;
     struct {
@@ -192,8 +191,26 @@ struct scc_ast_type {
         scc_ast_decl_t *decl;
     } typedef_type;
 };
+
+/**
+ * @brief 类型表示
+ */
+struct scc_ast_qual_type {
+    scc_ast_node_t base;
+    scc_ast_decl_specifier_t quals;
+    scc_ast_canon_type_t *type;
 };
 
+static inline const scc_ast_canon_type_t *
+scc_ast_canon_type(const scc_ast_qual_type_t *type) {
+    return type->type;
+}
+
+static inline scc_ast_canon_type_t *
+scc_ast_mut_canon_type(scc_ast_qual_type_t *type) {
+    return type->type;
+}
+
 /**
  * @brief AST 操作符枚举
  * 这个枚举定义了所有在AST中使用的操作符，与词法token分离
@@ -302,12 +319,12 @@ struct scc_ast_expr {
         } member;
         // cast 类型转换
         struct {
-            scc_ast_type_t *type;
+            scc_ast_qual_type_t *type;
             scc_ast_expr_t *expr;
         } cast;
         // sizeof / _Alignof / ...
         union {
-            scc_ast_type_t *type;
+            scc_ast_qual_type_t *type;
             scc_ast_expr_t *expr;
         } attr_of;
         // 复合字面量
@@ -329,7 +346,7 @@ struct scc_ast_expr {
             scc_ast_decl_t *_target; ///< fill by sema
         } identifier;
         struct {
-            scc_ast_type_t *type;
+            scc_ast_qual_type_t *type;
         } lvalue;
         // 内置表达式
         struct {
@@ -418,17 +435,17 @@ struct scc_ast_decl {
         } list;
         // 变量声明
         struct {
-            scc_ast_type_t *type;
+            scc_ast_qual_type_t *type;
             scc_ast_expr_t *init; // 可为 nullptr
         } var;
         // 函数声明
         struct {
-            scc_ast_type_t *type; // 函数类型
+            scc_ast_qual_type_t *type; // 函数类型
             scc_ast_stmt_t *body;      // 可为 nullptr 表示只有声明
         } func;
         // 参数声明
         struct {
-            scc_ast_type_t *type;
+            scc_ast_qual_type_t *type;
             int param_idx;
         } param;
         // 结构体/联合/枚举声明
@@ -438,7 +455,7 @@ struct scc_ast_decl {
         } record;
         struct {
             /// @brief 被 typedef 的类型
-            scc_ast_type_t *type;
+            scc_ast_qual_type_t *type;
         } typedef_decl;
     };
 };

libs/ast/include/scc_ast_utils.h

@@ -0,0 +1,505 @@
+#ifndef __SCC_AST_UTILS_H__
+#define __SCC_AST_UTILS_H__
+
+#include "scc_ast_def.h"
+
+// decls can be nullptr but maybe warning
+static inline void
+scc_ast_translation_unit_init(scc_ast_translation_unit_t *translation_unit,
+                              scc_ast_decl_vec_t *decls, scc_pos_t loc) {
+    Assert(translation_unit != nullptr);
+    translation_unit->base.type = SCC_AST_TRANSLATION_UNIT;
+    translation_unit->base.loc = loc;
+    if (decls == nullptr) {
+        scc_vec_init(translation_unit->declarations);
+    } else {
+        translation_unit->declarations = *decls;
+        scc_vec_init(*decls);
+    }
+}
+
+static inline void scc_ast_decl_list_init(scc_ast_decl_t *decl,
+                                          scc_ast_decl_vec_t *list_move,
+                                          scc_pos_t loc) {
+    Assert(decl != nullptr && list_move != nullptr);
+    decl->base.loc = loc;
+    decl->base.type = SCC_AST_DECL_LIST;
+    decl->name = nullptr;
+    decl->list.vars = *list_move;
+    scc_vec_init(*list_move);
+}
+
+// name and var_init can be nullptr
+static inline void scc_ast_decl_unsafe_val_init(scc_ast_decl_t *decl,
+                                                scc_ast_qual_type_t *type,
+                                                const char *name,
+                                                scc_ast_expr_t *var_init,
+                                                scc_pos_t loc) {
+    Assert(decl != nullptr && type != nullptr);
+    decl->base.loc = loc;
+    decl->base.type = SCC_AST_DECL_VAR;
+    decl->name = name;
+    decl->var.type = type;
+    decl->var.init = var_init;
+}
+
+// var_init can be nullptr
+static inline void scc_ast_decl_val_init(scc_ast_decl_t *decl,
+                                         scc_ast_qual_type_t *type,
+                                         const char *name,
+                                         scc_ast_expr_t *var_init,
+                                         scc_pos_t loc) {
+    Assert(decl != nullptr && name != nullptr && type != nullptr);
+    decl->base.loc = loc;
+    decl->base.type = SCC_AST_DECL_VAR;
+    decl->name = name;
+    decl->var.type = type;
+    decl->var.init = var_init;
+}
+
+// body can be nullptr
+static inline void scc_ast_decl_func_init(scc_ast_decl_t *decl,
+                                          scc_ast_qual_type_t *type,
+                                          const char *name,
+                                          scc_ast_stmt_t *body, scc_pos_t loc) {
+    Assert(decl != nullptr && name != nullptr && type != nullptr);
+    decl->base.loc = loc;
+    decl->base.type = SCC_AST_DECL_FUNC;
+    decl->name = name;
+    decl->func.type = type;
+    Assert(type->base.type == SCC_AST_TYPE_FUNCTION);
+    decl->func.body = body;
+}
+
+// name can be nullptr
+static inline void scc_ast_decl_param_init(scc_ast_decl_t *decl,
+                                           scc_ast_qual_type_t *type,
+                                           const char *name, int idx,
+                                           scc_pos_t loc) {
+    Assert(decl != nullptr && type != nullptr);
+    decl->base.loc = loc;
+    decl->base.type = SCC_AST_DECL_PARAM;
+    decl->name = name;
+    decl->param.type = type;
+    decl->param.param_idx = idx;
+}
+
+static inline void _scc_ast_decl_record_init(scc_ast_decl_t *decl,
+                                             scc_ast_node_kind_t type,
+                                             const char *name,
+                                             scc_ast_decl_vec_t *fields_move,
+                                             scc_pos_t loc) {
+    Assert(decl != nullptr);
+    if (name == nullptr) {
+        name = "<anonymous>";
+    }
+    decl->base.loc = loc;
+    decl->base.type = type;
+    decl->name = name;
+    if (fields_move == nullptr) {
+        scc_vec_init(decl->record.fields);
+    } else {
+        decl->record.fields = *fields_move;
+        scc_vec_init(*fields_move);
+    }
+}
+
+// name and fields can be nullptr
+static inline void scc_ast_decl_struct_init(scc_ast_decl_t *decl,
+                                            const char *name,
+                                            scc_ast_decl_vec_t *fields_move,
+                                            scc_pos_t loc) {
+    _scc_ast_decl_record_init(decl, SCC_AST_DECL_STRUCT, name, fields_move,
+                              loc);
+}
+
+// name and fields can be nullptr
+static inline void scc_ast_decl_union_init(scc_ast_decl_t *decl,
+                                           const char *name,
+                                           scc_ast_decl_vec_t *fields_move,
+                                           scc_pos_t loc) {
+    _scc_ast_decl_record_init(decl, SCC_AST_DECL_UNION, name, fields_move, loc);
+}
+
+// name and fields can be nullptr
+static inline void scc_ast_decl_enum_init(scc_ast_decl_t *decl,
+                                          const char *name,
+                                          scc_ast_decl_vec_t *fields_move,
+                                          scc_pos_t loc) {
+    _scc_ast_decl_record_init(decl, SCC_AST_DECL_ENUM, name, fields_move, loc);
+}
+
+static inline void scc_ast_decl_typedef_init(scc_ast_decl_t *decl,
+                                             const char *name,
+                                             scc_ast_qual_type_t *type,
+                                             scc_pos_t loc) {
+    Assert(decl != nullptr && name != nullptr && type != nullptr);
+    decl->base.loc = loc;
+    decl->base.type = SCC_AST_DECL_TYPEDEF;
+    decl->name = name;
+    decl->typedef_decl.type = type;
+}
+
+// items can be nullptr
+static inline void scc_ast_stmt_compound_init(
+    scc_ast_stmt_t *stmt, scc_ast_block_item_vec_t *items_move, scc_pos_t loc) {
+    Assert(stmt != nullptr);
+    stmt->base.loc = loc;
+    stmt->base.type = SCC_AST_STMT_COMPOUND;
+    if (items_move == nullptr) {
+        scc_vec_init(stmt->compound.block_items);
+    } else {
+        stmt->compound.block_items = *items_move;
+        scc_vec_init(*items_move);
+    }
+}
+
+// expr can be nullptr
+static inline void scc_ast_stmt_expr_init(scc_ast_stmt_t *stmt,
+                                          scc_ast_expr_t *expr, scc_pos_t loc) {
+    Assert(stmt != nullptr);
+    stmt->base.loc = loc;
+    stmt->base.type = SCC_AST_STMT_EXPR;
+    stmt->expr.expr = expr;
+}
+
+// opt_else can be nullptr
+static inline void scc_ast_stmt_if_init(scc_ast_stmt_t *stmt,
+                                        scc_ast_expr_t *cond,
+                                        scc_ast_stmt_t *then,
+                                        scc_ast_stmt_t *opt_else,
+                                        scc_pos_t loc) {
+    Assert(stmt != nullptr && cond != nullptr && then != nullptr);
+    stmt->base.loc = loc;
+    stmt->base.type = SCC_AST_STMT_IF;
+    stmt->if_stmt.cond = cond;
+    stmt->if_stmt.then_stmt = then;
+    stmt->if_stmt.opt_else_stmt = opt_else;
+}
+
+static inline void scc_ast_stmt_while_init(scc_ast_stmt_t *stmt,
+                                           scc_ast_expr_t *cond,
+                                           scc_ast_stmt_t *body,
+                                           scc_pos_t loc) {
+    Assert(stmt != nullptr && cond != nullptr && body != nullptr);
+    stmt->base.loc = loc;
+    stmt->base.type = SCC_AST_STMT_WHILE;
+    stmt->while_stmt.cond = cond;
+    stmt->while_stmt.body = body;
+}
+
+static inline void scc_ast_stmt_do_while_init(scc_ast_stmt_t *stmt,
+                                              scc_ast_expr_t *cond,
+                                              scc_ast_stmt_t *body,
+                                              scc_pos_t loc) {
+    Assert(stmt != nullptr && cond != nullptr && body != nullptr);
+    stmt->base.loc = loc;
+    stmt->base.type = SCC_AST_STMT_DO_WHILE;
+    stmt->while_stmt.cond = cond;
+    stmt->while_stmt.body = body;
+}
+
+// FIXME
+static inline void scc_ast_stmt_for_init(scc_ast_stmt_t *stmt,
+                                         scc_ast_node_t *init,
+                                         scc_ast_expr_t *cond,
+                                         scc_ast_expr_t *incr,
+                                         scc_ast_stmt_t *body, scc_pos_t loc) {
+    Assert(stmt != nullptr && body != nullptr);
+    stmt->base.loc = loc;
+    stmt->base.type = SCC_AST_STMT_FOR;
+    stmt->for_stmt.init = init;
+    stmt->for_stmt.cond = cond;
+    stmt->for_stmt.incr = incr;
+    stmt->for_stmt.body = body;
+}
+
+static inline void scc_ast_stmt_switch_init(scc_ast_stmt_t *stmt,
+                                            scc_ast_expr_t *cond,
+                                            scc_ast_stmt_t *body,
+                                            scc_pos_t loc) {
+    Assert(stmt != nullptr && cond != nullptr && body != nullptr);
+    stmt->base.loc = loc;
+    stmt->base.type = SCC_AST_STMT_SWITCH;
+    stmt->switch_stmt.cond = cond;
+    stmt->switch_stmt.body = body;
+}
+
+static inline void scc_ast_stmt_case_init(scc_ast_stmt_t *stmt,
+                                          scc_ast_expr_t *cond,
+                                          scc_ast_stmt_t *body, scc_pos_t loc) {
+    Assert(stmt != nullptr && cond != nullptr && body != nullptr);
+    stmt->base.loc = loc;
+    stmt->base.type = SCC_AST_STMT_CASE;
+    stmt->case_stmt.expr = cond;
+    stmt->case_stmt.stmt = body;
+}
+
+static inline void scc_ast_stmt_default_init(scc_ast_stmt_t *stmt,
+                                             scc_ast_stmt_t *body,
+                                             scc_pos_t loc) {
+    Assert(stmt != nullptr && body != nullptr);
+    stmt->base.loc = loc;
+    stmt->base.type = SCC_AST_STMT_DEFAULT;
+    stmt->default_stmt.stmt = body;
+}
+
+static inline void scc_ast_stmt_break_init(scc_ast_stmt_t *stmt,
+                                           scc_pos_t loc) {
+    Assert(stmt != nullptr);
+    stmt->base.loc = loc;
+    stmt->base.type = SCC_AST_STMT_BREAK;
+    stmt->jump._target = nullptr;
+}
+
+static inline void scc_ast_stmt_continue_init(scc_ast_stmt_t *stmt,
+                                              scc_pos_t loc) {
+    Assert(stmt != nullptr);
+    stmt->base.loc = loc;
+    stmt->base.type = SCC_AST_STMT_CONTINUE;
+    stmt->jump._target = nullptr;
+}
+
+// expr can be nullptr
+static inline void scc_ast_stmt_return_init(scc_ast_stmt_t *stmt,
+                                            scc_ast_expr_t *expr,
+                                            scc_pos_t loc) {
+    Assert(stmt != nullptr);
+    stmt->base.loc = loc;
+    stmt->base.type = SCC_AST_STMT_RETURN;
+    stmt->return_stmt.expr = expr;
+}
+
+static inline void scc_ast_stmt_goto_init(scc_ast_stmt_t *stmt,
+                                          const char *label, scc_pos_t loc) {
+    Assert(stmt != nullptr && label != nullptr);
+    stmt->base.loc = loc;
+    stmt->base.type = SCC_AST_STMT_GOTO;
+    stmt->goto_stmt.label = label;
+    stmt->goto_stmt._target = nullptr;
+}
+
+static inline void scc_ast_stmt_label_init(scc_ast_stmt_t *stmt,
+                                           const char *label,
+                                           scc_ast_stmt_t *body,
+                                           scc_pos_t loc) {
+    Assert(stmt != nullptr);
+    stmt->base.loc = loc;
+    stmt->base.type = SCC_AST_STMT_LABEL;
+    stmt->label_stmt.label = label;
+    stmt->label_stmt.stmt = body;
+}
+
+static inline void scc_ast_expr_binary_init(scc_ast_expr_t *expr,
+                                            scc_ast_expr_op_t op,
+                                            scc_ast_expr_t *lhs,
+                                            scc_ast_expr_t *rhs,
+                                            scc_pos_t loc) {
+    Assert(expr != nullptr && lhs != nullptr && rhs != nullptr);
+    expr->base.loc = loc;
+    expr->base.type = SCC_AST_EXPR_BINARY;
+    expr->binary.op = op;
+    expr->binary.lhs = lhs;
+    expr->binary.rhs = rhs;
+}
+
+static inline void scc_ast_expr_unary_init(scc_ast_expr_t *expr,
+                                           scc_ast_expr_op_t op,
+                                           scc_ast_expr_t *operand,
+                                           scc_pos_t loc) {
+    Assert(expr != nullptr && operand != nullptr);
+    expr->base.loc = loc;
+    expr->base.type = SCC_AST_EXPR_UNARY;
+    expr->unary.op = op;
+    expr->unary.operand = operand;
+}
+
+static inline void scc_ast_expr_cond_init(scc_ast_expr_t *expr,
+                                          scc_ast_expr_t *cond,
+                                          scc_ast_expr_t *then_expr,
+                                          scc_ast_expr_t *else_expr,
+                                          scc_pos_t loc) {
+    Assert(expr != nullptr && cond != nullptr && then_expr != nullptr &&
+           else_expr != nullptr);
+    expr->base.loc = loc;
+    expr->base.type = SCC_AST_EXPR_COND;
+    expr->cond.cond = cond;
+    expr->cond.then_expr = then_expr;
+    expr->cond.else_expr = else_expr;
+}
+
+// args can be nullptr
+static inline void scc_ast_expr_call_init(scc_ast_expr_t *expr,
+                                          scc_ast_expr_t *callee,
+                                          scc_ast_expr_vec_t *args,
+                                          scc_pos_t loc) {
+    Assert(expr != nullptr && callee != nullptr);
+    expr->base.loc = loc;
+    expr->base.type = SCC_AST_EXPR_CALL;
+    expr->call.callee = callee;
+    if (args == nullptr) {
+        scc_vec_init(expr->call.args);
+    } else {
+        expr->call.args = *args;
+    }
+}
+
+// SCC_AST_EXPR_ARRAY_SUBSCRIPT,  // 数组下标
+static inline void scc_ast_expr_array_subscript_init(scc_ast_expr_t *expr,
+                                                     scc_ast_expr_t *array,
+                                                     scc_ast_expr_t *index,
+                                                     scc_pos_t loc) {
+    Assert(expr != nullptr && array != nullptr && index != nullptr);
+    expr->base.loc = loc;
+    expr->base.type = SCC_AST_EXPR_ARRAY_SUBSCRIPT;
+    expr->subscript.array = array;
+    expr->subscript.index = index;
+}
+
+static inline void _scc_ast_expr_member_init(scc_ast_expr_t *expr,
+                                             scc_ast_node_kind_t type,
+                                             scc_ast_expr_t *object,
+                                             const char *member,
+                                             scc_pos_t loc) {
+    Assert(expr != nullptr && object != nullptr && member != nullptr);
+    expr->base.loc = loc;
+    expr->base.type = type;
+    expr->member.base = object;
+    expr->member.name = member;
+    expr->member._target_idx = 0;
+}
+
+static inline void scc_ast_expr_member_init(scc_ast_expr_t *expr,
+                                            scc_ast_expr_t *object,
+                                            const char *member, scc_pos_t loc) {
+    _scc_ast_expr_member_init(expr, SCC_AST_EXPR_MEMBER, object, member, loc);
+}
+
+static inline void scc_ast_expr_ptr_member_init(scc_ast_expr_t *expr,
+                                                scc_ast_expr_t *object,
+                                                const char *member,
+                                                scc_pos_t loc) {
+    _scc_ast_expr_member_init(expr, SCC_AST_EXPR_PTR_MEMBER, object, member,
+                              loc);
+}
+
+static inline void scc_ast_expr_cast_init(scc_ast_expr_t *expr,
+                                          scc_ast_qual_type_t *type,
+                                          scc_ast_expr_t *operand,
+                                          scc_pos_t loc) {
+    Assert(expr != nullptr && type != nullptr && operand != nullptr);
+    expr->base.loc = loc;
+    expr->base.type = SCC_AST_EXPR_CAST;
+    expr->cast.type = type;
+    expr->cast.expr = operand;
+}
+
+// type and target_expr can be nullptr but it only one of them can be nullptr
+static inline void scc_ast_expr_sizeof_init(scc_ast_expr_t *expr,
+                                            scc_ast_qual_type_t *type,
+                                            scc_ast_expr_t *target_expr,
+                                            scc_pos_t loc) {
+    Assert(expr != nullptr);
+    expr->base.loc = loc;
+    expr->base.type = SCC_AST_EXPR_SIZE_OF;
+    expr->attr_of.type = type;
+    expr->attr_of.expr = target_expr;
+}
+
+// type and target_expr can be nullptr but it only one of them can be nullptr
+static inline void scc_ast_expr_alignof_init(scc_ast_expr_t *expr,
+                                             scc_ast_qual_type_t *type,
+                                             scc_ast_expr_t *target_expr,
+                                             scc_pos_t loc) {
+    Assert(expr != nullptr);
+    expr->base.loc = loc;
+    expr->base.type =
+        SCC_AST_EXPR_SIZE_OF; // 注意：这里使用了 SIZE_OF，可能需要改为 ALIGN_OF
+    expr->attr_of.type = type;
+    expr->attr_of.expr = target_expr;
+}
+
+// lhs_exprs and rhs_exprs can be nullptr
+static inline void scc_ast_expr_compound_init(scc_ast_expr_t *expr,
+                                              scc_ast_expr_t *base,
+                                              scc_ast_expr_vec_t *lhs_exprs,
+                                              scc_ast_expr_vec_t *rhs_exprs,
+                                              scc_pos_t loc) {
+    Assert(expr != nullptr && base != nullptr);
+    expr->base.loc = loc;
+    expr->base.type = SCC_AST_EXPR_COMPOUND;
+    expr->compound.base = base;
+
+    if (lhs_exprs == nullptr) {
+        scc_vec_init(expr->compound.lhs_exprs);
+    } else {
+        expr->compound.lhs_exprs = *lhs_exprs;
+        scc_vec_init(*lhs_exprs);
+    }
+
+    if (rhs_exprs == nullptr) {
+        scc_vec_init(expr->compound.rhs_exprs);
+    } else {
+        expr->compound.rhs_exprs = *rhs_exprs;
+        scc_vec_init(*rhs_exprs);
+    }
+}
+
+static inline void scc_ast_expr_literal_init(scc_ast_expr_t *expr,
+                                             scc_ast_node_kind_t type,
+                                             const char *value, cbool owned,
+                                             scc_pos_t loc) {
+    Assert(expr != nullptr && value != nullptr);
+    expr->base.loc = loc;
+    expr->base.type = type;
+    expr->literal.lexme = value;
+    expr->literal.owned = owned;
+}
+
+static inline void scc_ast_expr_literal_int_init(scc_ast_expr_t *expr,
+                                                 const char *value, cbool owned,
+                                                 scc_pos_t loc) {
+    scc_ast_expr_literal_init(expr, SCC_AST_EXPR_INT_LITERAL, value, owned,
+                              loc);
+}
+
+static inline void scc_ast_expr_literal_float_init(scc_ast_expr_t *expr,
+                                                   const char *value,
+                                                   cbool owned, scc_pos_t loc) {
+    scc_ast_expr_literal_init(expr, SCC_AST_EXPR_FLOAT_LITERAL, value, owned,
+                              loc);
+}
+static inline void scc_ast_expr_literal_char_init(scc_ast_expr_t *expr,
+                                                  const char *value,
+                                                  cbool owned, scc_pos_t loc) {
+    scc_ast_expr_literal_init(expr, SCC_AST_EXPR_CHAR_LITERAL, value, owned,
+                              loc);
+}
+static inline void scc_ast_expr_literal_string_init(scc_ast_expr_t *expr,
+                                                    const char *value,
+                                                    cbool owned,
+                                                    scc_pos_t loc) {
+    scc_ast_expr_literal_init(expr, SCC_AST_EXPR_STRING_LITERAL, value, owned,
+                              loc);
+}
+
+static inline void scc_ast_expr_identifier_init(scc_ast_expr_t *expr,
+                                                const char *name,
+                                                scc_pos_t loc) {
+    Assert(expr != nullptr && name != nullptr);
+    expr->base.loc = loc;
+    expr->base.type = SCC_AST_EXPR_IDENTIFIER;
+    expr->identifier.name = name;
+    expr->identifier._target = nullptr;
+}
+
+static inline void scc_ast_expr_lvalue_init(scc_ast_expr_t *expr,
+                                            scc_ast_qual_type_t *type,
+                                            scc_pos_t loc) {
+    Assert(expr != nullptr && type != nullptr);
+    expr->base.loc = loc;
+    expr->base.type = SCC_AST_EXPR_LVALUE;
+    expr->lvalue.type = type;
+}
+
+#endif /* __SCC_AST_UTILS_H__ */

libs/ast/src/ast_dump.c

@@ -53,7 +53,7 @@ static const char *node_type_names[] = {
     [SCC_AST_EXPR_STRING_LITERAL] = "StringLiteralExpr",
     [SCC_AST_EXPR_IDENTIFIER] = "IdentifierExpr",
     [scc_ast_expr_t_END] = "ERROR",
-    [scc_ast_type_t_BEGIN] = "ERROR",
+    [scc_ast_qual_type_t_BEGIN] = "ERROR",
     [SCC_AST_TYPE_BUILTIN] = "BuiltinType",
     [SCC_AST_TYPE_POINTER] = "PointerType",
     [SCC_AST_TYPE_ARRAY] = "ArrayType",
@@ -62,7 +62,7 @@ static const char *node_type_names[] = {
     [SCC_AST_TYPE_UNION] = "UnionType",
     [SCC_AST_TYPE_ENUM] = "EnumType",
     [SCC_AST_TYPE_TYPEDEF] = "TypedefType",
-    [scc_ast_type_t_END] = "ERROR",
+    [scc_ast_qual_type_t_END] = "ERROR",
     [scc_ast_translation_unit_t_BEGIN] = "ERROR",
     [SCC_AST_TRANSLATION_UNIT] = "TranslationUnit",
     [scc_ast_translation_unit_t_END] = "ERROR",
@@ -200,8 +200,8 @@ static inline void dump_child_node(scc_tree_dump_t *td, scc_ast_node_t *child,
     scc_tree_dump_pop(td);
 }
 
-static inline void dump_quals(scc_ast_decl_specifier_t quals,
+static inline void dump_quals(scc_tree_dump_t *td,
-                              scc_tree_dump_t *td) {
+                              scc_ast_decl_specifier_t quals) {
     if (quals.is_atomic)
         scc_tree_dump_value(td, " atomic");
     if (quals.is_restrict)
@@ -216,18 +216,20 @@ static inline void dump_quals(scc_ast_decl_specifier_t quals,
         scc_tree_dump_value(td, " extern");
 }
 
-static void dump_type_impl(scc_ast_type_t *type, scc_tree_dump_t *td) {
+static void dump_type_impl(scc_tree_dump_t *td,
+                           const scc_ast_qual_type_t *type) {
     if (!type)
         return;
 
     scc_tree_dump_begin_line(td);
     scc_tree_dump_node(td, "%s", get_node_type_str(type->base.type));
-    dump_quals(type->quals, td);
+    dump_quals(td, type->quals);
 
     switch (type->base.type) {
     case SCC_AST_TYPE_BUILTIN:
-        scc_tree_dump_value(td, " '%s'",
+        scc_tree_dump_value(
-                            get_builtin_type_str(type->builtin.type));
+            td, " '%s'",
+            get_builtin_type_str(scc_ast_canon_type(type)->builtin.type));
         break;
     case SCC_AST_TYPE_POINTER:
         scc_tree_dump_value(td, " pointer");
@@ -239,25 +241,29 @@ static void dump_type_impl(scc_ast_type_t *type, scc_tree_dump_t *td) {
         scc_tree_dump_value(td, " function");
         break;
     case SCC_AST_TYPE_STRUCT:
-        if (type->record.name)
+        if (scc_ast_canon_type(type)->record.name)
-            scc_tree_dump_value(td, " 'struct %s'", type->record.name);
+            scc_tree_dump_value(td, " 'struct %s'",
+                                scc_ast_canon_type(type)->record.name);
         else
             scc_tree_dump_value(td, " <anonymous struct>");
         break;
     case SCC_AST_TYPE_UNION:
-        if (type->record.name)
+        if (scc_ast_canon_type(type)->record.name)
-            scc_tree_dump_value(td, " 'union %s'", type->record.name);
+            scc_tree_dump_value(td, " 'union %s'",
+                                scc_ast_canon_type(type)->record.name);
         else
             scc_tree_dump_value(td, " <anonymous union>");
         break;
     case SCC_AST_TYPE_ENUM:
-        if (type->record.name)
+        if (scc_ast_canon_type(type)->record.name)
-            scc_tree_dump_value(td, " 'enum %s'", type->record.name);
+            scc_tree_dump_value(td, " 'enum %s'",
+                                scc_ast_canon_type(type)->record.name);
         else
             scc_tree_dump_value(td, " anonymous enum");
         break;
     case SCC_AST_TYPE_TYPEDEF:
-        scc_tree_dump_value(td, " '%s'", type->typedef_type.name);
+        scc_tree_dump_value(td, " '%s'",
+                            scc_ast_canon_type(type)->typedef_type.name);
         break;
     default:
         break;
@@ -265,26 +271,35 @@ static void dump_type_impl(scc_ast_type_t *type, scc_tree_dump_t *td) {
 
     switch (type->base.type) {
     case SCC_AST_TYPE_POINTER:
-        dump_child_node(td, (scc_ast_node_t *)type->pointer.pointee, true);
+        dump_child_node(
+            td, (scc_ast_node_t *)scc_ast_canon_type(type)->pointer.pointee,
+            true);
         break;
     case SCC_AST_TYPE_ARRAY:
-        dump_child_node(td, (scc_ast_node_t *)type->array.element,
+        dump_child_node(
-                        type->array.size == nullptr);
+            td, (scc_ast_node_t *)scc_ast_canon_type(type)->array.element,
-        if (type->array.size)
+            scc_ast_canon_type(type)->array.size == nullptr);
-            dump_child_node(td, (scc_ast_node_t *)type->array.size, true);
+        if (scc_ast_canon_type(type)->array.size)
+            dump_child_node(
+                td, (scc_ast_node_t *)scc_ast_canon_type(type)->array.size,
+                true);
         break;
     case SCC_AST_TYPE_FUNCTION:
         scc_tree_dump_push(td, false);
         scc_tree_dump_begin_line(td);
         scc_tree_dump_node(td, "%s", "ReturnType");
-        dump_child_node(td, (scc_ast_node_t *)type->function.return_type, true);
+        dump_child_node(
+            td,
+            (scc_ast_node_t *)scc_ast_canon_type(type)->function.return_type,
+            true);
         scc_tree_dump_pop(td);
 
         scc_tree_dump_push(td, true);
-        if (scc_vec_size(type->function.params) != 0) {
+        if (scc_vec_size(scc_ast_canon_type(type)->function.params) != 0) {
-            scc_vec_foreach(type->function.params, i) {
+            scc_vec_foreach(scc_ast_canon_type(type)->function.params, i) {
-                scc_ast_decl_t *param = scc_vec_at(type->function.params, i);
+                scc_ast_decl_t *param =
-                dump_type_impl(param->param.type, td);
+                    scc_vec_at(scc_ast_canon_type(type)->function.params, i);
+                dump_type_impl(td, param->param.type);
             }
         } else {
             scc_tree_dump_begin_line(td);
@@ -297,7 +312,7 @@ static void dump_type_impl(scc_ast_type_t *type, scc_tree_dump_t *td) {
     }
 }
 
-static void dump_expr_impl(scc_ast_expr_t *expr, scc_tree_dump_t *td) {
+static void dump_expr_impl(scc_tree_dump_t *td, const scc_ast_expr_t *expr) {
     if (!expr)
         return;
 
@@ -401,7 +416,7 @@ static void dump_expr_impl(scc_ast_expr_t *expr, scc_tree_dump_t *td) {
     }
 }
 
-static void dump_stmt_impl(scc_ast_stmt_t *stmt, scc_tree_dump_t *td) {
+static void dump_stmt_impl(scc_tree_dump_t *td, const scc_ast_stmt_t *stmt) {
     if (!stmt)
         return;
 
@@ -479,7 +494,7 @@ static void dump_stmt_impl(scc_ast_stmt_t *stmt, scc_tree_dump_t *td) {
     }
 }
 
-static void dump_decl_impl(scc_ast_decl_t *decl, scc_tree_dump_t *td) {
+static void dump_decl_impl(scc_tree_dump_t *td, const scc_ast_decl_t *decl) {
     if (!decl)
         return;
 
@@ -535,8 +550,8 @@ static void dump_decl_impl(scc_ast_decl_t *decl, scc_tree_dump_t *td) {
     }
 }
 
-static void dump_unit_impl(scc_ast_translation_unit_t *unit,
+static void dump_unit_impl(scc_tree_dump_t *td,
-                           scc_tree_dump_t *td) {
+                           const scc_ast_translation_unit_t *unit) {
     if (!unit)
         return;
 
@@ -552,13 +567,13 @@ void scc_ast_dump_node(scc_tree_dump_t *td, const scc_ast_node_t *node) {
     if (!node)
         return;
     if (SCC_AST_IS_A(scc_ast_expr_t, node))
-        dump_expr_impl(SCC_AST_CAST_TO(scc_ast_expr_t, node), td);
+        dump_expr_impl(td, SCC_AST_CAST_TO(scc_ast_expr_t, node));
     else if (SCC_AST_IS_A(scc_ast_stmt_t, node))
-        dump_stmt_impl(SCC_AST_CAST_TO(scc_ast_stmt_t, node), td);
+        dump_stmt_impl(td, SCC_AST_CAST_TO(scc_ast_stmt_t, node));
     else if (SCC_AST_IS_A(scc_ast_decl_t, node))
-        dump_decl_impl(SCC_AST_CAST_TO(scc_ast_decl_t, node), td);
+        dump_decl_impl(td, SCC_AST_CAST_TO(scc_ast_decl_t, node));
-    else if (SCC_AST_IS_A(scc_ast_type_t, node))
+    else if (SCC_AST_IS_A(scc_ast_qual_type_t, node))
-        dump_type_impl(SCC_AST_CAST_TO(scc_ast_type_t, node), td);
+        dump_type_impl(td, SCC_AST_CAST_TO(scc_ast_qual_type_t, node));
     else if (SCC_AST_IS_A(scc_ast_translation_unit_t, node))
-        dump_unit_impl(SCC_AST_CAST_TO(scc_ast_translation_unit_t, node), td);
+        dump_unit_impl(td, SCC_AST_CAST_TO(scc_ast_translation_unit_t, node));
 }

libs/ast/src/scc_ast.c

@@ -0,0 +1,42 @@
+#include <scc_ast.h>
+
+static scc_ast_canon_type_t *alloc_canonical_type(scc_ast_ctx_t *ctx) {
+    scc_ast_canon_type_t *type = scc_malloc(sizeof(scc_ast_canon_type_t));
+    if (type == nullptr) {
+        Panic("alloc_canonical_type: malloc failed");
+    }
+    scc_vec_push(ctx->canonical_type_pool, type);
+    return type;
+}
+
+void scc_ast_ctx_init(scc_ast_ctx_t *ctx) {
+    scc_vec_init(ctx->canonical_type_pool);
+    scc_vec_init(ctx->all_nodes);
+
+    // 创建全部内置类型
+    for (int i = 0; i < SCC_AST_BUILTIN_TYPE_COUNT; i += 1) {
+        scc_ast_canon_type_t *t = alloc_canonical_type(ctx);
+        t->builtin.type = (scc_ast_builtin_type_t)i; // 直接按顺序对应
+        ctx->builtin_types[i] = t;
+    }
+}
+
+void scc_ast_ctx_drop(scc_ast_ctx_t *ctx) {
+    // 释放所有规范类型
+    scc_vec_foreach(ctx->canonical_type_pool, i) {
+        scc_free(ctx->canonical_type_pool.data[i]);
+    }
+    scc_vec_foreach(ctx->all_nodes, i) { scc_free(ctx->all_nodes.data[i]); }
+    scc_vec_free(ctx->canonical_type_pool);
+}
+
+scc_ast_canon_type_t *
+scc_ast_ctx_get_builtin_type(scc_ast_ctx_t *ctx, scc_ast_builtin_type_t kind) {
+    assert(kind < SCC_AST_BUILTIN_TYPE_COUNT &&
+           kind > SCC_AST_BUILTIN_TYPE_UNKNOWN);
+    return ctx->builtin_types[kind];
+}
+
+scc_ast_canon_type_t *scc_ast_ctx_alloc_type(scc_ast_ctx_t *ctx) {
+    return alloc_canonical_type(ctx);
+}

libs/ast2ir/include/scc_ast2ir.h

@@ -18,7 +18,7 @@ void scc_ast2ir_ctx_init(scc_ast2ir_ctx_t *ctx, const scc_abi_type_calc_t *abi,
                          scc_hir_cprog_t *cprog);
 void scc_ast2ir_ctx_drop(scc_ast2ir_ctx_t *ctx);
 
-void scc_ast2ir_translation_unit(scc_ast2ir_ctx_t *ctx,
+void scc_ast2ir_run(scc_ast2ir_ctx_t *ctx,
                     const scc_ast_translation_unit_t *tu);
 void scc_ast2ir_decl(scc_ast2ir_ctx_t *ctx, const scc_ast_decl_t *decl,
                      cbool is_global);
@@ -27,6 +27,6 @@ scc_hir_value_ref_t scc_ast2ir_expr(scc_ast2ir_ctx_t *ctx,
                                     cbool is_lvalue);
 void scc_ast2ir_stmt(scc_ast2ir_ctx_t *ctx, const scc_ast_stmt_t *stmt);
 scc_hir_type_ref_t scc_ast2ir_type(scc_ast2ir_ctx_t *ctx,
-                                   const scc_ast_type_t *ast_type);
+                                   const scc_ast_qual_type_t *ast_type);
 
 #endif /* __SCC_AST2IR_H__ */

libs/ast2ir/src/scc_ast2ir.c

@@ -1,10 +1,11 @@
 #include <scc_ast2ir.h>
 #include <scc_ast_def.h>
+#include <scc_ast_utils.h>
 #include <scc_hir_builder.h>
 #include <scc_hir_def.h>
 
 static scc_hir_type_ref_t parse_base_type(scc_ast2ir_ctx_t *ctx,
-                                          const scc_ast_type_t *ast_type) {
+                                          const scc_ast_qual_type_t *ast_type) {
     scc_abi_type_layout_t layout;
     // 映射内置类型
     ctx->abi->compute_type_layout(ctx->abi, (void *)ast_type, &layout);
@@ -26,7 +27,7 @@ static scc_hir_type_ref_t parse_base_type(scc_ast2ir_ctx_t *ctx,
     return SCC_HIR_REF_nullptr;
 }
 
-static inline void parse_struct_union_layout(scc_ast_type_t *type) {}
+static inline void parse_struct_union_layout(scc_ast_qual_type_t *type) {}
 
 // 辅助函数：计算数组实际长度（如果原长度为0）
 static void resolve_array_length(scc_ast2ir_ctx_t *ctx,
@@ -123,7 +124,7 @@ static void emit_array_initialization(scc_ast2ir_ctx_t *ctx,
 }
 
 scc_hir_type_ref_t scc_ast2ir_type(scc_ast2ir_ctx_t *ctx,
-                                   const scc_ast_type_t *ast_type) {
+                                   const scc_ast_qual_type_t *ast_type) {
     if (ctx == nullptr || ast_type == nullptr) {
         LOG_ERROR("args is nullptr");
         return 0;
@@ -137,7 +138,7 @@ scc_hir_type_ref_t scc_ast2ir_type(scc_ast2ir_ctx_t *ctx,
     case SCC_AST_TYPE_POINTER: {
         scc_hir_type_init(&ir_type, SCC_HIR_TYPE_PTR);
         scc_hir_type_ref_t pointee_type =
-            scc_ast2ir_type(ctx, ast_type->pointer.pointee);
+            scc_ast2ir_type(ctx, scc_ast_canon_type(ast_type)->pointer.pointee);
         ir_type.data.pointer.base = pointee_type;
         break;
     }
@@ -145,17 +146,20 @@ scc_hir_type_ref_t scc_ast2ir_type(scc_ast2ir_ctx_t *ctx,
         scc_hir_type_init(&ir_type, SCC_HIR_TYPE_ARRAY);
 
         scc_hir_type_ref_t element_type =
-            scc_ast2ir_type(ctx, ast_type->array.element);
+            scc_ast2ir_type(ctx, scc_ast_canon_type(ast_type)->array.element);
 
         ir_type.data.array.base = element_type;
         ir_type.data.array.len = 0;
-        if (ast_type->array.size) {
+        if (scc_ast_canon_type(ast_type)->array.size) {
             // TODO constant expression
-            if (ast_type->array.size->base.type != SCC_AST_EXPR_INT_LITERAL) {
+            if (scc_ast_canon_type(ast_type)->array.size->base.type !=
+                SCC_AST_EXPR_INT_LITERAL) {
                 Panic("TODO: array size expression");
             }
             scc_ap_t value;
-            scc_ap_from_cstr(&value, ast_type->array.size->literal.lexme, 10);
+            scc_ap_from_cstr(
+                &value, scc_ast_canon_type(ast_type)->array.size->literal.lexme,
+                10);
             // FIXME hack
             ir_type.data.array.len = value.data.digit;
         }
@@ -165,8 +169,8 @@ scc_hir_type_ref_t scc_ast2ir_type(scc_ast2ir_ctx_t *ctx,
         scc_hir_type_init(&ir_type, SCC_HIR_TYPE_FUNC);
 
         // 处理返回类型
-        scc_hir_type_ref_t ret_type =
+        scc_hir_type_ref_t ret_type = scc_ast2ir_type(
-            scc_ast2ir_type(ctx, ast_type->function.return_type);
+            ctx, scc_ast_canon_type(ast_type)->function.return_type);
 
         // 将返回类型添加到程序的类型容器中
         ir_type.data.function.ret_type = ret_type;
@@ -174,9 +178,9 @@ scc_hir_type_ref_t scc_ast2ir_type(scc_ast2ir_ctx_t *ctx,
         // 转换参数类型
         scc_hir_type_ref_vec_t params;
         scc_vec_init(params);
-        scc_vec_foreach(ast_type->function.params, i) {
+        scc_vec_foreach(scc_ast_canon_type(ast_type)->function.params, i) {
             scc_ast_decl_t *decl_param =
-                scc_vec_at(ast_type->function.params, i);
+                scc_vec_at(scc_ast_canon_type(ast_type)->function.params, i);
             Assert(decl_param->base.type == SCC_AST_DECL_PARAM);
             scc_hir_type_ref_t tmp_type =
                 scc_ast2ir_type(ctx, decl_param->param.type);
@@ -190,10 +194,14 @@ scc_hir_type_ref_t scc_ast2ir_type(scc_ast2ir_ctx_t *ctx,
         scc_hir_type_init(&ir_type, ast_type->base.type == SCC_AST_TYPE_STRUCT
                                         ? SCC_HIR_TYPE_STRUCT
                                         : SCC_HIR_TYPE_UNION);
-        Assert(ast_type->record.decl != nullptr);
+        if (scc_ast_canon_type(ast_type)->record.decl == nullptr) {
-        scc_vec_foreach(ast_type->record.decl->record.fields, i) {
+            Panic("%s record fields is nullptr",
-            scc_ast_decl_t *decl_field =
+                  scc_ast_canon_type(ast_type)->record.name);
-                scc_vec_at(ast_type->record.decl->record.fields, i);
+        }
+        scc_vec_foreach(
+            scc_ast_canon_type(ast_type)->record.decl->record.fields, i) {
+            scc_ast_decl_t *decl_field = scc_vec_at(
+                scc_ast_canon_type(ast_type)->record.decl->record.fields, i);
             Assert(decl_field->base.type == SCC_AST_DECL_VAR);
             scc_hir_type_ref_t field_type =
                 scc_ast2ir_type(ctx, decl_field->var.type);
@@ -202,13 +210,19 @@ scc_hir_type_ref_t scc_ast2ir_type(scc_ast2ir_ctx_t *ctx,
         break;
     }
     case SCC_AST_TYPE_ENUM:
-        return parse_base_type(
+        scc_ast_canon_type_t int_canon_type = {
-            ctx, &(scc_ast_type_t){.base.type = SCC_AST_TYPE_BUILTIN,
+            .builtin = SCC_AST_BUILTIN_TYPE_INT,
-                                   .builtin = SCC_AST_BUILTIN_TYPE_INT});
+        };
+        scc_ast_qual_type_t int_type = {
+            .base.type = SCC_AST_TYPE_BUILTIN,
+            .type = &int_canon_type,
+        };
+        return parse_base_type(ctx, &int_type);
     case SCC_AST_TYPE_TYPEDEF:
         // TODO maybe using cache
-        return scc_ast2ir_type(ctx,
+        return scc_ast2ir_type(
-                               ast_type->typedef_type.decl->typedef_decl.type);
+            ctx,
+            scc_ast_canon_type(ast_type)->typedef_type.decl->typedef_decl.type);
     default:
         LOG_FATAL("Unsupported AST type: %d", ast_type->base.type);
         return 0;
@@ -560,10 +574,45 @@ scc_hir_value_ref_t scc_ast2ir_expr(scc_ast2ir_ctx_t *ctx,
                                         elem_ptr); // 作为右值：加载值
         }
     }
-    case SCC_AST_EXPR_MEMBER:
+    case SCC_AST_EXPR_MEMBER: {
-        break;
+        // 1. 获取基对象的左值（地址）
-    case SCC_AST_EXPR_PTR_MEMBER:
+        scc_hir_value_ref_t base_ptr =
-        break;
+            scc_ast2ir_expr(ctx, expr->member.base, true);
+        // 2. 通过偏移生成字段地址
+        //    需要基对象类型来计算索引：假设 sema 填好了 _target_idx
+        usize field_idx = expr->member._target_idx;
+        scc_ap_t idx_ap;
+        scc_ap_set_int(&idx_ap, field_idx);
+        scc_hir_value_ref_t idx_val = scc_hir_builder_integer(
+            &ctx->builder, scc_hir_builder_type_u64(&ctx->builder), &idx_ap);
+        scc_hir_value_ref_t field_ptr =
+            scc_hir_builder_get_elem_ptr(&ctx->builder, base_ptr, idx_val);
+        if (is_lvalue)
+            return field_ptr;
+        else
+            return scc_hir_builder_load(&ctx->builder, field_ptr);
+    }
+    case SCC_AST_EXPR_PTR_MEMBER: {
+        // 1. 计算指针值（obj->field 等价于 (*obj).field）
+        scc_hir_value_ref_t obj_ptr =
+            scc_ast2ir_expr(ctx, expr->member.base, false);
+        // 2. 解引用得到对象地址，再访问成员
+        //    但更简单：先 load 出对象值？不对：obj
+        //    是指向结构体的指针，我们需要指针的地址？ 实际上，obj->field 相当于
+        //    (*(obj)).field，所以可以直接用 obj 作为基地址进行 get_elem_ptr
+        //    因为 get_elem_ptr 接收一个指针，obj 本身就是指向结构体的指针。
+        usize field_idx = expr->member._target_idx;
+        scc_ap_t idx_ap;
+        scc_ap_set_int(&idx_ap, field_idx);
+        scc_hir_value_ref_t idx_val = scc_hir_builder_integer(
+            &ctx->builder, scc_hir_builder_type_u64(&ctx->builder), &idx_ap);
+        scc_hir_value_ref_t field_ptr =
+            scc_hir_builder_get_elem_ptr(&ctx->builder, obj_ptr, idx_val);
+        if (is_lvalue)
+            return field_ptr;
+        else
+            return scc_hir_builder_load(&ctx->builder, field_ptr);
+    }
     case SCC_AST_EXPR_CAST:
         break;
     case SCC_AST_EXPR_SIZE_OF: {
@@ -576,8 +625,9 @@ scc_hir_value_ref_t scc_ast2ir_expr(scc_ast2ir_ctx_t *ctx,
         // return scc_hir_builder_integer(
         //     &ctx->builder, scc_hir_builder_type_u64(&ctx->builder), val);
     }
-    case SCC_AST_EXPR_COMPOUND:
+    case SCC_AST_EXPR_COMPOUND: {
         break;
+    }
     case SCC_AST_EXPR_LVALUE:
         break;
         // SCC_AST_EXPR_BUILTIN,// 内置表达式 ... directive map to ir builtin
@@ -945,9 +995,10 @@ void scc_ast2ir_decl(scc_ast2ir_ctx_t *ctx, const scc_ast_decl_t *decl,
         scc_hir_builder_begin_func(&ctx->builder, func_ref);
         scc_hir_builder_begin_bblock(&ctx->builder, "entry");
 
-        scc_vec_foreach(decl->func.type->function.params, i) {
+        scc_vec_foreach(scc_ast_canon_type(decl->func.type)->function.params,
-            scc_ast_decl_t *param =
+                        i) {
-                scc_vec_at(decl->func.type->function.params, i);
+            scc_ast_decl_t *param = scc_vec_at(
+                scc_ast_canon_type(decl->func.type)->function.params, i);
             scc_ast2ir_decl(ctx, param, false);
         }
 
@@ -968,7 +1019,8 @@ void scc_ast2ir_decl(scc_ast2ir_ctx_t *ctx, const scc_ast_decl_t *decl,
     }
     case SCC_AST_DECL_PARAM: {
         if (decl->param.type->base.type == SCC_AST_TYPE_BUILTIN &&
-            decl->param.type->builtin.type == SCC_AST_BUILTIN_TYPE_VOID) {
+            scc_ast_canon_type(decl->param.type)->builtin.type ==
+                SCC_AST_BUILTIN_TYPE_VOID) {
             break;
         }
         scc_hir_type_ref_t parma_type_ref =
@@ -988,12 +1040,15 @@ void scc_ast2ir_decl(scc_ast2ir_ctx_t *ctx, const scc_ast_decl_t *decl,
     }
     case SCC_AST_DECL_STRUCT:
     case SCC_AST_DECL_UNION:
-        scc_ast_type_t type = {
+        scc_ast_canon_type_t canon_type = {
-            .base.type =
-                SCC_AST_DECL_STRUCT ? SCC_AST_TYPE_STRUCT : SCC_AST_TYPE_UNION,
             .record.decl = decl,
             .record.name = decl->name,
         };
+        scc_ast_qual_type_t type = {
+            .base.type =
+                SCC_AST_DECL_STRUCT ? SCC_AST_TYPE_STRUCT : SCC_AST_TYPE_UNION,
+            .type = &canon_type,
+        };
         scc_hir_type_ref_t type_ref = scc_ast2ir_type(ctx, &type);
         // scc_hir_builder_global_alloca(&ctx->builder, type_ref,
         //                              SCC_HIR_REF_nullptr);
@@ -1024,7 +1079,7 @@ void scc_ast2ir_decl(scc_ast2ir_ctx_t *ctx, const scc_ast_decl_t *decl,
     }
 }
 
-void scc_ast2ir_translation_unit(scc_ast2ir_ctx_t *ctx,
+void scc_ast2ir_run(scc_ast2ir_ctx_t *ctx,
                     const scc_ast_translation_unit_t *tu) {
     Assert(ctx != nullptr && tu != nullptr);
 

libs/ir/hir/src/scc_hir_builder.c

@@ -123,7 +123,7 @@ static int cmp_type(const void *_key1, const void *_key2, void *userdata) {
             key2->data.function.params.size) {
             return 1;
         }
-        for (usize i = 0; i < key1->data.function.params.size; i++) {
+        scc_vec_foreach(key1->data.function.params, i) {
             if (key1->data.function.params.data[i] !=
                 key2->data.function.params.data[i]) {
                 return 1;
@@ -131,6 +131,20 @@ static int cmp_type(const void *_key1, const void *_key2, void *userdata) {
         }
         return 0;
     }
+    case SCC_HIR_TYPE_STRUCT:
+    case SCC_HIR_TYPE_UNION: {
+        if (key1->data.aggregate.fields.size !=
+            key2->data.aggregate.fields.size) {
+            return 1;
+        }
+        scc_vec_foreach(key1->data.aggregate.fields, i) {
+            if (key1->data.aggregate.fields.data[i] !=
+                key2->data.aggregate.fields.data[i]) {
+                return 1;
+            }
+        }
+        return 0;
+    }
     default:
         Panic("Unknown key type %d", key1->tag);
         return 1;

libs/ir/hir/src/scc_hir_dump.c

@@ -429,6 +429,18 @@ void scc_hir_dump_type_linear(scc_hir_dump_t *ctx,
             scc_tree_dump_append(ctx->dump_ctx, ")");
         }
         break;
+    case SCC_HIR_TYPE_STRUCT:
+    case SCC_HIR_TYPE_UNION:
+        scc_tree_dump_append_fmt(ctx->dump_ctx, "%s {",
+                                 type->tag == SCC_HIR_TYPE_STRUCT ? "struct"
+                                                                  : "union");
+        scc_vec_foreach(type->data.aggregate.fields, i) {
+            scc_hir_dump_type_linear(
+                ctx, scc_vec_at(type->data.aggregate.fields, i));
+            scc_tree_dump_append(ctx->dump_ctx, ";");
+        }
+        scc_tree_dump_append(ctx->dump_ctx, "}");
+        break;
     default:
         LOG_ERROR("invalid type tag");
         break;

libs/parser/include/scc_parse_type.h

@@ -0,0 +1,108 @@
+#ifndef __SCC_PARSE_TYPE_H__
+#define __SCC_PARSE_TYPE_H__
+
+#include <scc_ast.h>
+#include <scc_ast_utils.h>
+
+static inline void scc_ast_type_pointer_init(scc_ast_qual_type_t *type,
+                                             scc_ast_canon_type_t *canon,
+                                             scc_ast_qual_type_t *pointee,
+                                             scc_pos_t loc) {
+    Assert(type != nullptr && pointee != nullptr);
+    type->base.loc = loc;
+    type->base.type = SCC_AST_TYPE_POINTER;
+    type->quals = (scc_ast_decl_specifier_t){0};
+    type->type = canon;
+    canon->pointer.pointee = pointee;
+}
+
+// size can be nullptr
+static inline void scc_ast_type_array_init(scc_ast_qual_type_t *type,
+                                           scc_ast_canon_type_t *canon,
+                                           scc_ast_qual_type_t *element,
+                                           scc_ast_expr_t *size,
+                                           scc_pos_t loc) {
+    Assert(type != nullptr && element != nullptr);
+    type->base.loc = loc;
+    type->base.type = SCC_AST_TYPE_ARRAY;
+    type->quals = (scc_ast_decl_specifier_t){0};
+    type->type = canon;
+    canon->array.element = element;
+    canon->array.size = size;
+}
+
+// return_type and params can be nullptr
+static inline void scc_ast_type_function_init(scc_ast_qual_type_t *type,
+                                              scc_ast_canon_type_t *canon,
+                                              scc_ast_qual_type_t *return_type,
+                                              scc_ast_decl_vec_t *params,
+                                              scc_pos_t loc) {
+    Assert(type != nullptr);
+    type->base.loc = loc;
+    type->base.type = SCC_AST_TYPE_FUNCTION;
+    type->quals = (scc_ast_decl_specifier_t){0};
+    type->type = canon;
+    canon->function.return_type = return_type;
+    if (params == nullptr) {
+        scc_vec_init(canon->function.params);
+    } else {
+        canon->function.params = *params;
+        scc_vec_init(*params);
+    }
+}
+
+static inline void _scc_ast_type_record_init(scc_ast_qual_type_t *type,
+                                             scc_ast_canon_type_t *canon,
+                                             scc_ast_node_kind_t type_kind,
+                                             const char *name,
+                                             scc_ast_decl_t *decl,
+                                             scc_pos_t loc) {
+    Assert(type != nullptr);
+    type->base.loc = loc;
+    type->base.type = type_kind;
+    type->quals = (scc_ast_decl_specifier_t){0};
+    type->type = canon;
+    canon->record.name = name;
+    canon->record.decl = decl;
+}
+
+// name and decl can be nullptr
+static inline void scc_ast_type_struct_init(scc_ast_qual_type_t *type,
+                                            scc_ast_canon_type_t *canon,
+                                            const char *name,
+                                            scc_ast_decl_t *decl,
+                                            scc_pos_t loc) {
+    _scc_ast_type_record_init(type, canon, SCC_AST_TYPE_STRUCT, name, decl,
+                              loc);
+}
+
+// name and decl can be nullptr
+static inline void
+scc_ast_type_union_init(scc_ast_qual_type_t *type, scc_ast_canon_type_t *canon,
+                        const char *name, scc_ast_decl_t *decl, scc_pos_t loc) {
+    _scc_ast_type_record_init(type, canon, SCC_AST_TYPE_UNION, name, decl, loc);
+}
+
+// name and decl can be nullptr
+static inline void scc_ast_type_enum_init(scc_ast_qual_type_t *type,
+                                          scc_ast_canon_type_t *canon,
+                                          const char *name,
+                                          scc_ast_decl_t *decl, scc_pos_t loc) {
+    _scc_ast_type_record_init(type, canon, SCC_AST_TYPE_ENUM, name, decl, loc);
+}
+
+static inline void scc_ast_type_typedef_init(scc_ast_qual_type_t *type,
+                                             scc_ast_canon_type_t *canon,
+                                             const char *name,
+                                             scc_ast_decl_t *target,
+                                             scc_pos_t loc) {
+    Assert(type != nullptr && target != nullptr);
+    type->base.loc = loc;
+    type->base.type = SCC_AST_TYPE_TYPEDEF;
+    type->quals = (scc_ast_decl_specifier_t){0};
+    type->type = canon;
+    canon->typedef_type.name = name;
+    canon->typedef_type.decl = target;
+}
+
+#endif /* __SCC_PARSE_TYPE_H__ */

libs/parser/include/scc_parser.h

@@ -14,12 +14,13 @@ typedef struct scc_parser {
     scc_lexer_tok_ring_t *ring;
     usize checkpoint;
 
-    scc_sema_callbacks_t sema_callbacks;
+    scc_ast_ctx_t *ast_ctx;
+    scc_sema_ctx_t sema_callbacks;
     scc_ast_translation_unit_t *translation_unit;
     int errcode;
 } scc_parser_t;
 
-// static inline scc_ast_type_t *scc_parser_
+// static inline scc_ast_qual_type_t *scc_parser_
 
 /**
  * @brief 初始化解析器
@@ -28,7 +29,7 @@ typedef struct scc_parser {
  * @param callbacks 语义分析回调(可为 nullptr)
  */
 void scc_parser_init(scc_parser_t *parser, scc_lexer_tok_ring_t *tok_ring,
-                     scc_sema_callbacks_t *callbacks);
+                     scc_ast_ctx_t *ast_ctx, scc_sema_ctx_t *callbacks);
 
 /**
  * @brief 销毁解析器
@@ -74,9 +75,9 @@ scc_ast_expr_t *scc_parse_expression(scc_parser_t *parser);
  * @return 类型 AST 节点
  */
 scc_ast_decl_t *scc_parse_declarator(scc_parser_t *parser,
-                                     scc_ast_type_t *type);
+                                     scc_ast_qual_type_t *type);
-scc_ast_type_t *scc_parse_declaration_specifiers(scc_parser_t *parser);
+scc_ast_qual_type_t *scc_parse_declaration_specifiers(scc_parser_t *parser);
-scc_ast_type_t *scc_parse_type_name(scc_parser_t *parser);
+scc_ast_qual_type_t *scc_parse_type_name(scc_parser_t *parser);
 
 static inline void scc_parse_decl_sema(scc_parser_t *parser,
                                        scc_ast_decl_t *decl) {
@@ -100,14 +101,14 @@ static inline void scc_parse_stmt_sema(scc_parser_t *parser,
 }
 
 static inline void scc_parse_type_sema(scc_parser_t *parser,
-                                       scc_ast_type_t *type) {
+                                       scc_ast_qual_type_t *type) {
     parser->sema_callbacks.on_type(parser->sema_callbacks.context,
                                    type ? type->base.type : SCC_AST_UNKNOWN,
                                    type);
 }
 
-static inline scc_ast_type_t *scc_parse_got_type(scc_parser_t *parser,
+static inline const scc_ast_qual_type_t *
-                                                 const char *name) {
+scc_parse_got_type(scc_parser_t *parser, const char *name) {
     return parser->sema_callbacks.got_type(parser->sema_callbacks.context,
                                            name);
 }

libs/parser/include/scc_sema.h

@@ -9,21 +9,23 @@
 typedef void (*scc_sema_callback_t)(void *context,
                                     scc_ast_node_kind_t node_type, void *node);
 
-typedef scc_ast_type_t *(*scc_sema_got_type_t)(void *context, const char *name);
+typedef const scc_ast_qual_type_t *(*scc_sema_got_type_t)(void *context,
+                                                          const char *name);
 
 /**
  * @brief 语义分析回调集合
  */
-typedef struct scc_sema_callbacks {
+typedef struct scc_sema_ctx {
     scc_sema_callback_t on_decl;
     scc_sema_callback_t on_stmt;
     scc_sema_callback_t on_expr;
     scc_sema_callback_t on_type;
     scc_sema_got_type_t got_type;
+    scc_ast_ctx_t *ast_ctx;
     void *context;
-} scc_sema_callbacks_t;
+} scc_sema_ctx_t;
 
-void scc_sema_init(scc_sema_callbacks_t *callbacks);
+void scc_sema_init(scc_sema_ctx_t *sema_ctx, scc_ast_ctx_t *ast_ctx);
-void scc_sema_drop(scc_sema_callbacks_t *callbacks);
+void scc_sema_drop(scc_sema_ctx_t *sema_ctx);
 
 #endif /* __SCC_SEMA_H__ */

libs/parser/src/parse_decl.c

@@ -152,6 +152,7 @@ A.2.4 External definitions
 */
 
 #include <parser_utils.h>
+#include <scc_ast_utils.h>
 #include <scc_parser.h>
 
 scc_ast_expr_t *scc_parse_initializer(scc_parser_t *parser,
@@ -186,7 +187,7 @@ scc_ast_expr_t *scc_parse_initializer(scc_parser_t *parser,
     scc_pos_t pos = tok.loc;
     scc_lexer_tok_drop(&tok);
 
-    init = scc_malloc(sizeof(scc_ast_expr_t));
+    init = SCC_AST_ALLOC_EXPR(parser->ast_ctx);
     Assert(init != nullptr);
     scc_ast_expr_vec_t lhs_exprs;
     scc_vec_init(lhs_exprs);
@@ -202,7 +203,7 @@ scc_ast_expr_t *scc_parse_initializer(scc_parser_t *parser,
             tok_ptr = scc_parser_peek(parser);
             if (tok_ptr && tok_ptr->type == SCC_TOK_IDENT) {
                 scc_parser_next_consume(parser, &tok);
-                lhs = scc_malloc(sizeof(scc_ast_expr_t));
+                lhs = SCC_AST_ALLOC_EXPR(parser->ast_ctx);
                 Assert(lhs != nullptr);
                 scc_ast_expr_member_init(lhs, ptr, scc_str_as_cstr(&tok.lexeme),
                                          tok.loc);
@@ -230,7 +231,7 @@ scc_ast_expr_t *scc_parse_initializer(scc_parser_t *parser,
             if (!scc_parser_consume_if(parser, SCC_TOK_R_BRACKET)) {
                 SCC_ERROR(scc_parser_got_current_pos(parser), "Expected ']'");
             }
-            lhs = scc_malloc(sizeof(scc_ast_expr_t));
+            lhs = SCC_AST_ALLOC_EXPR(parser->ast_ctx);
             Assert(lhs != nullptr);
             scc_ast_expr_array_subscript_init(lhs, ptr, idx, tok_ptr->loc);
             if (!scc_parser_consume_if(parser, SCC_TOK_ASSIGN)) {
@@ -266,7 +267,7 @@ scc_ast_decl_t *scc_parse_declaration(scc_parser_t *parser) {
     scc_ast_decl_vec_t decl_list_vec;
     scc_vec_init(decl_list_vec);
 
-    scc_ast_type_t *type = scc_parse_declaration_specifiers(parser);
+    scc_ast_qual_type_t *type = scc_parse_declaration_specifiers(parser);
     if (type == nullptr) {
         return nullptr;
     }
@@ -284,16 +285,17 @@ CONTINUE:
     if (tok_ptr->type == SCC_TOK_ASSIGN) {
         scc_parser_next_consume(parser, nullptr);
         // TODO maybe memory leak
-        scc_ast_expr_t *lvalue = scc_malloc(sizeof(scc_ast_expr_t));
+        scc_ast_expr_t *lvalue = SCC_AST_ALLOC_EXPR(parser->ast_ctx);
         scc_ast_expr_lvalue_init(lvalue, decl->var.type, decl->base.loc);
         decl->var.init = scc_parse_initializer(parser, lvalue);
     } else if (tok_ptr->type == SCC_TOK_L_BRACE) {
         scc_parse_decl_sema(parser, decl);
         parser->sema_callbacks.on_decl(parser->sema_callbacks.context,
                                        scc_ast_decl_t_BEGIN, nullptr);
-        scc_vec_foreach(decl->func.type->function.params, i) {
+        // FIXME hack struct
+        scc_vec_foreach(decl->func.type->type->function.params, i) {
             scc_ast_decl_t *param =
-                scc_vec_at(decl->func.type->function.params, i);
+                scc_vec_at(decl->func.type->type->function.params, i);
             // Add params to decl
             scc_parse_decl_sema(parser, param);
         }
@@ -342,7 +344,7 @@ CONTINUE:
     } else if (tok_ptr->type == SCC_TOK_COMMA) {
         scc_parser_next_consume(parser, nullptr);
         if (decl_list == nullptr) {
-            decl_list = scc_malloc(sizeof(scc_ast_decl_t));
+            decl_list = SCC_AST_ALLOC_DECL(parser->ast_ctx);
             Assert(decl_list != nullptr);
             scc_vec_push(decl_list_vec, decl);
         } else {

libs/parser/src/parse_expr.c

@@ -106,6 +106,7 @@ A.2.1 Expressions
 */
 
 #include <parser_utils.h>
+#include <scc_ast_utils.h>
 #include <scc_parser.h>
 
 /**
@@ -370,7 +371,7 @@ static scc_ast_expr_t *parse_expression_with_precedence(scc_parser_t *parser,
             return nullptr;
         }
 
-        scc_ast_expr_t *expr = scc_malloc(sizeof(scc_ast_expr_t));
+        scc_ast_expr_t *expr = SCC_AST_ALLOC_EXPR(parser->ast_ctx);
         Assert(expr != nullptr);
         // FIXME pos
         scc_ast_expr_binary_init(expr, op, left, right, left->base.loc);
@@ -409,7 +410,7 @@ scc_ast_expr_t *scc_parse_assignment_expression(scc_parser_t *parser) {
             return nullptr;
         }
 
-        scc_ast_expr_t *expr = scc_malloc(sizeof(scc_ast_expr_t));
+        scc_ast_expr_t *expr = SCC_AST_ALLOC_EXPR(parser->ast_ctx);
         Assert(expr != nullptr);
         scc_ast_expr_binary_init(expr, op, left, right, pos);
         left = expr;
@@ -455,7 +456,7 @@ static scc_ast_expr_t *parse_conditional_expression(scc_parser_t *parser) {
             return nullptr;
         }
 
-        scc_ast_expr_t *cond = scc_malloc(sizeof(scc_ast_expr_t));
+        scc_ast_expr_t *cond = SCC_AST_ALLOC_EXPR(parser->ast_ctx);
         Assert(cond != nullptr);
         scc_ast_expr_cond_init(cond, cond_expr, then_expr, else_expr, pos);
         cond_expr = cond;
@@ -466,7 +467,7 @@ static scc_ast_expr_t *parse_conditional_expression(scc_parser_t *parser) {
 // 类型转换表达式 (type-name) cast-expression
 static scc_ast_expr_t *parse_cast_expression(scc_parser_t *parser) {
     const scc_lexer_tok_t *tok_ptr = scc_parser_peek(parser);
-    scc_ast_type_t *type = nullptr;
+    scc_ast_qual_type_t *type = nullptr;
     if (tok_ptr && tok_ptr->type == SCC_TOK_L_PAREN) {
         // 尝试解析类型名
         scc_parser_store(parser);
@@ -480,13 +481,13 @@ static scc_ast_expr_t *parse_cast_expression(scc_parser_t *parser) {
                 scc_ast_expr_t *operand = parse_cast_expression(parser);
                 if (!operand) {
                     // FIXME postfix-expression
-                    scc_ast_expr_t *expr = scc_malloc(sizeof(scc_ast_expr_t));
+                    scc_ast_expr_t *expr = SCC_AST_ALLOC_EXPR(parser->ast_ctx);
                     // FIXME pos
                     scc_ast_expr_lvalue_init(expr, type, type->base.loc);
                     operand = scc_parse_initializer(parser, expr);
                     return operand;
                 }
-                scc_ast_expr_t *expr = scc_malloc(sizeof(scc_ast_expr_t));
+                scc_ast_expr_t *expr = SCC_AST_ALLOC_EXPR(parser->ast_ctx);
                 Assert(expr != nullptr);
                 // FIXME pos
                 scc_ast_expr_cast_init(expr, type, operand, type->base.loc);
@@ -558,7 +559,7 @@ static scc_ast_expr_t *parse_unary_expression(scc_parser_t *parser) {
             return nullptr;
         }
 
-        scc_ast_expr_t *expr = scc_malloc(sizeof(scc_ast_expr_t));
+        scc_ast_expr_t *expr = SCC_AST_ALLOC_EXPR(parser->ast_ctx);
         Assert(expr != nullptr);
         scc_ast_expr_unary_init(expr, op, operand, pos);
         return expr;
@@ -587,12 +588,12 @@ static scc_ast_expr_t *parse_sizeof_expression(scc_parser_t *parser) {
         return nullptr;
     }
 
-    scc_ast_expr_t *expr = scc_malloc(sizeof(scc_ast_expr_t));
+    scc_ast_expr_t *expr = SCC_AST_ALLOC_EXPR(parser->ast_ctx);
 
     if (next->type == SCC_TOK_L_PAREN) {
         scc_parser_store(parser);
         scc_parser_next(parser);
-        scc_ast_type_t *type_name = scc_parse_type_name(parser);
+        scc_ast_qual_type_t *type_name = scc_parse_type_name(parser);
         if (type_name == nullptr) {
             scc_parser_restore(parser);
             goto next;
@@ -633,7 +634,7 @@ static scc_ast_expr_t *parse_postfix_expression(scc_parser_t *parser) {
 
         scc_parser_store(parser);
         scc_parser_next(parser);
-        scc_ast_type_t *type = scc_parse_type_name(parser);
+        scc_ast_qual_type_t *type = scc_parse_type_name(parser);
         if (!type) {
             scc_parser_restore(parser);
             return nullptr;
@@ -642,7 +643,7 @@ static scc_ast_expr_t *parse_postfix_expression(scc_parser_t *parser) {
         if (!scc_parser_consume_if(parser, SCC_TOK_R_PAREN)) {
             SCC_ERROR(scc_parser_got_current_pos(parser), "Expected ')'");
         }
-        scc_ast_expr_t *expr = scc_malloc(sizeof(scc_ast_expr_t));
+        scc_ast_expr_t *expr = SCC_AST_ALLOC_EXPR(parser->ast_ctx);
         scc_ast_expr_lvalue_init(expr, type, pos);
         left = scc_parse_initializer(parser, expr);
         return left;
@@ -671,7 +672,7 @@ static scc_ast_expr_t *parse_postfix_expression(scc_parser_t *parser) {
                 parser_sync(parser);
                 return nullptr;
             }
-            scc_ast_expr_t *subscript = scc_malloc(sizeof(scc_ast_expr_t));
+            scc_ast_expr_t *subscript = SCC_AST_ALLOC_EXPR(parser->ast_ctx);
             Assert(subscript != nullptr);
             scc_ast_expr_array_subscript_init(subscript, left, index, pos);
             left = subscript;
@@ -708,7 +709,7 @@ static scc_ast_expr_t *parse_postfix_expression(scc_parser_t *parser) {
                     return nullptr;
                 }
             }
-            scc_ast_expr_t *call = scc_malloc(sizeof(scc_ast_expr_t));
+            scc_ast_expr_t *call = SCC_AST_ALLOC_EXPR(parser->ast_ctx);
             Assert(call != nullptr);
             scc_ast_expr_call_init(call, left, &args, pos);
             left = call;
@@ -730,7 +731,7 @@ static scc_ast_expr_t *parse_postfix_expression(scc_parser_t *parser) {
             }
             const char *name = scc_str_as_cstr(&ident_tok.lexeme);
 
-            scc_ast_expr_t *member = scc_malloc(sizeof(scc_ast_expr_t));
+            scc_ast_expr_t *member = SCC_AST_ALLOC_EXPR(parser->ast_ctx);
             Assert(member != nullptr);
             if (op_tok.type == SCC_TOK_DOT) {
                 scc_ast_expr_member_init(member, left, name, ident_tok.loc);
@@ -749,7 +750,7 @@ static scc_ast_expr_t *parse_postfix_expression(scc_parser_t *parser) {
             if (!scc_parser_next_consume(parser, &op_tok))
                 return left;
             scc_ast_expr_op_t op = map_token_to_unary_op(op_tok.type, false);
-            scc_ast_expr_t *expr = scc_malloc(sizeof(scc_ast_expr_t));
+            scc_ast_expr_t *expr = SCC_AST_ALLOC_EXPR(parser->ast_ctx);
             Assert(expr != nullptr);
             scc_ast_expr_unary_init(expr, op, left, op_tok.loc);
             scc_lexer_tok_drop(&op_tok);
@@ -784,7 +785,7 @@ static scc_ast_expr_t *parse_primary_expression(scc_parser_t *parser) {
     case SCC_TOK_IDENT: {
         if (!scc_parser_next_consume(parser, &tok))
             return nullptr;
-        expr = scc_malloc(sizeof(scc_ast_expr_t));
+        expr = SCC_AST_ALLOC_EXPR(parser->ast_ctx);
         Assert(expr != nullptr);
         scc_ast_expr_identifier_init(expr, scc_str_as_cstr(&tok.lexeme),
                                      tok.loc);
@@ -793,7 +794,7 @@ static scc_ast_expr_t *parse_primary_expression(scc_parser_t *parser) {
     case SCC_TOK_INT_LITERAL: {
         if (!scc_parser_next_consume(parser, &tok))
             return nullptr;
-        expr = scc_malloc(sizeof(scc_ast_expr_t));
+        expr = SCC_AST_ALLOC_EXPR(parser->ast_ctx);
         Assert(expr != nullptr);
         scc_ast_expr_literal_int_init(expr, scc_str_as_cstr(&tok.lexeme), false,
                                       tok.loc);
@@ -802,7 +803,7 @@ static scc_ast_expr_t *parse_primary_expression(scc_parser_t *parser) {
     case SCC_TOK_FLOAT_LITERAL: {
         if (!scc_parser_next_consume(parser, &tok))
             return nullptr;
-        expr = scc_malloc(sizeof(scc_ast_expr_t));
+        expr = SCC_AST_ALLOC_EXPR(parser->ast_ctx);
         Assert(expr != nullptr);
         scc_ast_expr_literal_float_init(expr, scc_str_as_cstr(&tok.lexeme),
                                         false, tok.loc);
@@ -811,7 +812,7 @@ static scc_ast_expr_t *parse_primary_expression(scc_parser_t *parser) {
     case SCC_TOK_CHAR_LITERAL: {
         if (!scc_parser_next_consume(parser, &tok))
             return nullptr;
-        expr = scc_malloc(sizeof(scc_ast_expr_t));
+        expr = SCC_AST_ALLOC_EXPR(parser->ast_ctx);
         Assert(expr != nullptr);
         scc_ast_expr_literal_char_init(expr, scc_str_as_cstr(&tok.lexeme),
                                        false, tok.loc);
@@ -834,7 +835,7 @@ static scc_ast_expr_t *parse_primary_expression(scc_parser_t *parser) {
             scc_str_append(&string, &tmp);
         }
 
-        expr = scc_malloc(sizeof(scc_ast_expr_t));
+        expr = SCC_AST_ALLOC_EXPR(parser->ast_ctx);
         Assert(expr != nullptr);
         // FIXME loc
         scc_ast_expr_literal_string_init(expr, scc_str_as_cstr(&string), true,
@@ -879,7 +880,7 @@ scc_ast_expr_t *scc_parse_expression(scc_parser_t *parser) {
             parser_sync(parser);
             return nullptr;
         }
-        scc_ast_expr_t *expr = scc_malloc(sizeof(scc_ast_expr_t));
+        scc_ast_expr_t *expr = SCC_AST_ALLOC_EXPR(parser->ast_ctx);
         Assert(expr != nullptr);
         scc_ast_expr_binary_init(expr, SCC_AST_OP_COMMA, left, right, pos);
         left = expr;

libs/parser/src/parse_stmt.c

@@ -48,16 +48,9 @@ A.2.3 Statements
 */
 
 #include <parser_utils.h>
+#include <scc_ast_utils.h>
 #include <scc_parser.h>
 
-static inline scc_ast_stmt_t *ast_stmt_alloc() {
-    scc_ast_stmt_t *stmt = (scc_ast_stmt_t *)scc_malloc(sizeof(scc_ast_stmt_t));
-    if (stmt == nullptr) {
-        LOG_FATAL("Out of memory");
-    }
-    return stmt;
-}
-
 static inline scc_ast_expr_t *ast_parse_paren_expression(scc_parser_t *parser) {
     if (!scc_parser_consume_if(parser, SCC_TOK_L_PAREN)) {
         SCC_ERROR(scc_parser_got_current_pos(parser),
@@ -90,7 +83,7 @@ static scc_ast_stmt_t *parse_label_statement(scc_parser_t *parser,
         Panic("expect stmt");
     }
 
-    scc_ast_stmt_t *stmt = ast_stmt_alloc();
+    scc_ast_stmt_t *stmt = SCC_AST_ALLOC_STMT(parser->ast_ctx);
     Assert(stmt != nullptr);
     scc_ast_stmt_label_init(stmt, scc_str_as_cstr(&tok.lexeme), statement, pos);
     return stmt;
@@ -121,7 +114,7 @@ static scc_ast_stmt_t *parse_case_statement(scc_parser_t *parser,
         Panic("expect stmt");
     }
 
-    scc_ast_stmt_t *stmt = ast_stmt_alloc();
+    scc_ast_stmt_t *stmt = SCC_AST_ALLOC_STMT(parser->ast_ctx);
     scc_ast_stmt_case_init(stmt, expr, statement, pos);
     return stmt;
 }
@@ -143,7 +136,7 @@ static scc_ast_stmt_t *parse_default_statement(scc_parser_t *parser,
         Panic("expect stmt");
     }
 
-    scc_ast_stmt_t *stmt = ast_stmt_alloc();
+    scc_ast_stmt_t *stmt = SCC_AST_ALLOC_STMT(parser->ast_ctx);
     scc_ast_stmt_default_init(stmt, statement, pos);
     return stmt;
 }
@@ -177,7 +170,7 @@ static scc_ast_stmt_t *parse_compound_statement(scc_parser_t *parser,
     parser->sema_callbacks.on_stmt(parser->sema_callbacks.context,
                                    scc_ast_stmt_t_END, nullptr);
 
-    scc_ast_stmt_t *stmt = ast_stmt_alloc();
+    scc_ast_stmt_t *stmt = SCC_AST_ALLOC_STMT(parser->ast_ctx);
     scc_ast_stmt_compound_init(stmt, &block_items, pos);
     return stmt;
 }
@@ -197,7 +190,7 @@ static scc_ast_stmt_t *parse_if_statement(scc_parser_t *parser, scc_pos_t pos) {
         opt_else = nullptr;
     }
 
-    scc_ast_stmt_t *stmt = ast_stmt_alloc();
+    scc_ast_stmt_t *stmt = SCC_AST_ALLOC_STMT(parser->ast_ctx);
     scc_ast_stmt_if_init(stmt, expression, statement, opt_else, pos);
     return stmt;
 }
@@ -211,7 +204,7 @@ static scc_ast_stmt_t *parse_switch_statement(scc_parser_t *parser,
     scc_ast_expr_t *expression = ast_parse_paren_expression(parser);
     scc_ast_stmt_t *statement = scc_parse_statement(parser);
 
-    scc_ast_stmt_t *stmt = ast_stmt_alloc();
+    scc_ast_stmt_t *stmt = SCC_AST_ALLOC_STMT(parser->ast_ctx);
     scc_ast_stmt_switch_init(stmt, expression, statement, pos);
     return stmt;
 }
@@ -225,7 +218,7 @@ static scc_ast_stmt_t *parse_while_statement(scc_parser_t *parser,
     scc_ast_expr_t *expression = ast_parse_paren_expression(parser);
     scc_ast_stmt_t *statement = scc_parse_statement(parser);
 
-    scc_ast_stmt_t *stmt = ast_stmt_alloc();
+    scc_ast_stmt_t *stmt = SCC_AST_ALLOC_STMT(parser->ast_ctx);
     scc_ast_stmt_while_init(stmt, expression, statement, pos);
     return stmt;
 }
@@ -242,7 +235,6 @@ static scc_ast_stmt_t *parse_do_while_statement(scc_parser_t *parser,
         SCC_ERROR(scc_parser_got_current_pos(parser),
                   "Expected 'while' after do.");
         // TODO 使用更好的错误处理，未来应当采用更好的内存管理器
-        scc_free(statement);
         return nullptr;
     }
     scc_ast_expr_t *expression = ast_parse_paren_expression(parser);
@@ -251,7 +243,7 @@ static scc_ast_stmt_t *parse_do_while_statement(scc_parser_t *parser,
         SCC_ERROR(scc_parser_got_current_pos(parser),
                   "Expected semicolon after jump statement.");
     }
-    scc_ast_stmt_t *stmt = ast_stmt_alloc();
+    scc_ast_stmt_t *stmt = SCC_AST_ALLOC_STMT(parser->ast_ctx);
     scc_ast_stmt_do_while_init(stmt, expression, statement, pos);
     return stmt;
 }
@@ -303,14 +295,14 @@ static scc_ast_stmt_t *parse_for_statement(scc_parser_t *parser,
 
     body = scc_parse_statement(parser);
 
-    scc_ast_stmt_t *stmt = ast_stmt_alloc();
+    scc_ast_stmt_t *stmt = SCC_AST_ALLOC_STMT(parser->ast_ctx);
     scc_ast_stmt_for_init(stmt, init, cond, incr, body, pos);
     return stmt;
 }
 
 static scc_ast_stmt_t *parse_jump_statement(scc_parser_t *parser,
                                             scc_pos_t pos) {
-    scc_ast_stmt_t *stmt = ast_stmt_alloc();
+    scc_ast_stmt_t *stmt = SCC_AST_ALLOC_STMT(parser->ast_ctx);
 
     if (scc_parser_consume_if(parser, SCC_TOK_GOTO)) {
         scc_lexer_tok_t tok = {0};
@@ -341,7 +333,7 @@ static scc_ast_stmt_t *parse_expression_statement(scc_parser_t *parser,
                                                   scc_pos_t pos) {
 
     if (scc_parser_consume_if(parser, SCC_TOK_SEMICOLON)) {
-        scc_ast_stmt_t *stmt = ast_stmt_alloc();
+        scc_ast_stmt_t *stmt = SCC_AST_ALLOC_STMT(parser->ast_ctx);
         scc_ast_stmt_expr_init(stmt, nullptr, pos);
         return stmt;
     }
@@ -351,7 +343,7 @@ static scc_ast_stmt_t *parse_expression_statement(scc_parser_t *parser,
         return nullptr;
     }
 
-    scc_ast_stmt_t *stmt = ast_stmt_alloc();
+    scc_ast_stmt_t *stmt = SCC_AST_ALLOC_STMT(parser->ast_ctx);
     scc_ast_stmt_expr_init(stmt, expr, pos);
 
     if (!scc_parser_consume_if(parser, SCC_TOK_SEMICOLON)) {

libs/parser/src/parse_type.c

@@ -157,31 +157,24 @@ EXAMPLE The constructions
 */
 
 #include <parser_utils.h>
+#include <scc_parse_type.h>
 #include <scc_parser.h>
 
-static scc_ast_type_t *parse_declarator(scc_parser_t *parser,
+static scc_ast_qual_type_t *
-                                        scc_ast_type_t *base,
+parse_declarator(scc_parser_t *parser, scc_ast_qual_type_t *base,
-                                        scc_ast_type_t **delay_pointee_ptr,
+                 scc_ast_qual_type_t **delay_pointee_ptr,
                  scc_lexer_tok_t *tok_ident);
-static scc_ast_type_t *
+static scc_ast_qual_type_t *
-parse_direct_declarator(scc_parser_t *parser, scc_ast_type_t *base,
+parse_direct_declarator(scc_parser_t *parser, scc_ast_qual_type_t *base,
-                        scc_ast_type_t **delay_pointee_ptr,
+                        scc_ast_qual_type_t **delay_pointee_ptr,
                         scc_lexer_tok_t *tok_ident);
-static scc_ast_type_t *
+static scc_ast_qual_type_t *
-parse_abstract_declarator(scc_parser_t *parser, scc_ast_type_t *base,
+parse_abstract_declarator(scc_parser_t *parser, scc_ast_qual_type_t *base,
-                          scc_ast_type_t **delay_pointee_ptr);
+                          scc_ast_qual_type_t **delay_pointee_ptr);
-static scc_ast_type_t *
+static scc_ast_qual_type_t *
-parse_direct_abstract_declarator(scc_parser_t *parser, scc_ast_type_t *base,
+parse_direct_abstract_declarator(scc_parser_t *parser,
-                                 scc_ast_type_t **delay_pointee_ptr);
+                                 scc_ast_qual_type_t *base,
-
+                                 scc_ast_qual_type_t **delay_pointee_ptr);
-static inline scc_ast_type_t *ast_type_alloc() {
-    scc_ast_type_t *ast_type = scc_malloc(sizeof(scc_ast_type_t));
-    ast_type->base.type = SCC_AST_UNKNOWN;
-    if (ast_type == nullptr) {
-        LOG_FATAL("Out of memory");
-    }
-    return ast_type;
-}
 
 /**
  * @brief 判断 token 是否为声明说明符的开始
@@ -306,6 +299,7 @@ cbool scc_parse_is_storage_class_start(scc_parser_t *parser) {
             goto duplicate_error;                                              \
         expr = true;                                                           \
     } while (0)
+
 static scc_ast_decl_specifier_t
 parse_type_qualifier_list(scc_parser_t *parser,
                           scc_ast_decl_specifier_t quals) {
@@ -407,7 +401,7 @@ typedef struct {
     cbool is_unsigned; // 显式 unsigned
 
     // 以下用于 struct/union/enum/typedef-name
-    scc_ast_type_t *user_type; // 如果是用户定义类型，直接存储解析结果
+    scc_ast_qual_type_t *user_type; // 如果是用户定义类型，直接存储解析结果
 } type_spec_info_t;
 
 static cbool check_type_combinations(scc_parser_t *parser,
@@ -467,7 +461,8 @@ static cbool check_type_combinations(scc_parser_t *parser,
     }
     return true;
 }
-static scc_ast_type_t *build_type_from_info(type_spec_info_t *info,
+static scc_ast_qual_type_t *build_type_from_info(scc_parser_t *parser,
+                                                 type_spec_info_t *info,
                                                  scc_pos_t pos) {
     // 如果有用户定义类型，直接返回（注意可能需要复制或共享）
     if (info->user_type) {
@@ -531,13 +526,86 @@ static scc_ast_type_t *build_type_from_info(type_spec_info_t *info,
         }
     }
 
-    scc_ast_type_t *type = ast_type_alloc();
+    scc_ast_ctx_get_builtin_type(parser->ast_ctx, builtin);
-    scc_ast_type_builtin_init(type, builtin, pos);
+    scc_ast_qual_type_t *type = SCC_AST_ALLOC_QUAL_TYPE(parser->ast_ctx);
-    // 注意：限定符（const, volatile）不应在此处处理，应由上层函数负责
+    scc_ast_type_builtin_init(type, parser->ast_ctx, builtin, pos);
     return type;
 }
-static scc_ast_type_t *parse_record_type(scc_parser_t *parser,
+
+static scc_ast_qual_type_t *parse_record_type(scc_parser_t *parser,
+                                              scc_pos_t *pos,
                                               scc_ast_node_kind_t type_kind) {
+    scc_lexer_tok_t tok;
+    // skip 'struct' or 'union' or 'enum'
+    scc_parser_next_consume(parser, &tok);
+    *pos = tok.loc;
+    scc_lexer_tok_drop(&tok);
+
+    const scc_lexer_tok_t *tok_ptr = scc_parser_peek(parser);
+    if (tok_ptr == nullptr) {
+        SCC_ERROR(scc_parser_got_current_pos(parser), "Unexpected EOF");
+        return nullptr;
+    }
+    const char *name = nullptr;
+
+    if (tok_ptr->type == SCC_TOK_IDENT) {
+        scc_parser_next_consume(parser, &tok);
+        tok_ptr = scc_parser_peek(parser);
+        name = scc_str_as_cstr(&tok.lexeme);
+    } else if (tok_ptr->type != SCC_TOK_L_BRACE) {
+        SCC_ERROR(scc_parser_got_current_pos(parser),
+                  "Expected name in struct/union/enum specifier");
+        return nullptr;
+    }
+
+    scc_str_t symbol_name;
+    switch (type_kind) {
+    case SCC_AST_TYPE_ENUM:
+        symbol_name = scc_str_from_cstr("$E_");
+        break;
+    case SCC_AST_TYPE_STRUCT:
+        symbol_name = scc_str_from_cstr("$S_");
+        break;
+    case SCC_AST_TYPE_UNION:
+        symbol_name = scc_str_from_cstr("$U_");
+        break;
+    default:
+        UNREACHABLE();
+        break;
+    }
+    const scc_ast_qual_type_t *type = nullptr;
+    if (name == nullptr) {
+        scc_ast_canon_type_t *canon = scc_ast_ctx_alloc_type(parser->ast_ctx);
+        scc_ast_decl_t *decl = SCC_AST_ALLOC_DECL(parser->ast_ctx);
+        _scc_ast_decl_record_init(decl, type_kind, name, nullptr, *pos);
+
+        const scc_ast_qual_type_t *type =
+            SCC_AST_ALLOC_QUAL_TYPE(parser->ast_ctx);
+        _scc_ast_type_record_init(type, canon, type_kind, name, decl, *pos);
+        return type;
+    }
+    scc_str_append_cstr(&symbol_name, name, scc_strlen(name));
+
+    type = scc_parse_got_type(parser, scc_str_as_cstr(&symbol_name));
+    if (type == nullptr) {
+        scc_ast_canon_type_t *canon = scc_ast_ctx_alloc_type(parser->ast_ctx);
+        scc_ast_decl_t *decl = SCC_AST_ALLOC_DECL(parser->ast_ctx);
+        _scc_ast_decl_record_init(decl, type_kind, name, nullptr, *pos);
+
+        const scc_ast_qual_type_t *qual_type =
+            SCC_AST_ALLOC_QUAL_TYPE(parser->ast_ctx);
+        _scc_ast_type_record_init(qual_type, canon, type_kind, name, decl,
+                                  *pos);
+        scc_parse_type_sema(parser, qual_type);
+        type = scc_parse_got_type(parser, scc_str_as_cstr(&symbol_name));
+        Assert(type == qual_type);
+    }
+    Assert(type != nullptr);
+    return type;
+}
+
+static scc_ast_qual_type_t *
+parse_struct_union_type(scc_parser_t *parser, scc_ast_node_kind_t type_kind) {
     /*
     (6.7.2.1)
         struct-or-union-specifier:
@@ -568,27 +636,15 @@ static scc_ast_type_t *parse_record_type(scc_parser_t *parser,
             declarator(opt) : constant-expression
     */
     // FIXME check struct/union
-    scc_lexer_tok_t tok;
+    scc_lexer_tok_t tok = {0};
-    scc_parser_next_consume(parser, &tok);
+    scc_pos_t pos = scc_pos_create();
-    scc_pos_t pos = tok.loc;
+
-    scc_lexer_tok_drop(&tok);
+    scc_ast_qual_type_t *type = parse_record_type(parser, &pos, type_kind);
+    Assert(type != nullptr);
+    scc_ast_decl_t *decl = type->type->record.decl;
+    Assert(decl != nullptr);
 
     const scc_lexer_tok_t *tok_ptr = scc_parser_peek(parser);
-    if (tok_ptr == nullptr) {
-        SCC_ERROR(scc_parser_got_current_pos(parser), "Unexpected EOF");
-        return nullptr;
-    }
-    const char *name = nullptr;
-    scc_ast_decl_t *decl = nullptr;
-    scc_ast_decl_vec_t member;
-    scc_vec_init(member);
-
-    if (tok_ptr->type == SCC_TOK_IDENT) {
-        scc_parser_next_consume(parser, &tok);
-        name = scc_str_as_cstr(&tok.lexeme);
-        tok_ptr = scc_parser_peek(parser);
-    }
-
     if (tok_ptr && tok_ptr->type == SCC_TOK_L_BRACE) {
         scc_parser_next_consume(parser, nullptr);
         while (1) {
@@ -599,11 +655,13 @@ static scc_ast_type_t *parse_record_type(scc_parser_t *parser,
                 break;
             }
 
-            scc_ast_type_t *type = scc_parse_declaration_specifiers(parser);
+            scc_ast_qual_type_t *new_type =
-            if (type != nullptr) {
+                scc_parse_declaration_specifiers(parser);
-                decl = scc_parse_declarator(parser, type);
+            if (new_type != nullptr) {
-                if (decl != nullptr) {
+                scc_ast_decl_t *new_decl =
-                    scc_vec_push(member, decl);
+                    scc_parse_declarator(parser, new_type);
+                if (new_decl != nullptr) {
+                    scc_vec_push(decl->record.fields, new_decl);
                     continue;
                 }
             }
@@ -621,30 +679,12 @@ static scc_ast_type_t *parse_record_type(scc_parser_t *parser,
                 break;
             }
         }
-
-        decl = scc_malloc(sizeof(scc_ast_decl_t));
-        Assert(decl != nullptr);
-        if (type_kind == SCC_AST_TYPE_STRUCT) {
-            scc_ast_decl_struct_init(decl, name, &member, pos);
-        } else {
-            scc_ast_decl_union_init(decl, name, &member, pos);
-        }
-        scc_parse_decl_sema(parser, decl);
-    } else {
-        if (name == nullptr) {
-            SCC_ERROR(scc_parser_got_current_pos(parser),
-                      "Expected name in struct/union specifier");
-            // FIXME memory leak
-            return nullptr;
-        }
     }
 
-    scc_ast_type_t *type = ast_type_alloc();
-    _scc_ast_type_record_init(type, type_kind, name, decl, pos);
     return type;
 }
 
-static scc_ast_type_t *parse_enum_type(scc_parser_t *parser) {
+static scc_ast_qual_type_t *parse_enum_type(scc_parser_t *parser) {
     /*
     (6.7.2.2)
         enum-specifier:
@@ -661,31 +701,15 @@ static scc_ast_type_t *parse_enum_type(scc_parser_t *parser) {
             enumeration-constant = constant-expression
     */
     scc_lexer_tok_t tok;
-    scc_parser_next_consume(parser, &tok);
+    scc_pos_t pos = scc_pos_create();
-    scc_pos_t pos = tok.loc;
+
-    if (tok.type != SCC_TOK_ENUM) {
+    scc_ast_qual_type_t *type =
-        SCC_ERROR(scc_parser_got_current_pos(parser), "Expected 'enum'");
+        parse_record_type(parser, &pos, SCC_AST_TYPE_ENUM);
-        return nullptr;
+    Assert(type != nullptr);
-    }
+    scc_ast_decl_t *decl = type->type->record.decl;
-    scc_lexer_tok_drop(&tok);
+    Assert(decl != nullptr);
 
     const scc_lexer_tok_t *tok_ptr = scc_parser_peek(parser);
-    if (tok_ptr == nullptr) {
-        SCC_ERROR(scc_parser_got_current_pos(parser), "Unexpected EOF");
-        return nullptr;
-    }
-    scc_ast_type_t *type = ast_type_alloc();
-    const char *name = nullptr;
-    scc_ast_decl_t *decl = nullptr;
-    scc_ast_decl_vec_t member;
-    scc_vec_init(member);
-
-    if (tok_ptr->type == SCC_TOK_IDENT) {
-        scc_parser_next_consume(parser, &tok);
-        tok_ptr = scc_parser_peek(parser);
-        name = scc_str_as_cstr(&tok.lexeme);
-    }
-
     if (tok_ptr && tok_ptr->type == SCC_TOK_L_BRACE) {
         scc_parser_next_consume(parser, nullptr);
         while (1) {
@@ -708,12 +732,13 @@ static scc_ast_type_t *parse_enum_type(scc_parser_t *parser) {
                 enum_item_init = scc_parser_constant_expression(parser);
             }
 
-            scc_ast_decl_t *enum_item_decl = scc_malloc(sizeof(scc_ast_decl_t));
+            scc_ast_decl_t *enum_item_decl =
+                SCC_AST_ALLOC_DECL(parser->ast_ctx);
             Assert(enum_item_decl != nullptr);
             scc_ast_decl_val_init(enum_item_decl, type,
                                   scc_str_as_cstr(&tok.lexeme), enum_item_init,
                                   tok.loc);
-            scc_vec_push(member, enum_item_decl);
+            scc_vec_push(decl->record.fields, enum_item_decl);
 
             tok_ptr = scc_parser_peek(parser);
 
@@ -738,24 +763,17 @@ static scc_ast_type_t *parse_enum_type(scc_parser_t *parser) {
                 break;
             }
         }
-        decl = scc_malloc(sizeof(scc_ast_decl_t));
-        Assert(decl != nullptr);
-        scc_ast_decl_enum_init(decl, name, &member, pos);
-        scc_parse_decl_sema(parser, decl);
-    } else {
-        if (name == nullptr) {
-            SCC_ERROR(scc_parser_got_current_pos(parser),
-                      "Expected name in enum specifier");
-            // FIXME memory leak
-            return nullptr;
-        }
     }
 
-    scc_ast_type_enum_init(type, name, decl, pos);
+    scc_vec_foreach(decl->record.fields, i) {
+        scc_ast_decl_t *enum_decl = scc_vec_at(decl->record.fields, i);
+        scc_parse_decl_sema(parser, enum_decl);
+    }
+
     return type;
 }
 
-static scc_ast_type_t *parse_type_specifier(scc_parser_t *parser) {
+static scc_ast_qual_type_t *parse_type_specifier(scc_parser_t *parser) {
     type_spec_info_t info = {0};
     if (!scc_parse_is_type_specifier_start(parser))
         return nullptr;
@@ -769,7 +787,7 @@ static scc_ast_type_t *parse_type_specifier(scc_parser_t *parser) {
     switch (tok_ptr->type) {
     case SCC_TOK_STRUCT:
     case SCC_TOK_UNION:
-        info.user_type = parse_record_type(
+        info.user_type = parse_struct_union_type(
             parser, tok_ptr->type == SCC_TOK_STRUCT ? SCC_AST_TYPE_STRUCT
                                                     : SCC_AST_TYPE_UNION);
         goto done;
@@ -886,15 +904,15 @@ done:
     if (!check_type_combinations(parser, &info)) {
         return nullptr;
     }
-    return build_type_from_info(&info, pos);
+    return build_type_from_info(parser, &info, pos);
 duplicate_error:
     SCC_ERROR(scc_parser_got_current_pos(parser), "Duplicate type specifier");
     return nullptr;
 }
 
-static scc_ast_type_t *parse_pointer(scc_parser_t *parser,
+static scc_ast_qual_type_t *
-                                     scc_ast_type_t *pointee,
+parse_pointer(scc_parser_t *parser, scc_ast_qual_type_t *pointee,
-                                     scc_ast_type_t **delay_pointee_ptr) {
+              scc_ast_qual_type_t **delay_pointee_ptr) {
     /*
     pointer:
         * type-qualifier-list(opt)
@@ -907,13 +925,15 @@ static scc_ast_type_t *parse_pointer(scc_parser_t *parser,
     scc_pos_t pos = tok_ptr->loc;
     scc_parser_next_consume(parser, nullptr);
 
-    scc_ast_type_t *pointer = ast_type_alloc();
+    scc_ast_qual_type_t *pointer = SCC_AST_ALLOC_QUAL_TYPE(parser->ast_ctx);
     if (pointee == nullptr) {
         Assert(delay_pointee_ptr != nullptr);
         *delay_pointee_ptr = pointer;
         pointee = pointer;
     }
-    scc_ast_type_pointer_init(pointer, pointee, pos);
+
+    scc_ast_canon_type_t *canon = scc_ast_ctx_alloc_type(parser->ast_ctx);
+    scc_ast_type_pointer_init(pointer, canon, pointee, pos);
     pointer->quals = parse_type_qualifier_list(parser, pointer->quals);
 
     return parse_pointer(parser, pointer, delay_pointee_ptr);
@@ -937,7 +957,7 @@ static void parse_parameter_type_list(scc_parser_t *parser,
     const scc_lexer_tok_t *tok_ptr = nullptr;
     while (1) {
         // FIXME
-        scc_ast_type_t *type = scc_parse_declaration_specifiers(parser);
+        scc_ast_qual_type_t *type = scc_parse_declaration_specifiers(parser);
         if (type == nullptr) {
             break;
         }
@@ -947,7 +967,7 @@ static void parse_parameter_type_list(scc_parser_t *parser,
         }
 
         // TODO Check validation
-        param = scc_malloc(sizeof(scc_ast_decl_t));
+        param = SCC_AST_ALLOC_DECL(parser->ast_ctx);
         Assert(param != nullptr);
         scc_ast_decl_param_init(param, decl->var.type, decl->name,
                                 scc_vec_size(*params), decl->base.loc);
@@ -964,12 +984,12 @@ static void parse_parameter_type_list(scc_parser_t *parser,
         scc_parser_next_consume(parser, nullptr);
         tok_ptr = scc_parser_peek(parser);
         if (tok_ptr->type == SCC_TOK_ELLIPSIS) {
-            param = scc_malloc(sizeof(scc_ast_decl_t));
+            param = SCC_AST_ALLOC_DECL(parser->ast_ctx);
             Assert(param != nullptr);
             // FIXME
-            type = scc_malloc(sizeof(scc_ast_type_t));
+            type = SCC_AST_ALLOC_QUAL_TYPE(parser->ast_ctx);
-            Assert(type != nullptr);
+            scc_ast_type_builtin_init(type, parser->ast_ctx,
-            scc_ast_type_builtin_init(type, SCC_AST_BUILTIN_TYPE_VA_LIST,
+                                      SCC_AST_BUILTIN_TYPE_VA_LIST,
                                       tok_ptr->loc);
             scc_ast_decl_param_init(param, type, nullptr, scc_vec_size(*params),
                                     tok_ptr->loc);
@@ -1048,9 +1068,9 @@ static scc_ast_expr_t *parse_array_size_type(scc_parser_t *parser) {
     return size;
 }
 
-static scc_ast_type_t *parse_declarator(scc_parser_t *parser,
+static scc_ast_qual_type_t *
-                                        scc_ast_type_t *base,
+parse_declarator(scc_parser_t *parser, scc_ast_qual_type_t *base,
-                                        scc_ast_type_t **delay_pointee_ptr,
+                 scc_ast_qual_type_t **delay_pointee_ptr,
                  scc_lexer_tok_t *tok_ident) {
     /*
     (6.7.5) declarator:
@@ -1068,16 +1088,17 @@ static scc_ast_type_t *parse_declarator(scc_parser_t *parser,
         direct-declarator ( parameter-type-list )
         direct-declarator ( identifier-list(opt) )
     */
-    scc_ast_type_t *ret = parse_pointer(parser, base, delay_pointee_ptr);
+    scc_ast_qual_type_t *ret = parse_pointer(parser, base, delay_pointee_ptr);
     return parse_direct_declarator(parser, ret, delay_pointee_ptr, tok_ident);
 }
 
-static scc_ast_type_t *
+static scc_ast_qual_type_t *
-parse_direct_declarator(scc_parser_t *parser, scc_ast_type_t *base,
+parse_direct_declarator(scc_parser_t *parser, scc_ast_qual_type_t *base,
-                        scc_ast_type_t **delay_pointee_ptr,
+                        scc_ast_qual_type_t **delay_pointee_ptr,
                         scc_lexer_tok_t *tok_ident) {
     const scc_lexer_tok_t *tok_ptr = nullptr;
-    scc_ast_type_t *ret = nullptr;
+    scc_ast_qual_type_t *ret = nullptr;
+    scc_ast_canon_type_t *canon = scc_ast_ctx_alloc_type(parser->ast_ctx);
     // direct-abstract-declarator
     tok_ptr = scc_parser_peek(parser);
     if (tok_ptr == nullptr) {
@@ -1098,13 +1119,14 @@ parse_direct_declarator(scc_parser_t *parser, scc_ast_type_t *base,
     } else if (tok_ptr->type == SCC_TOK_L_PAREN) {
         // () SCC_TOK_L_PAREN
         scc_parser_next_consume(parser, nullptr);
-        scc_ast_type_t *delay_pointee = nullptr;
+        scc_ast_qual_type_t *delay_pointee = nullptr;
         if (parse_function_parameters_start(parser)) {
             scc_ast_decl_vec_t params;
             parse_function_parameters(parser, &params);
-            ret = ast_type_alloc();
+            ret = SCC_AST_ALLOC_QUAL_TYPE(parser->ast_ctx);
             // FIXME
-            scc_ast_type_function_init(ret, base, &params, base->base.loc);
+            scc_ast_type_function_init(ret, canon, base, &params,
+                                       base->base.loc);
             return parse_direct_declarator(parser, ret, delay_pointee_ptr,
                                            tok_ident);
         } else {
@@ -1118,28 +1140,28 @@ parse_direct_declarator(scc_parser_t *parser, scc_ast_type_t *base,
             }
             base = parse_direct_declarator(parser, base, delay_pointee_ptr,
                                            tok_ident);
-            Assert(SCC_AST_IS_A(scc_ast_type_t, base));
+            Assert(SCC_AST_IS_A(scc_ast_qual_type_t, base));
             Assert(delay_pointee != nullptr);
-            delay_pointee->pointer.pointee = base;
+            scc_ast_mut_canon_type(delay_pointee)->pointer.pointee = base;
             return ret;
         }
     } else if (tok_ptr->type == SCC_TOK_L_BRACKET) {
         // [] SCC_TOK_L_BRACKET
         scc_ast_expr_t *size = parse_array_size_type(parser);
-        scc_ast_type_t *ret = ast_type_alloc();
+        scc_ast_qual_type_t *ret = SCC_AST_ALLOC_QUAL_TYPE(parser->ast_ctx);
         base =
             parse_direct_declarator(parser, base, delay_pointee_ptr, tok_ident);
         // FIXME
-        scc_ast_type_array_init(ret, base, size, base->base.loc);
+        scc_ast_type_array_init(ret, canon, base, size, base->base.loc);
         return ret;
     } else {
         return base;
     }
 }
 
-static scc_ast_type_t *
+static scc_ast_qual_type_t *
-parse_abstract_declarator(scc_parser_t *parser, scc_ast_type_t *base,
+parse_abstract_declarator(scc_parser_t *parser, scc_ast_qual_type_t *base,
-                          scc_ast_type_t **delay_pointee_ptr) {
+                          scc_ast_qual_type_t **delay_pointee_ptr) {
     /*
     (6.7.6) abstract-declarator:
         pointer
@@ -1155,16 +1177,18 @@ parse_abstract_declarator(scc_parser_t *parser, scc_ast_type_t *base,
         direct-abstract-declarator(opt) [ * ]
         direct-abstract-declarator(opt) ( parameter-type-list(opt) )
     */
-    scc_ast_type_t *ret = parse_pointer(parser, base, delay_pointee_ptr);
+    scc_ast_qual_type_t *ret = parse_pointer(parser, base, delay_pointee_ptr);
     ret = parse_direct_abstract_declarator(parser, ret, delay_pointee_ptr);
     return ret;
 }
 
-static scc_ast_type_t *
+static scc_ast_qual_type_t *
-parse_direct_abstract_declarator(scc_parser_t *parser, scc_ast_type_t *base,
+parse_direct_abstract_declarator(scc_parser_t *parser,
-                                 scc_ast_type_t **delay_pointee_ptr) {
+                                 scc_ast_qual_type_t *base,
+                                 scc_ast_qual_type_t **delay_pointee_ptr) {
     const scc_lexer_tok_t *tok_ptr = nullptr;
-    scc_ast_type_t *ret = nullptr;
+    scc_ast_qual_type_t *ret = nullptr;
+    scc_ast_canon_type_t *canon = scc_ast_ctx_alloc_type(parser->ast_ctx);
     // direct-abstract-declarator
     tok_ptr = scc_parser_peek(parser);
     if (tok_ptr == nullptr) {
@@ -1174,13 +1198,14 @@ parse_direct_abstract_declarator(scc_parser_t *parser, scc_ast_type_t *base,
     if (tok_ptr->type == SCC_TOK_L_PAREN) {
         // () SCC_TOK_L_PAREN
         scc_parser_next_consume(parser, nullptr);
-        scc_ast_type_t *delay_pointee = nullptr;
+        scc_ast_qual_type_t *delay_pointee = nullptr;
         if (parse_function_parameters_start(parser)) {
             scc_ast_decl_vec_t params;
             parse_function_parameters(parser, &params);
-            ret = ast_type_alloc();
+            ret = SCC_AST_ALLOC_QUAL_TYPE(parser->ast_ctx);
             // FIXME
-            scc_ast_type_function_init(ret, base, &params, base->base.loc);
+            scc_ast_type_function_init(ret, canon, base, &params,
+                                       base->base.loc);
             return parse_direct_abstract_declarator(parser, ret,
                                                     delay_pointee_ptr);
         } else {
@@ -1192,17 +1217,17 @@ parse_direct_abstract_declarator(scc_parser_t *parser, scc_ast_type_t *base,
             base = parse_direct_abstract_declarator(parser, base,
                                                     delay_pointee_ptr);
             Assert(delay_pointee != nullptr);
-            delay_pointee->pointer.pointee = base;
+            scc_ast_mut_canon_type(delay_pointee)->pointer.pointee = base;
         }
         return ret;
     } else if (tok_ptr->type == SCC_TOK_L_BRACKET) {
         // [] SCC_TOK_L_BRACKET
         scc_ast_expr_t *size = parse_array_size_type(parser);
-        scc_ast_type_t *ret = ast_type_alloc();
+        scc_ast_qual_type_t *ret = SCC_AST_ALLOC_QUAL_TYPE(parser->ast_ctx);
         base =
             parse_direct_abstract_declarator(parser, base, delay_pointee_ptr);
         // FIXME
-        scc_ast_type_array_init(ret, base, size, base->base.loc);
+        scc_ast_type_array_init(ret, canon, base, size, base->base.loc);
         return ret;
     } else {
         return base;
@@ -1210,12 +1235,12 @@ parse_direct_abstract_declarator(scc_parser_t *parser, scc_ast_type_t *base,
 }
 
 scc_ast_decl_t *scc_parse_declarator(scc_parser_t *parser,
-                                     scc_ast_type_t *type) {
+                                     scc_ast_qual_type_t *type) {
     scc_lexer_tok_t decl_name_tok = {0};
-    scc_ast_type_t *decl_type =
+    scc_ast_qual_type_t *decl_type =
         parse_declarator(parser, type, nullptr, &decl_name_tok);
     scc_ast_decl_t *decl = nullptr;
-    decl = scc_malloc(sizeof(scc_ast_decl_t));
+    decl = SCC_AST_ALLOC_DECL(parser->ast_ctx);
     Assert(decl != nullptr);
     Assert(decl_name_tok.type == SCC_TOK_IDENT ||
            decl_name_tok.type == SCC_TOK_UNKNOWN);
@@ -1240,36 +1265,39 @@ scc_ast_decl_t *scc_parse_declarator(scc_parser_t *parser,
     }
 
     if (decl_name_tok.type != SCC_TOK_IDENT) {
-        if (decl_type->base.type == SCC_AST_TYPE_STRUCT ||
+        // TODO();
-            decl_type->base.type == SCC_AST_TYPE_UNION ||
+        // if (decl_type->base.type == SCC_AST_TYPE_STRUCT ||
-            decl_type->base.type == SCC_AST_TYPE_ENUM) {
+        //     decl_type->base.type == SCC_AST_TYPE_UNION ||
-            if (decl_type->record.decl == nullptr) {
+        //     decl_type->base.type == SCC_AST_TYPE_ENUM) {
-                decl = scc_malloc(sizeof(scc_ast_decl_t));
+        //     if (scc_ast_canon_type(decl_type)->record.decl == nullptr) {
-                Assert(decl != nullptr);
+        //         decl = SCC_AST_ALLOC_DECL(parser->ast_ctx);
-                if (decl_type->base.type == SCC_AST_TYPE_STRUCT) {
+        //         Assert(decl != nullptr);
-                    scc_ast_decl_struct_init(decl, decl_type->record.name,
+        //         if (decl_type->base.type == SCC_AST_TYPE_STRUCT) {
-                                             nullptr, decl_type->base.loc);
+        //             scc_ast_decl_struct_init(
-                } else if (decl_type->base.type == SCC_AST_TYPE_UNION) {
+        //                 decl, scc_ast_canon_type(decl_type)->record.name,
-                    scc_ast_decl_union_init(decl, decl_type->record.name,
+        //                 nullptr, decl_type->base.loc);
-                                            nullptr, decl_type->base.loc);
+        //         } else if (decl_type->base.type == SCC_AST_TYPE_UNION) {
-                } else {
+        //             scc_ast_decl_union_init(
-                    scc_ast_decl_enum_init(decl, type->record.name, nullptr,
+        //                 decl, scc_ast_canon_type(decl_type)->record.name,
-                                           decl_type->base.loc);
+        //                 nullptr, decl_type->base.loc);
-                }
+        //         } else {
-            } else {
+        //             scc_ast_decl_enum_init(
-                decl = decl_type->record.decl;
+        //                 decl, scc_ast_canon_type(decl_type)->record.name,
-                scc_free(decl_type); // FIXME
+        //                 nullptr, decl_type->base.loc);
-            }
+        //         }
-        } else {
+        //     } else {
-            decl = scc_malloc(sizeof(scc_ast_decl_t));
+        //         decl = scc_ast_canon_type(decl_type)->record.decl;
-            scc_ast_decl_unsafe_val_init(decl, type, nullptr, nullptr,
+        //     }
-                                         decl_type->base.loc);
+        // } else {
-        }
+        //     decl = SCC_AST_ALLOC_DECL(parser->ast_ctx);
+        //     scc_ast_decl_unsafe_val_init(decl, type, nullptr, nullptr,
+        //                                  decl_type->base.loc);
+        // }
     }
     return decl;
 }
 
-scc_ast_type_t *scc_parse_declaration_specifiers(scc_parser_t *parser) {
+scc_ast_qual_type_t *scc_parse_declaration_specifiers(scc_parser_t *parser) {
     if (!scc_parse_is_decl_specifier_start(parser)) {
         return nullptr;
     }
@@ -1280,7 +1308,7 @@ scc_ast_type_t *scc_parse_declaration_specifiers(scc_parser_t *parser) {
     }
 
     spec = parse_declaration_specifiers_list(parser, spec);
-    scc_ast_type_t *specifier = parse_type_specifier(parser);
+    scc_ast_qual_type_t *specifier = parse_type_specifier(parser);
     if (specifier == nullptr) {
         SCC_ERROR(scc_parser_got_current_pos(parser),
                   "declaration specifier can't have type specifier");
@@ -1291,13 +1319,13 @@ scc_ast_type_t *scc_parse_declaration_specifiers(scc_parser_t *parser) {
     return specifier;
 }
 
-scc_ast_type_t *scc_parse_type_name(scc_parser_t *parser) {
+scc_ast_qual_type_t *scc_parse_type_name(scc_parser_t *parser) {
     if (!(scc_parse_is_type_specifier_start(parser) ||
           scc_parse_is_type_qualifier_start(parser))) {
         return nullptr;
     }
 
-    scc_ast_type_t *ret = nullptr;
+    scc_ast_qual_type_t *ret = nullptr;
     scc_ast_decl_specifier_t spec = {0};
     spec = parse_type_qualifier_list(parser, spec);
     ret = parse_type_specifier(parser);

libs/parser/src/scc_parser.c

@@ -9,7 +9,7 @@ static void dummy_sema_callback(void *context, scc_ast_node_kind_t node_type,
     return;
 }
 
-static scc_ast_type_t *dummy_got_type_callback(void *context,
+static const scc_ast_qual_type_t *dummy_got_type_callback(void *context,
                                                           const char *name) {
     (void)context;
     (void)name;
@@ -20,8 +20,11 @@ static scc_ast_type_t *dummy_got_type_callback(void *context,
     assigned_val = value ? value : default
 
 void scc_parser_init(scc_parser_t *parser, scc_lexer_tok_ring_t *tok_ring,
-                     scc_sema_callbacks_t *callbacks) {
+                     scc_ast_ctx_t *ast_ctx, scc_sema_ctx_t *callbacks) {
     Assert(parser != nullptr && tok_ring != nullptr);
+    Assert(ast_ctx != nullptr);
+    parser->ast_ctx = ast_ctx;
+
     parser->ring = tok_ring;
     parser->errcode = 0;
     parser->translation_unit = nullptr;

libs/parser/src/scc_sema.c

@@ -1,13 +1,59 @@
+#include <scc_ast_utils.h>
 #include <scc_pos_log.h>
 #include <scc_sema.h>
 #include <sema_symtab.h>
 
+static const scc_ast_qual_type_t *got_type_callback(void *context,
+                                                    const char *name);
+
+static void gen_symbol_name(const scc_ast_decl_t *decl, scc_str_t *name) {
+    switch (decl->base.type) {
+    case SCC_AST_TYPE_ENUM:
+        *name = scc_str_from_cstr("$E_");
+        scc_str_append_cstr(name, decl->name, scc_strlen(decl->name));
+        break;
+    case SCC_AST_TYPE_STRUCT:
+        *name = scc_str_from_cstr("$S_");
+        scc_str_append_cstr(name, decl->name, scc_strlen(decl->name));
+        break;
+    case SCC_AST_TYPE_UNION:
+        *name = scc_str_from_cstr("$U_");
+        scc_str_append_cstr(name, decl->name, scc_strlen(decl->name));
+        break;
+    default:
+        break;
+    }
+}
+
+static void symtab_add_symbol(scc_sema_symtab_t *sema_symtab,
+                              scc_ast_decl_t *decl,
+                              scc_ast_node_t *ast_node_ref) {
+
+    if (decl->name == nullptr)
+        return;
+    // FIXME memory leak
+    scc_str_t name = scc_str_empty();
+    gen_symbol_name(decl, &name);
+    if (scc_str_is_empty(&name)) {
+        scc_sema_symtab_add_symbol(sema_symtab, decl->name, ast_node_ref);
+    } else {
+        scc_sema_symtab_add_symbol(sema_symtab, scc_str_as_cstr(&name),
+                                   ast_node_ref);
+    }
+}
+
 static void type_callback(void *context, scc_ast_node_kind_t node_type,
                           void *node) {
     scc_sema_symtab_t *sema_symtab = context;
-    (void)context;
+    scc_ast_qual_type_t *type = SCC_AST_CAST_TO(scc_ast_qual_type_t, node);
-    (void)node_type;
+
-    (void)node;
+    if (node_type == SCC_AST_TYPE_STRUCT) {
+        symtab_add_symbol(sema_symtab, type->type->record.decl, &type->base);
+    } else if (node_type == SCC_AST_TYPE_UNION) {
+        symtab_add_symbol(sema_symtab, type->type->record.decl, &type->base);
+    } else if (node_type == SCC_AST_TYPE_ENUM) {
+        symtab_add_symbol(sema_symtab, type->type->record.decl, &type->base);
+    }
     return;
 }
 
@@ -71,119 +117,83 @@ static void decl_callback(void *context, scc_ast_node_kind_t node_type,
     }
     scc_ast_decl_t *decl = SCC_AST_CAST_TO(scc_ast_decl_t, node);
 
-    scc_ast_type_t *type = scc_malloc(sizeof(scc_ast_type_t));
+    if (node_type == SCC_AST_DECL_TYPEDEF) {
-    Assert(type != nullptr);
-
-    if (node_type == SCC_AST_DECL_STRUCT) {
-        scc_ast_type_struct_init(type, decl->name, decl, decl->base.loc);
-        // FIXME memory leak
-        scc_str_t name = scc_str_from_cstr("$S_");
-
-        if (decl->name == nullptr) {
-            decl->name = "<anonymous struct>";
-        }
-        scc_str_append_cstr(&name, decl->name, scc_strlen(decl->name));
-        scc_sema_symtab_add_symbol(sema_symtab, scc_str_as_cstr(&name),
-                                   &type->base);
-    } else if (node_type == SCC_AST_DECL_UNION) {
-        scc_ast_type_union_init(type, decl->name, decl, decl->base.loc);
-        scc_str_t name = scc_str_from_cstr("$U_");
-        if (decl->name == nullptr) {
-            decl->name = "<anonymous union>";
-        }
-        scc_str_append_cstr(&name, decl->name, scc_strlen(decl->name));
-        scc_sema_symtab_add_symbol(sema_symtab, scc_str_as_cstr(&name),
-                                   &type->base);
-    } else if (node_type == SCC_AST_DECL_ENUM) {
-        scc_ast_type_enum_init(type, decl->name, decl, decl->base.loc);
-        scc_str_t name = scc_str_from_cstr("$E_");
-        if (decl->name == nullptr) {
-            decl->name = "<anonymous enum>";
-        }
-        scc_str_append_cstr(&name, decl->name, scc_strlen(decl->name));
-        scc_sema_symtab_add_symbol(sema_symtab, scc_str_as_cstr(&name),
-                                   &type->base);
-
-        scc_vec_foreach(decl->record.fields, i) {
-            scc_ast_decl_t *enum_decl = scc_vec_at(decl->record.fields, i);
-            scc_sema_symtab_add_symbol(sema_symtab, enum_decl->name,
-                                       &enum_decl->base);
-            // LOG_INFO("enum added %s", enum_decl->name);
-        }
-    } else if (node_type == SCC_AST_DECL_TYPEDEF) {
         if (decl->name == nullptr) {
             SCC_ERROR(decl->base.loc, "typedef without name");
             return;
         }
-        scc_ast_type_typedef_init(type, decl->name, decl, decl->base.loc);
+        symtab_add_symbol(sema_symtab, decl, &decl->typedef_decl.type->base);
-        scc_sema_symtab_add_symbol(sema_symtab, decl->name, &type->base);
     } else if (node_type == SCC_AST_DECL_VAR) {
-        scc_sema_symtab_add_symbol(sema_symtab, decl->name, &decl->base);
+        symtab_add_symbol(sema_symtab, decl, &decl->base);
     } else if (node_type == SCC_AST_DECL_PARAM) {
         if (decl->name == nullptr) {
             if (decl->param.type->base.type == SCC_AST_TYPE_BUILTIN &&
-                (decl->param.type->builtin.type ==
+                (decl->param.type->type->builtin.type ==
                      SCC_AST_BUILTIN_TYPE_VA_LIST ||
-                 decl->param.type->builtin.type == SCC_AST_BUILTIN_TYPE_VOID)) {
+                 decl->param.type->type->builtin.type ==
+                     SCC_AST_BUILTIN_TYPE_VOID)) {
                 return;
             }
             SCC_ERROR(decl->base.loc, "sema error: Parameter must have a name");
             return;
         }
-        scc_sema_symtab_add_symbol(sema_symtab, decl->name, &decl->base);
+        symtab_add_symbol(sema_symtab, decl, &decl->base);
     } else if (node_type == SCC_AST_DECL_FUNC) {
         if (decl->name == nullptr) {
             SCC_ERROR(decl->base.loc, "sema error: Function must have a name");
         } else {
             // FIXME 重名函数...
-            scc_sema_symtab_add_symbol(sema_symtab, decl->name, &decl->base);
+            symtab_add_symbol(sema_symtab, decl, &decl->base);
         }
     }
     return;
 }
 
-static scc_ast_type_t *got_type_callback(void *context, const char *name) {
+static const scc_ast_qual_type_t *got_type_callback(void *context,
+                                                    const char *name) {
     scc_sema_symtab_t *sema_symtab = context;
     scc_ast_node_t *node = scc_sema_symtab_lookup_symbol(sema_symtab, name);
-    if (SCC_AST_IS_A(scc_ast_type_t, node)) {
+    if (SCC_AST_IS_A(scc_ast_qual_type_t, node)) {
-        scc_ast_type_t *type = scc_malloc(sizeof(scc_ast_type_t));
+        return (scc_ast_qual_type_t *)node;
-        *type = *(scc_ast_type_t *)node;
-        return type;
     }
     return nullptr;
 }
 
-void scc_sema_init(scc_sema_callbacks_t *callbacks) {
+void scc_sema_init(scc_sema_ctx_t *sema_ctx, scc_ast_ctx_t *ast_ctx) {
+    sema_ctx->ast_ctx = ast_ctx;
     scc_sema_symtab_t *sema_symtab = scc_malloc(sizeof(scc_sema_symtab_t));
     if (sema_symtab == nullptr) {
         LOG_FATAL("out of memory");
         return;
     }
-    callbacks->context = sema_symtab;
+    sema_ctx->context = sema_symtab;
-    callbacks->on_decl = decl_callback;
+    sema_ctx->on_decl = decl_callback;
-    callbacks->on_expr = expr_callback;
+    sema_ctx->on_expr = expr_callback;
-    callbacks->on_stmt = stmt_callback;
+    sema_ctx->on_stmt = stmt_callback;
-    callbacks->on_type = type_callback;
+    sema_ctx->on_type = type_callback;
-    callbacks->got_type = got_type_callback;
+    sema_ctx->got_type = got_type_callback;
 
     scc_sema_symtab_init(sema_symtab);
 
     // FIXME memory leak
-    scc_ast_type_t *type = scc_malloc(sizeof(scc_ast_type_t));
+
-    scc_ast_type_builtin_init(type, SCC_AST_BUILTIN_TYPE_VA_LIST,
+    scc_ast_qual_type_t *type = SCC_AST_ALLOC_QUAL_TYPE(sema_ctx->ast_ctx);
-                              scc_pos_create());
+    scc_ast_type_builtin_init(type, sema_ctx->ast_ctx,
+                              SCC_AST_BUILTIN_TYPE_VA_LIST, scc_pos_create());
     scc_sema_symtab_add_symbol(sema_symtab, "__scc_builtin_va_list",
                                &type->base);
 
-    scc_ast_decl_t *decl = scc_malloc(sizeof(scc_ast_decl_t));
+    scc_ast_decl_t *decl = SCC_AST_ALLOC_DECL(sema_ctx->ast_ctx);
     scc_ast_decl_val_init(decl, type, "__scc_builtin__", nullptr,
                           scc_pos_create());
     scc_sema_symtab_add_symbol(sema_symtab, "__func__", &decl->base);
 
-    scc_ast_type_t *built_func_type = scc_malloc(sizeof(scc_ast_type_t));
+    scc_ast_qual_type_t *built_func_type =
-    scc_ast_type_function_init(built_func_type, nullptr, nullptr,
+        SCC_AST_ALLOC_QUAL_TYPE(sema_ctx->ast_ctx);
-                               scc_pos_create());
+    // FIXME hack
-    scc_ast_decl_t *builin_func = scc_malloc(sizeof(scc_ast_decl_t));
+    built_func_type->base.type = SCC_AST_TYPE_FUNCTION;
+
+    scc_ast_decl_t *builin_func = SCC_AST_ALLOC_DECL(sema_ctx->ast_ctx);
     scc_ast_decl_func_init(builin_func, built_func_type, "__scc_builtin_func",
                            nullptr, scc_pos_create());
     scc_sema_symtab_add_symbol(sema_symtab, "__scc_builtin_va_start",
@@ -196,9 +206,9 @@ void scc_sema_init(scc_sema_callbacks_t *callbacks) {
                                &builin_func->base);
 }
 
-void scc_sema_drop(scc_sema_callbacks_t *callbacks) {
+void scc_sema_drop(scc_sema_ctx_t *sema_ctx) {
     // FIXME drop obj
-    if (callbacks->context) {
+    if (sema_ctx->context) {
-        scc_sema_symtab_drop(callbacks->context);
+        scc_sema_symtab_drop(sema_ctx->context);
     }
 }

src/main.c

@@ -184,9 +184,11 @@ int main(int argc, const char **argv, const char **envp) {
     scc_lexer_tok_ring_t *tok_ring =
         scc_pproc_to_ring(&pproc, 1024, false, false);
     scc_parser_t parser;
-    scc_sema_callbacks_t sema_callbacks;
+    scc_ast_ctx_t ast_ctx;
-    scc_sema_init(&sema_callbacks);
+    scc_ast_ctx_init(&ast_ctx);
-    scc_parser_init(&parser, tok_ring, &sema_callbacks);
+    scc_sema_ctx_t sema_callbacks;
+    scc_sema_init(&sema_callbacks, &ast_ctx);
+    scc_parser_init(&parser, tok_ring, &ast_ctx, &sema_callbacks);
     scc_ast_translation_unit_t *translation_unit =
         scc_parse_translation_unit(&parser);
 
@@ -221,7 +223,7 @@ sstream_drop:
     scc_hir_cprog_t cprog;
     scc_hir_cprog_init(&cprog);
     scc_ast2ir_ctx_init(&ast2ir_ctx, &scc_ast_abi_impl, &cprog);
-    scc_ast2ir_translation_unit(&ast2ir_ctx, translation_unit);
+    scc_ast2ir_run(&ast2ir_ctx, translation_unit);
     scc_ast2ir_ctx_drop(&ast2ir_ctx);
 
     if (config.emit_hir) {