stage1 更多的语义以及类型构造器

stage0/include/core_map.h

@@ -130,6 +130,56 @@ static inline usize map_hash_str(const char *s) {
         }                                                                                          \
     } while (0)
 
+/**
+ * 插入（仅当键不存在时），若键已存在则静默跳过，不更新值
+ * 与 map_put 的差异仅在"键已存在时"：map_put 更新值，map_put_new 放弃
+ */
+#define map_put_new(map, _key, _val)                                                               \
+    do {                                                                                           \
+        /* 扩容 */                                                                                 \
+        if ((map).cap == 0 || (map).size * 128 / (map).cap >= MAP_DEFAULT_LOAD_FACTOR) {           \
+            usize new_cap = (map).cap == 0 ? 8 : (map).cap * 2;                                    \
+            MAP_SLOT(MAP_TYPEOF((map).data->key), MAP_TYPEOF((map).data->val)) *new_data =         \
+                calloc(new_cap, sizeof(*new_data));                                                \
+            if (!new_data)                                                                         \
+                abort();                                                                           \
+            /* 重新插入旧元素 */                                                                   \
+            for (usize _i = 0; _i < (map).cap; ++_i) {                                             \
+                if ((map).data[_i].state == __MAP_SLOT_OCCUPIED) {                                 \
+                    usize _h = (map).hash((map).data[_i].key) & (new_cap - 1);                     \
+                    while (new_data[_h].state == __MAP_SLOT_OCCUPIED)                              \
+                        _h = (_h + 1) & (new_cap - 1);                                             \
+                    new_data[_h].key = (map).data[_i].key;                                         \
+                    new_data[_h].val = (map).data[_i].val;                                         \
+                    new_data[_h].state = __MAP_SLOT_OCCUPIED;                                      \
+                }                                                                                  \
+            }                                                                                      \
+            free((map).data);                                                                      \
+            (map).data = (void *)new_data;                                                         \
+            (map).cap = new_cap;                                                                   \
+        }                                                                                          \
+        /* 查找 */                                                                                 \
+        usize _mask = (map).cap - 1;                                                               \
+        usize _idx = (map).hash(_key) & _mask;                                                     \
+        usize _first_del = (usize) - 1;                                                            \
+        while ((map).data[_idx].state != __MAP_SLOT_EMPTY) {                                       \
+            if ((map).data[_idx].state == __MAP_SLOT_OCCUPIED &&                                   \
+                (map).cmp((map).data[_idx].key, _key) == 0) {                                      \
+                break; /* 已存在，不更新 */                                                         \
+            }                                                                                      \
+            if ((map).data[_idx].state == __MAP_SLOT_DELETED && _first_del == (usize) - 1)         \
+                _first_del = _idx;                                                                 \
+            _idx = (_idx + 1) & _mask;                                                             \
+        }                                                                                          \
+        if ((map).data[_idx].state == __MAP_SLOT_EMPTY) {                                          \
+            usize _target = (_first_del != (usize) - 1) ? _first_del : _idx;                       \
+            (map).data[_target].key = _key;                                                        \
+            (map).data[_target].val = _val;                                                        \
+            (map).data[_target].state = __MAP_SLOT_OCCUPIED;                                       \
+            ++(map).size;                                                                          \
+        }                                                                                          \
+    } while (0)
+
 /**
  * 查询：若找到，*out_val 被赋值为对应值并返回 1；否则返回 0
  */
@@ -152,6 +202,33 @@ static inline usize map_hash_str(const char *s) {
         _found;                                                                                    \
     }))
 
+/**
+ * 查询（续探）：首次调用前将 *in_out_idx 置为 (usize)-1，
+ * 则从键自身的 hash 桶开始查找；命中后 *out_val 被赋值、返回 1，
+ * 且 *in_out_idx 更新为命中槽位，下次调用从该槽的下一个继续探测（碰撞续探）。
+ * 扫描到空槽返回 0。用于 key 碰撞后需要回表二次比较的场景。
+ */
+#define map_get_continue(map, _key, out_val, in_out_idx)                                           \
+    (({                                                                                            \
+        int _found = 0;                                                                            \
+        if ((map).cap > 0) {                                                                       \
+            usize _mask = (map).cap - 1;                                                           \
+            usize _idx = (*(in_out_idx) == (usize) - 1) ? (map).hash(_key) & _mask                 \
+                                                        : (*(in_out_idx) + 1) & _mask;            \
+            while ((map).data[_idx].state != __MAP_SLOT_EMPTY) {                                   \
+                if ((map).data[_idx].state == __MAP_SLOT_OCCUPIED &&                               \
+                    (map).cmp((map).data[_idx].key, _key) == 0) {                                  \
+                    *out_val = (map).data[_idx].val;                                               \
+                    *(in_out_idx) = _idx;                                                          \
+                    _found = 1;                                                                    \
+                    break;                                                                         \
+                }                                                                                  \
+                _idx = (_idx + 1) & _mask;                                                         \
+            }                                                                                      \
+        }                                                                                          \
+        _found;                                                                                    \
+    }))
+
 /**
  * 删除指定键
  */

stage1/spl_ast.c

@@ -1848,9 +1848,10 @@ static void dump_node(spl_ast_t *ast, spl_ast_node_ref_t node_ref, dump_stack_t
 
     for (usize i = 0; i < vec_size(*stack); i++)
         printf("%s", vec_at(*stack, i) ? "  " : "| ");
-    printf("%s%s #%zu", last ? "`-" : "|-", spl_ast_kind_name(node->kind), node_ref);
+    printf("%s%s #%zu ID`%zu`", last ? "`-" : "|-", spl_ast_kind_name(node->kind), node_ref,
+           node->resolved_type_id);
     if (node->dbg.fname)
-        printf(" (%d:%d)", node->dbg.line, node->dbg.col);
+        printf(" [%d:%d]", node->dbg.line, node->dbg.col);
     printf("\n");
 
     vec_push(*stack, last);

stage1/spl_ast.h

@@ -155,7 +155,7 @@ struct spl_ast_node {
             spl_ast_node_ref_vec_t attr_list; /* attr_item */
             const char *name;
             spl_ast_node_ref_vec_t param_list; /* param_decl */
-            spl_ast_node_ref_t type_expr;
+            spl_ast_node_ref_t type_expr; /* ret type expr */
             spl_ast_node_ref_vec_t block; /* 语句/尾表达式 */
         } fn_decl;
         struct {

stage1/spl_ast2ir.c

@@ -58,7 +58,7 @@ static spl_ir_node_ref_t transit(spl_ir_builder_t *ir, const spl_sema_t *sema,
         if (n->ret_statement.expr) {
             ret = transit(ir, sema, n->ret_statement.expr);
         }
-        ret = spl_ir_builder_control_ret(ir, tid_from_def(sema, n->resolved_def_id), ret);
+        ret = spl_ir_builder_control_ret(ir, n->resolved_type_id, ret);
     } break;
     case SPL_AST_BREAK_STATEMENT:
     case SPL_AST_CONTINUE_STATEMENT:
@@ -111,8 +111,7 @@ static spl_ir_node_ref_t transit(spl_ir_builder_t *ir, const spl_sema_t *sema,
         TODO();
         break;
     case SPL_AST_EXPR_INTEGER_LIT: {
-        ret = spl_ir_builder_type_const_int(ir, tid_from_def(sema, n->resolved_def_id),
+        ret = spl_ir_builder_type_const_int(ir, n->resolved_type_id, n->primary_expr.integer_expr);
-                                            n->primary_expr.integer_expr);
         break;
     }
     case SPL_AST_EXPR_FLOAT_LIT:

stage1/spl_sema.h

@@ -43,6 +43,8 @@ typedef struct {
     spl_scope_t *scope;
     spl_symbol_t root;
     int error_count;
+    spl_scope_id_t store_scope;
+    spl_type_id_t current_fn_ret_tid; // TODO
 } spl_sema_t;
 
 void spl_sema_init(spl_sema_t *sema, spl_ast_t *ast, spl_type_t *type, spl_scope_t *scope);

stage1/spl_type.c

@@ -6,6 +6,8 @@ static usize spl_type_hash(spl_type_node_t n) {
     case SPL_TYPE_ERROR:
     case SPL_TYPE_VOID:
     case SPL_TYPE_BOOL:
+    case SPL_TYPE_UNDEFINED:
+    case SPL_TYPE_NULL:
         break;
     case SPL_TYPE_INT:
         hash += n.int_type.bits + n.int_type.is_signed;
@@ -27,15 +29,21 @@ static usize spl_type_hash(spl_type_node_t n) {
         break;
     case SPL_TYPE_STRUCT:
     case SPL_TYPE_UNION:
-        hash += n.layout.mode;
+        hash += n.layout.mode * 31 + n.layout.fixed_align_bits;
-        hash += n.layout.fixed_align_bits;
+        vec_for(n.agg_members, i) {
-        vec_for(n.agg_field_types, i) { hash += vec_at(n.agg_field_types, i); }
+            hash += (n.agg_members.data[i].name ? map_hash_str(n.agg_members.data[i].name) : 0) +
+                    n.agg_members.data[i].type_id;
+        }
         break;
     case SPL_TYPE_ENUM:
-        hash += n.layout.mode;
+        hash += n.layout.mode * 31 + n.layout.fixed_align_bits;
-        hash += n.layout.fixed_align_bits;
         hash += n.adt_type.tag_type;
-        vec_for(n.adt_type.variants, i) { hash += vec_at(n.adt_type.variants, i); }
+        vec_for(n.adt_type.variants, i) {
+            hash +=
+                (n.adt_type.variants.data[i].name ? map_hash_str(n.adt_type.variants.data[i].name)
+                                                  : 0) +
+                n.adt_type.variants.data[i].type_id;
+        }
         break;
     case SPL_TYPE_FN:
         hash += n.fn_type.ret;
@@ -54,6 +62,8 @@ static int spl_type_eq(spl_type_node_t n1, spl_type_node_t n2) {
     case SPL_TYPE_ERROR:
     case SPL_TYPE_VOID:
     case SPL_TYPE_BOOL:
+    case SPL_TYPE_UNDEFINED:
+    case SPL_TYPE_NULL:
         break;
     case SPL_TYPE_INT:
         if (n1.int_type.bits != n2.int_type.bits)
@@ -88,10 +98,14 @@ static int spl_type_eq(spl_type_node_t n1, spl_type_node_t n2) {
         if (n1.layout.mode != n2.layout.mode ||
             n1.layout.fixed_align_bits != n2.layout.fixed_align_bits)
             return 1;
-        if (vec_size(n1.agg_field_types) != vec_size(n2.agg_field_types))
+        if (vec_size(n1.agg_members) != vec_size(n2.agg_members))
             return 1;
-        vec_for(n1.agg_field_types, i) {
+        vec_for(n1.agg_members, i) {
-            if (vec_at(n1.agg_field_types, i) != vec_at(n2.agg_field_types, i))
+            const char *na = n1.agg_members.data[i].name;
+            const char *nb = n2.agg_members.data[i].name;
+            if (strcmp(na ? na : "", nb ? nb : "") != 0)
+                return 1;
+            if (n1.agg_members.data[i].type_id != n2.agg_members.data[i].type_id)
                 return 1;
         }
         break;
@@ -104,7 +118,11 @@ static int spl_type_eq(spl_type_node_t n1, spl_type_node_t n2) {
         if (vec_size(n1.adt_type.variants) != vec_size(n2.adt_type.variants))
             return 1;
         vec_for(n1.adt_type.variants, i) {
-            if (vec_at(n1.adt_type.variants, i) != vec_at(n2.adt_type.variants, i))
+            const char *na = n1.adt_type.variants.data[i].name;
+            const char *nb = n2.adt_type.variants.data[i].name;
+            if (strcmp(na ? na : "", nb ? nb : "") != 0)
+                return 1;
+            if (n1.adt_type.variants.data[i].type_id != n2.adt_type.variants.data[i].type_id)
                 return 1;
         }
         break;
@@ -124,132 +142,215 @@ static int spl_type_eq(spl_type_node_t n1, spl_type_node_t n2) {
     return 0;
 }
 
-spl_type_id_t spl_type_node_push(spl_type_t *type, spl_type_node_t type_node) {
+static usize spl_type_map_hash(usize k) { return MAP_HASH_INT(k); }
-    spl_type_id_t ret = 0;
+
-    int ok = map_get(type->type_map, type_node, &ret);
+static int spl_type_map_cmp(usize a, usize b) { return MAP_CMP_INT(a, b); }
-    if (ok) {
+
-        return ret;
+static void spl_type_node_free_vecs(spl_type_node_t *tn) {
+    switch (tn->kind) {
+    case SPL_TYPE_STRUCT:
+    case SPL_TYPE_UNION:
+        vec_free(tn->agg_members);
+        break;
+    case SPL_TYPE_ENUM:
+        vec_free(tn->adt_type.variants);
+        break;
+    case SPL_TYPE_FN:
+        vec_free(tn->fn_type.params);
+        break;
+    default:
+        break;
     }
-    map_put(type->type_map, type_node, vec_size(type->type_table));
-    vec_push(type->type_table, type_node);
-    return vec_size(type->type_table) - 1;
 }
 
-spl_type_id_t spl_type_def_alloc(spl_type_t *type) {
+spl_type_id_t spl_type_node_push(spl_type_t *type, spl_type_node_t *tn) {
-    vec_push(type->def_table, (spl_def_node_t){0});
+    usize hash = spl_type_hash(*tn);
-    return vec_size(type->def_table) - 1;
+    usize idx = (usize)-1;
+    spl_type_id_t cand = 0;
+    while (map_get_continue(type->type_map, hash, &cand, &idx)) {
+        spl_type_node_t *existing = &vec_at(type->type_table, cand);
+        if (spl_type_eq(*existing, *tn) == 0) {
+            spl_type_node_free_vecs(tn);
+            return cand;
+        }
+    }
+    spl_type_id_t id = vec_size(type->type_table);
+    vec_push(type->type_table, *tn);
+    map_put_new(type->type_map, hash, id);
+    tn->kind = SPL_TYPE_ERROR;
+    return id;
 }
 
-spl_type_id_t spl_type_def_agg_build(spl_type_t *type, spl_def_id_t def, spl_type_node_kind_t tk,
+static const spl_type_member_t *spl_type_agg_member_find(spl_type_t *type, spl_type_id_t tid,
+                                                         const char *name, usize *out_idx) {
+    spl_type_node_t *n = spl_type_node(type, tid);
+    if (!n || !name) {
+        return NULL;
+    }
+    if (n->kind == SPL_TYPE_STRUCT || n->kind == SPL_TYPE_UNION) {
+        vec_for(n->agg_members, i) {
+            const char *mn = n->agg_members.data[i].name;
+            if (strcmp(mn ? mn : "", name) == 0) {
+                if (out_idx) {
+                    *out_idx = i;
+                }
+                return &n->agg_members.data[i];
+            }
+        }
+    } else if (n->kind == SPL_TYPE_ENUM) {
+        vec_for(n->adt_type.variants, i) {
+            const char *mn = n->adt_type.variants.data[i].name;
+            if (strcmp(mn ? mn : "", name) == 0) {
+                if (out_idx) {
+                    *out_idx = i;
+                }
+                return &n->adt_type.variants.data[i];
+            }
+        }
+    }
+    return NULL;
+}
+
+const spl_type_member_t *spl_type_agg_member(spl_type_t *type, spl_type_id_t tid,
+                                             const char *name) {
+    return spl_type_agg_member_find(type, tid, name, NULL);
+}
+
+bool spl_type_agg_member_idx(spl_type_t *type, spl_type_id_t tid, const char *name,
+                             usize *out_idx) {
+    return spl_type_agg_member_find(type, tid, name, out_idx) != NULL;
+}
+
+spl_type_id_t spl_type_builder_simple(spl_type_t *type, spl_type_node_kind_t kind) {
+    spl_type_node_t tn = {0};
+    tn.kind = kind;
+    return spl_type_node_push(type, &tn);
+}
+
+spl_type_id_t spl_type_builder_int(spl_type_t *type, usize bits, int is_signed) {
+    spl_type_node_t tn = {0};
+    tn.kind = SPL_TYPE_INT;
+    tn.int_type.bits = bits;
+    tn.int_type.is_signed = is_signed;
+    return spl_type_node_push(type, &tn);
+}
+
+spl_type_id_t spl_type_builder_float(spl_type_t *type, usize bits) {
+    spl_type_node_t tn = {0};
+    tn.kind = SPL_TYPE_FLOAT;
+    tn.float_type.bits = bits;
+    return spl_type_node_push(type, &tn);
+}
+
+spl_type_id_t spl_type_builder_ptr(spl_type_t *type, spl_type_id_t pointee) {
+    spl_type_node_t tn = {0};
+    tn.kind = SPL_TYPE_PTR;
+    tn.ptr_pointee = pointee;
+    return spl_type_node_push(type, &tn);
+}
+
+spl_type_id_t spl_type_builder_slice(spl_type_t *type, spl_type_id_t element) {
+    spl_type_node_t tn = {0};
+    tn.kind = SPL_TYPE_SLICE;
+    tn.slice_element = element;
+    return spl_type_node_push(type, &tn);
+}
+
+spl_type_id_t spl_type_builder_range(spl_type_t *type, spl_type_id_t element) {
+    spl_type_node_t tn = {0};
+    tn.kind = SPL_TYPE_RANGE;
+    tn.range_element = element;
+    return spl_type_node_push(type, &tn);
+}
+
+spl_type_id_t spl_type_builder_array(spl_type_t *type, spl_type_id_t element, usize len) {
+    spl_type_node_t tn = {0};
+    tn.kind = SPL_TYPE_ARRAY;
+    tn.array_type.element = element;
+    tn.array_type.len = len;
+    return spl_type_node_push(type, &tn);
+}
+
+spl_type_id_t spl_type_builder_fn(spl_type_t *type, spl_type_id_t ret, const spl_type_id_t *params,
+                                  usize nparams) {
+    spl_type_node_t tn = {0};
+    tn.kind = SPL_TYPE_FN;
+    vec_init(tn.fn_type.params);
+    for (usize i = 0; i < nparams; i++) {
+        vec_push(tn.fn_type.params, params[i]);
+    }
+    tn.fn_type.ret = ret;
+    return spl_type_node_push(type, &tn);
+}
+
+spl_type_id_t spl_type_builder_agg(spl_type_t *type, spl_type_node_kind_t tk,
+                                   const spl_type_member_t *members, usize nmembers,
                                    spl_type_id_t tag_type, spl_type_layout_t layout) {
-    if (tk != SPL_TYPE_STRUCT && tk != SPL_TYPE_UNION && tk != SPL_TYPE_ENUM) {
-        return 0;
-    }
-    spl_def_node_t *d = spl_type_def(type, def);
-    if (!d) {
-        return 0;
-    }
     spl_type_node_t tn = {0};
     tn.kind = tk;
     tn.layout = layout;
     if (tk == SPL_TYPE_ENUM) {
         vec_init(tn.adt_type.variants);
+        for (usize i = 0; i < nmembers; i++) {
+            vec_push(tn.adt_type.variants, members[i]);
+        }
         tn.adt_type.tag_type = tag_type;
     } else {
-        vec_init(tn.agg_field_types);
+        vec_init(tn.agg_members);
-    }
+        for (usize i = 0; i < nmembers; i++) {
-    vec_for(d->agg_def, i) {
+            vec_push(tn.agg_members, members[i]);
-        if (tk == SPL_TYPE_ENUM) {
-            vec_push(tn.adt_type.variants, vec_at(d->agg_def, i).type_id);
-        } else {
-            vec_push(tn.agg_field_types, vec_at(d->agg_def, i).type_id);
         }
     }
-    usize old = vec_size(type->type_table);
+    return spl_type_node_push(type, &tn);
-    spl_type_id_t tid = spl_type_node_push(type, tn);
-    if (tid < old) {
-        if (tk == SPL_TYPE_ENUM) {
-            vec_free(tn.adt_type.variants);
-        } else {
-            vec_free(tn.agg_field_types);
-        }
-    }
-    d->type_id = tid;
-    return tid;
 }
 
-spl_type_id_t spl_type_def_fn_build(spl_type_t *type, spl_def_id_t def, spl_type_id_t ret) {
+spl_def_id_t spl_type_def_alloc(spl_type_t *type, spl_def_node_kind_t kind, const char *name,
-    spl_def_node_t *d = spl_type_def(type, def);
+                                spl_dbg_node_t dbg, usize ast_node_ref) {
+    spl_def_node_t n = {0};
+    n.kind = kind;
+    n.name = name;
+    n.dbg_node = dbg;
+    n.ast_node_ref = ast_node_ref;
+    vec_push(type->def_table, n);
+    return vec_size(type->def_table) - 1;
+}
+
+void spl_type_def_resolve(spl_type_t *type, spl_def_id_t id, spl_type_id_t tid) {
+    spl_def_node_t *d = spl_type_def(type, id);
     if (!d) {
-        return 0;
+        return;
-    }
-    spl_type_node_t tn = {0};
-    tn.kind = SPL_TYPE_FN;
-    vec_init(tn.fn_type.params);
-    vec_for(d->fn_params_def, i) {
-        vec_push(tn.fn_type.params, vec_at(d->fn_params_def, i).type_id);
-    }
-    tn.fn_type.ret = ret;
-    usize old = vec_size(type->type_table);
-    spl_type_id_t tid = spl_type_node_push(type, tn);
-    if (tid < old) {
-        vec_free(tn.fn_type.params);
     }
     d->type_id = tid;
-    return tid;
+}
+
+spl_type_id_t spl_type_fn_param_tid(spl_type_t *type, spl_type_id_t fn_tid, usize idx) {
+    spl_type_node_t *n = spl_type_node(type, fn_tid);
+    if (!n || n->kind != SPL_TYPE_FN || idx >= vec_size(n->fn_type.params))
+        return 0;
+    return vec_at(n->fn_type.params, idx);
 }
 
 void spl_type_init(spl_type_t *type) {
     vec_init(type->type_table);
     vec_push(type->type_table, (spl_type_node_t){0});
-    map_init(type->type_map, spl_type_hash, spl_type_eq);
+    map_init(type->type_map, spl_type_map_hash, spl_type_map_cmp);
     vec_init(type->def_table);
     vec_push(type->def_table, (spl_def_node_t){0});
 
-    spl_type_node_push(type, (spl_type_node_t){.kind = SPL_TYPE_VOID});
+    spl_type_builder_simple(type, SPL_TYPE_VOID);
-    spl_type_node_push(type, (spl_type_node_t){.kind = SPL_TYPE_BOOL});
+    spl_type_builder_simple(type, SPL_TYPE_BOOL);
-    spl_type_node_push(type, (spl_type_node_t){
+    spl_type_builder_simple(type, SPL_TYPE_UNDEFINED);
-                                 .kind = SPL_TYPE_INT,
+    spl_type_builder_simple(type, SPL_TYPE_NULL);
-                                 .int_type.bits = 8,
+    spl_type_builder_int(type, 8, false);
-                                 .int_type.is_signed = false,
+    spl_type_builder_int(type, 16, false);
-                             });
+    spl_type_builder_int(type, 32, false);
-    spl_type_node_push(type, (spl_type_node_t){
+    spl_type_builder_int(type, 64, false);
-                                 .kind = SPL_TYPE_INT,
+    spl_type_builder_int(type, 8, true);
-                                 .int_type.bits = 16,
+    spl_type_builder_int(type, 16, true);
-                                 .int_type.is_signed = false,
+    spl_type_builder_int(type, 32, true);
-                             });
+    spl_type_builder_int(type, 64, true);
-    spl_type_node_push(type, (spl_type_node_t){
+    spl_type_builder_float(type, 32);
-                                 .kind = SPL_TYPE_INT,
+    spl_type_builder_float(type, 64);
-                                 .int_type.bits = 32,
-                                 .int_type.is_signed = false,
-                             });
-    spl_type_node_push(type, (spl_type_node_t){
-                                 .kind = SPL_TYPE_INT,
-                                 .int_type.bits = 64,
-                                 .int_type.is_signed = false,
-                             });
-    spl_type_node_push(type, (spl_type_node_t){
-                                 .kind = SPL_TYPE_INT,
-                                 .int_type.bits = 8,
-                                 .int_type.is_signed = true,
-                             });
-    spl_type_node_push(type, (spl_type_node_t){
-                                 .kind = SPL_TYPE_INT,
-                                 .int_type.bits = 16,
-                                 .int_type.is_signed = true,
-                             });
-    spl_type_node_push(type, (spl_type_node_t){
-                                 .kind = SPL_TYPE_INT,
-                                 .int_type.bits = 32,
-                                 .int_type.is_signed = true,
-                             });
-    spl_type_node_push(type, (spl_type_node_t){
-                                 .kind = SPL_TYPE_INT,
-                                 .int_type.bits = 64,
-                                 .int_type.is_signed = true,
-                             });
-    spl_type_node_push(type, (spl_type_node_t){.kind = SPL_TYPE_FLOAT, .float_type.bits = 32});
-    spl_type_node_push(type, (spl_type_node_t){.kind = SPL_TYPE_FLOAT, .float_type.bits = 64});
 }
 
 void spl_type_drop(spl_type_t *type) {
@@ -258,7 +359,7 @@ void spl_type_drop(spl_type_t *type) {
         switch (n->kind) {
         case SPL_TYPE_STRUCT:
         case SPL_TYPE_UNION:
-            vec_free(n->agg_field_types);
+            vec_free(n->agg_members);
             break;
         case SPL_TYPE_ENUM:
             vec_free(n->adt_type.variants);
@@ -271,20 +372,6 @@ void spl_type_drop(spl_type_t *type) {
         }
     }
 
-    vec_for(type->def_table, i) {
-        spl_def_node_t *d = &vec_at(type->def_table, i);
-        switch (d->kind) {
-        case SPL_DEF_AGG:
-            vec_free(d->agg_def);
-            break;
-        case SPL_DEF_FN_PARAMS:
-            vec_free(d->fn_params_def);
-            break;
-        default:
-            break;
-        }
-    }
-
     map_free(type->type_map);
     vec_free(type->type_table);
     vec_free(type->def_table);
@@ -318,11 +405,25 @@ void spl_type_pure_dump(spl_type_t *type, spl_type_id_t id) {
     case SPL_TYPE_BOOL:
         printf("bool");
         break;
+    case SPL_TYPE_UNDEFINED:
+        printf("undefined");
+        break;
+    case SPL_TYPE_NULL:
+        printf("null");
+        break;
     case SPL_TYPE_INT:
+        if (n->int_type.bits == 0) {
+            printf("comptime_int");
+        } else {
             printf("%s%zu", n->int_type.is_signed ? "i" : "u", n->int_type.bits);
+        }
         break;
     case SPL_TYPE_FLOAT:
+        if (n->float_type.bits == 0) {
+            printf("comptime_float");
+        } else {
             printf("f%zu", n->float_type.bits);
+        }
         break;
     case SPL_TYPE_PTR:
         printf("*");
@@ -342,20 +443,48 @@ void spl_type_pure_dump(spl_type_t *type, spl_type_id_t id) {
         spl_type_pure_dump(type, n->array_type.element);
         break;
     case SPL_TYPE_STRUCT:
-        printf("struct{%zu fields}", n->agg_field_types.size);
+        printf("struct{");
+        vec_for(n->agg_members, i) {
+            if (i) {
+                printf(", ");
+            }
+            spl_type_member_t *member = &vec_at(n->agg_members, i);
+            printf("%s:", member->name ? member->name : "?");
+            spl_type_pure_dump(type, member->type_id);
+        }
+        printf("}");
         break;
     case SPL_TYPE_UNION:
-        printf("union{%zu fields}", n->agg_field_types.size);
+        printf("union{");
+        vec_for(n->agg_members, i) {
+            if (i) {
+                printf(", ");
+            }
+            spl_type_member_t *member = &vec_at(n->agg_members, i);
+            printf("%s:", member->name ? member->name : "?");
+            spl_type_pure_dump(type, member->type_id);
+        }
+        printf("}");
         break;
     case SPL_TYPE_ENUM:
-        printf("enum{%zu variants}", n->adt_type.variants.size);
+        printf("enum{"); // TODO tag_type
+        vec_for(n->adt_type.variants, i) {
+            if (i) {
+                printf(", ");
+            }
+            spl_type_member_t *member = &vec_at(n->adt_type.variants, i);
+            printf("%s:", member->name ? member->name : "?");
+            spl_type_pure_dump(type, member->type_id);
+        }
+        printf("}");
         break;
     case SPL_TYPE_FN: {
         printf("fn(");
-        for (usize i = 0; i < n->fn_type.params.size; i++) {
+        vec_for(n->fn_type.params, i) {
-            if (i)
+            if (i) {
                 printf(",");
-            spl_type_pure_dump(type, n->fn_type.params.data[i]);
+            }
+            spl_type_pure_dump(type, vec_at(n->fn_type.params, i));
         }
         printf(") -> ");
         spl_type_pure_dump(type, n->fn_type.ret);
@@ -389,7 +518,7 @@ void spl_type_def_dump(spl_type_t *type, spl_def_id_t id) {
         def_kind_name = "var";
         break;
     case SPL_DEF_FN_PARAMS:
-        def_kind_name = "params";
+        def_kind_name = "fn_params";
         break;
     case SPL_DEF_AGG:
         def_kind_name = "agg";
@@ -401,37 +530,6 @@ void spl_type_def_dump(spl_type_t *type, spl_def_id_t id) {
         def_kind_name = "sametypes";
         break;
     }
-    printf("kind=%s type_id=%zu", def_kind_name, node->type_id);
+    printf("kind=%s type_id=%zu name=%s", def_kind_name, node->type_id,
-    switch (node->kind) {
+           node->name ? node->name : "?");
-    case SPL_DEF_VAR:
-        printf(" var=%s", node->var_def.name ? node->var_def.name : "?");
-        break;
-    case SPL_DEF_MEMBER:
-        printf(" member=%s", node->var_def.name ? node->var_def.name : "?");
-        break;
-    case SPL_DEF_ALIAS:
-    case SPL_DEF_DISTINCT:
-        printf(" type=%s", node->type_def.name ? node->type_def.name : "?");
-        break;
-    case SPL_DEF_AGG:
-        printf(" agg{");
-        for (usize i = 0; i < node->agg_def.size; i++) {
-            if (i)
-                printf(",");
-            printf("%s", node->agg_def.data[i].name ? node->agg_def.data[i].name : "?");
-        }
-        printf("}");
-        break;
-    case SPL_DEF_FN_PARAMS:
-        printf(" fn(");
-        for (usize i = 0; i < node->fn_params_def.size; i++) {
-            if (i)
-                printf(",");
-            printf("%s", node->fn_params_def.data[i].name ? node->fn_params_def.data[i].name : "?");
-        }
-        printf(")");
-        break;
-    default:
-        break;
-    }
 }

stage1/spl_type.h

@@ -15,6 +15,8 @@ typedef enum {
     SPL_TYPE_BOOL,
     SPL_TYPE_INT,
     SPL_TYPE_FLOAT,
+    SPL_TYPE_UNDEFINED, // 自动配对任意类型的字面量，值为 undefined
+    SPL_TYPE_NULL,      // 自动配对指针/切片的字面量，值为 0
     SPL_TYPE_PTR,
     SPL_TYPE_SLICE, // 未来拥有泛型后删除
     SPL_TYPE_RANGE, // 未来拥有泛型后删除
@@ -37,6 +39,13 @@ typedef struct {
     usize fixed_align_bits;
 } spl_type_layout_t;
 
+typedef struct {
+    const char *name;
+    spl_type_id_t type_id;
+    usize ast_node_ref; // 回 AST member_decl 节点引用 dbg/IDE 定位用 不参与 hash
+} spl_type_member_t;
+typedef VEC(spl_type_member_t) spl_type_member_vec_t;
+
 typedef struct {
     spl_type_node_kind_t kind;
     spl_type_layout_t layout;
@@ -55,9 +64,9 @@ typedef struct {
             spl_type_id_t element;
             usize len;
         } array_type;
-        spl_type_id_vec_t agg_field_types;
+        spl_type_member_vec_t agg_members;
         struct {
-            spl_type_id_vec_t variants;
+            spl_type_member_vec_t variants;
             spl_type_id_t tag_type;
         } adt_type; // ADT
         struct {
@@ -69,16 +78,7 @@ typedef struct {
 } spl_type_node_t;
 typedef VEC(spl_type_node_t) spl_type_node_vec_t;
 
-typedef struct {
+typedef enum {
-    const char *name;
-    spl_def_id_t def_id;
-    spl_type_id_t type_id;
-    usize scope_id;
-} spl_var_def_t;
-typedef VEC(spl_var_def_t) spl_var_def_vec_t;
-
-typedef struct {
-    enum {
     SPL_DEF_ERROR,
     SPL_DEF_SCALAR,
     SPL_DEF_MEMBER,
@@ -87,22 +87,20 @@ typedef struct {
     SPL_DEF_AGG,      // include enum variants
     SPL_DEF_DISTINCT, // newtype
     SPL_DEF_ALIAS,    // sametypes
-    } kind;
+} spl_def_node_kind_t;
+
+typedef struct {
+    spl_def_node_kind_t kind;
+    const char *name;
     spl_dbg_node_t dbg_node;
     spl_type_id_t type_id;
-    union {
+    usize ast_node_ref;
-        spl_var_def_t var_def;
-        spl_var_def_vec_t agg_def; // include enum variants
-        spl_var_def_vec_t fn_params_def;
-        spl_var_def_t type_def;
-    };
 } spl_def_node_t;
 typedef VEC(spl_def_node_t) spl_def_node_vec_t;
 
-typedef MAP(spl_type_node_t, usize) spl_type_node_map_t;
+typedef MAP(usize, spl_type_id_t) spl_type_node_map_t;
 typedef struct {
     spl_type_node_vec_t type_table;
-    // TODO hashconsing
     spl_type_node_map_t type_map;
     spl_def_node_vec_t def_table;
 } spl_type_t;
@@ -116,11 +114,25 @@ void spl_type_pure_dump(spl_type_t *type, spl_type_id_t id);
 spl_type_node_t *spl_type_node(spl_type_t *type, spl_type_id_t id);
 spl_def_node_t *spl_type_def(spl_type_t *type, spl_def_id_t id);
 
-spl_type_id_t spl_type_def_alloc(spl_type_t *type);
+spl_type_id_t spl_type_def_alloc(spl_type_t *type, spl_def_node_kind_t kind, const char *name,
-spl_type_id_t spl_type_node_push(spl_type_t *type, spl_type_node_t type_node);
+                                 spl_dbg_node_t dbg, usize ast_node_ref);
+void spl_type_def_resolve(spl_type_t *type, spl_def_id_t id, spl_type_id_t tid);
 
-spl_type_id_t spl_type_def_agg_build(spl_type_t *type, spl_def_id_t def, spl_type_node_kind_t tk,
+spl_type_id_t spl_type_fn_param_tid(spl_type_t *type, spl_type_id_t fn_tid, usize idx);
+const spl_type_member_t *spl_type_agg_member(spl_type_t *type, spl_type_id_t tid, const char *name);
+bool spl_type_agg_member_idx(spl_type_t *type, spl_type_id_t tid, const char *name, usize *out_idx);
+
+spl_type_id_t spl_type_node_push(spl_type_t *type, spl_type_node_t *type_node);
+spl_type_id_t spl_type_builder_simple(spl_type_t *type, spl_type_node_kind_t kind);
+spl_type_id_t spl_type_builder_int(spl_type_t *type, usize bits, int is_signed);
+spl_type_id_t spl_type_builder_float(spl_type_t *type, usize bits);
+spl_type_id_t spl_type_builder_ptr(spl_type_t *type, spl_type_id_t pointee);
+spl_type_id_t spl_type_builder_slice(spl_type_t *type, spl_type_id_t element);
+spl_type_id_t spl_type_builder_range(spl_type_t *type, spl_type_id_t element);
+spl_type_id_t spl_type_builder_array(spl_type_t *type, spl_type_id_t element, usize len);
+spl_type_id_t spl_type_builder_fn(spl_type_t *type, spl_type_id_t ret, const spl_type_id_t *params,
+                                  usize nparams);
+spl_type_id_t spl_type_builder_agg(spl_type_t *type, spl_type_node_kind_t tk,
+                                   const spl_type_member_t *members, usize nmembers,
                                    spl_type_id_t tag_type, spl_type_layout_t layout);
-spl_type_id_t spl_type_def_fn_build(spl_type_t *type, spl_def_id_t def, spl_type_id_t ret);
-
 #endif /* __SPL_TYPE_H__ */