zzy/spl
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

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

Browse Source
This commit is contained in:
zzy
2026-08-22 19:35:01 +08:00
parent 0f40de43a1
commit f1d86b6e34
4 changed files with 719 additions and 398 deletions
Download Patch File Download Diff File Expand all files Collapse all files

77
stage0/include/core_map.h
View File

@@ -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; \
}))
/**
* 删除指定键
*/

562
stage1/spl_sema.c
View File

@@ -61,7 +61,7 @@ static void sema_collect(spl_sema_t *sema, spl_ast_node_ref_t ref) {
case SPL_AST_CONTAINER_MEMBERS: {
symbol.name = "$file";
symbol.kind = SPL_SYMBOL_KIND_TYPE;
symbol.node = spl_type_def_alloc(sema->type);
symbol.node = spl_type_def_alloc(sema->type, SPL_DEF_AGG, "$file", n->dbg, ref);
n->resolved_def_id = symbol.node;
spl_scope_id_t scope_id = spl_scope_alloc(sema->scope);
@@ -69,41 +69,38 @@ static void sema_collect(spl_sema_t *sema, spl_ast_node_ref_t ref) {
sema->scope->root_scope = scope_id;
spl_scope_insert(sema->scope, scope_id, symbol);
vec_for(n->container_members, i) { sema_collect(sema, vec_at(n->container_members, i)); }
spl_def_node_t *def = spl_type_def(sema->type, symbol.node);
def->kind = SPL_DEF_AGG;
break;
}
case SPL_AST_TYPE_DECL: {
symbol.name = n->type_decl.name;
symbol.kind = SPL_SYMBOL_KIND_TYPE;
symbol.node = spl_type_def_alloc(sema->type);
n->resolved_def_id = symbol.node;
n = spl_ast_node(sema->ast, n->type_decl.type_expr);
if (!n) {
spl_ast_node_t *te = spl_ast_node(sema->ast, n->type_decl.type_expr);
if (!te) {
SPL_ERROR(&n->dbg, "type_decl must have type_expr");
sema->error_count++;
return;
}
spl_def_node_t *def = spl_type_def(sema->type, symbol.node);
switch (n->kind) {
switch (te->kind) {
case SPL_AST_TYPE_STRUCT:
case SPL_AST_TYPE_UNION:
case SPL_AST_TYPE_ENUM:
case SPL_AST_TYPE_SHAPE: /* TODO for shape */
def->kind = SPL_DEF_AGG;
symbol.node = spl_type_def_alloc(sema->type, SPL_DEF_AGG, symbol.name, te->dbg, ref);
n->resolved_def_id = symbol.node;
spl_scope_id_t scope_id = spl_scope_alloc(sema->scope);
spl_scope_id_t old_id = sema->scope->current_scope;
spl_scope_insert(sema->scope, old_id, symbol);
sema->scope->current_scope = scope_id;
vec_for(n->type_expr.aggregate_list, i) {
sema_collect(sema, vec_at(n->type_expr.aggregate_list, i));
vec_for(te->type_expr.aggregate_list, i) {
spl_ast_node_ref_t mref = vec_at(te->type_expr.aggregate_list, i);
sema_collect(sema, mref);
}
sema->scope->current_scope = old_id;
break;
default:
def->kind = SPL_DEF_SCALAR;
symbol.node = spl_type_def_alloc(sema->type, SPL_DEF_SCALAR, symbol.name, te->dbg, ref);
n->resolved_def_id = symbol.node;
spl_scope_insert(sema->scope, sema->scope->current_scope, symbol);
break;
}
@@ -112,32 +109,17 @@ static void sema_collect(spl_sema_t *sema, spl_ast_node_ref_t ref) {
case SPL_AST_FN_DEFINE: {
symbol.name = n->fn_decl.name;
symbol.kind = SPL_SYMBOL_KIND_FN;
symbol.node = spl_type_def_alloc(sema->type);
symbol.node = spl_type_def_alloc(sema->type, SPL_DEF_FN_PARAMS, symbol.name, n->dbg, ref);
n->resolved_def_id = symbol.node;
spl_def_node_t *def = spl_type_def(sema->type, symbol.node);
def->kind = SPL_DEF_FN_PARAMS;
// TODO same type avaliable insert twice for decl and define but define must only once
spl_scope_insert(sema->scope, sema->scope->current_scope, symbol);
} break;
case SPL_AST_VAR_DECL:
case SPL_AST_CONST_DECL: {
symbol.name = n->var_const_decl.name;
symbol.kind = SPL_SYMBOL_KIND_VAR;
symbol.node = spl_type_def_alloc(sema->type);
symbol.node = spl_type_def_alloc(sema->type, SPL_DEF_VAR, symbol.name, n->dbg, ref);
n->resolved_def_id = symbol.node;
spl_def_node_t *def = spl_type_def(sema->type, symbol.node);
def->kind = SPL_DEF_VAR;
spl_scope_insert(sema->scope, sema->scope->current_scope, symbol);
} break;
case SPL_AST_MEMBER_DECL: {
symbol.name = n->member_decl.name;
symbol.kind = SPL_SYMBOL_KIND_MEMBER;
symbol.node = spl_type_def_alloc(sema->type);
n->resolved_def_id = symbol.node;
spl_def_node_t *def = spl_type_def(sema->type, symbol.node);
def->kind = SPL_DEF_MEMBER;
spl_scope_insert(sema->scope, sema->scope->current_scope, symbol);
} break;
default:
@@ -255,11 +237,29 @@ static spl_type_id_t sema_coerce_balance(spl_sema_t *sema, spl_type_id_t t1, spl
}
static bool sema_coerce_for_bool(spl_sema_t *sema, spl_type_id_t from) {
spl_type_id_t bool_tid =
spl_type_node_push(sema->type, (spl_type_node_t){.kind = SPL_TYPE_BOOL});
spl_type_id_t bool_tid = spl_type_builder_simple(sema->type, SPL_TYPE_BOOL);
return sema_coerce(sema, bool_tid, from) == bool_tid;
}
// FIXME using lib ops
static spl_type_id_t sema_for_elem_type(spl_sema_t *sema, spl_type_id_t tid) {
spl_type_node_t *n = spl_type_node(sema->type, tid);
if (!n)
return 0;
switch (n->kind) {
case SPL_TYPE_SLICE:
return n->slice_element;
case SPL_TYPE_ARRAY:
return n->array_type.element;
case SPL_TYPE_PTR:
return n->ptr_pointee;
case SPL_TYPE_RANGE:
return n->range_element;
default:
return 0;
}
}
static inline void sema_push_scope(spl_sema_t *sema) {
spl_scope_id_t scope_id = spl_scope_alloc(sema->scope);
sema->store_scope = sema->scope->current_scope;
@@ -284,45 +284,61 @@ static spl_type_id_t sema_parse(spl_sema_t *sema, spl_ast_node_ref_t ref) {
case SPL_AST_CONTAINER_MEMBERS: {
vec_for(n->container_members, i) { sema_parse(sema, vec_at(n->container_members, i)); }
} break;
case SPL_AST_FN_DECL:
case SPL_AST_FN_DECL: {
if (n->resolved_def_id == 0) {
Panic("fn `%s` don't collect", n->fn_decl.name);
}
/* 前向/extern 声明：只解析签名并构建 fn 类型，不进入 scope */
spl_type_id_vec_t params_type;
vec_init(params_type);
vec_for(n->fn_decl.param_list, i) {
spl_ast_node_ref_t ref = vec_at(n->fn_decl.param_list, i);
spl_ast_node_t *pd = spl_ast_node(sema->ast, ref);
if (pd && pd->kind == SPL_AST_PARAM_DECL && pd->param_decl.type_expr) {
vec_push(params_type, sema_parse(sema, pd->param_decl.type_expr));
} else {
// TODO variadic
}
}
spl_type_id_t ret_id = sema_parse(sema, n->fn_decl.type_expr);
spl_type_id_t fntid = spl_type_builder_fn(
sema->type, ret_id, vec_unsafe_get_data(params_type), vec_size(params_type));
// Move params_type don't need free
spl_type_def_resolve(sema->type, n->resolved_def_id, fntid);
break;
}
case SPL_AST_FN_DEFINE: {
if (n->resolved_def_id == 0) {
Panic("fn `%s` don't collect", n->fn_decl.name);
}
spl_def_node_t *def = spl_type_def(sema->type, n->resolved_def_id);
def->kind = SPL_DEF_FN_PARAMS;
vec_init(def->fn_params_def);
sema_push_scope(sema);
spl_var_def_vec_t params;
vec_init(params);
spl_type_id_vec_t params_type;
vec_init(params_type);
vec_for(n->fn_decl.param_list, i) {
spl_ast_node_ref_t ref = vec_at(n->fn_decl.param_list, i);
spl_type_id_t tid = sema_parse(sema, ref);
spl_ast_node_t *node = spl_ast_node(sema->ast, ref);
if (!node || node->kind != SPL_AST_PARAM_DECL || !node->param_decl.type_expr) {
// TODO variadic
continue;
}
spl_type_id_t tid = sema_parse(sema, ref);
Assert(node->kind == SPL_AST_PARAM_DECL);
spl_var_def_t var_def = {0};
var_def.name = node->param_decl.name;
var_def.type_id = tid;
var_def.def_id = node->resolved_def_id;
var_def.scope_id = sema->scope->current_scope;
vec_push(params, var_def);
vec_push(params_type, tid);
if (node->resolved_def_id) {
spl_def_node_t *pd = spl_type_def(sema->type, node->resolved_def_id);
Assert(pd != NULL);
pd->var_def.type_id = tid;
spl_type_def_resolve(sema->type, node->resolved_def_id, tid);
}
}
spl_def_node_t *def2 = spl_type_def(sema->type, n->resolved_def_id);
vec_free(def2->fn_params_def);
def2->fn_params_def = params;
spl_type_id_t ret_id = sema_parse(sema, n->fn_decl.type_expr);
spl_type_def_fn_build(sema->type, n->resolved_def_id, ret_id);
spl_type_id_t fntid = spl_type_builder_fn(
sema->type, ret_id, vec_unsafe_get_data(params_type), vec_size(params_type));
// Move params_type don't need free
spl_type_def_resolve(sema->type, n->resolved_def_id, fntid);
spl_type_id_t old_ret = sema->current_fn_ret_tid;
sema->current_fn_ret_tid = ret_id;
vec_for(n->fn_decl.block, i) { sema_parse(sema, vec_at(n->fn_decl.block, i)); }
@@ -330,8 +346,64 @@ static spl_type_id_t sema_parse(spl_sema_t *sema, spl_ast_node_ref_t ref) {
sema_pop_scope(sema);
} break;
case SPL_AST_TYPE_DECL: {
if (n->type_decl.type_expr) {
sema_parse(sema, n->type_decl.type_expr);
if (!n->type_decl.type_expr) {
break;
}
spl_ast_node_t *te = spl_ast_node(sema->ast, n->type_decl.type_expr);
if (!te) {
break;
}
switch (te->kind) {
case SPL_AST_TYPE_STRUCT:
case SPL_AST_TYPE_UNION:
case SPL_AST_TYPE_ENUM: {
spl_type_member_vec_t members;
vec_init(members);
/* 第一遍：只收字段(MEMBER_DECL)的类型，构建容器类型并 resolve；
* 方法(fn)留到类型 resolve 后再处理，否则方法体引用自身类型会拿到未解析的 0 */
vec_for(te->type_expr.aggregate_list, i) {
spl_ast_node_ref_t mref = vec_at(te->type_expr.aggregate_list, i);
spl_ast_node_t *mn = spl_ast_node(sema->ast, mref);
if (!mn || mn->kind != SPL_AST_MEMBER_DECL)
continue;
spl_type_id_t mtid = sema_parse(sema, mref);
spl_type_member_t m = {0};
m.name = mn->member_decl.name;
m.type_id = mtid;
m.ast_node_ref = mref;
vec_push(members, m);
}
spl_type_node_kind_t tk = te->kind == SPL_AST_TYPE_UNION ? SPL_TYPE_UNION
: te->kind == SPL_AST_TYPE_ENUM ? SPL_TYPE_ENUM
: SPL_TYPE_STRUCT;
spl_type_layout_t layout = {.mode = SPL_TYPE_LAYOUT_AUTO, .fixed_align_bits = 0};
// TODO tag type
spl_type_id_t tid = spl_type_builder_agg(
sema->type, tk, vec_unsafe_get_data(members), vec_size(members),
spl_type_builder_int(sema->type, 32, 1), layout);
// Move members don't need free
spl_type_def_resolve(sema->type, n->resolved_def_id, tid);
/* 第二遍：方法 body（struct 类型已 resolve，可引用自身类型） */
vec_for(te->type_expr.aggregate_list, i) {
spl_ast_node_ref_t mref = vec_at(te->type_expr.aggregate_list, i);
spl_ast_node_t *mn = spl_ast_node(sema->ast, mref);
if (mn && mn->kind == SPL_AST_FN_DEFINE)
sema_parse(sema, mref);
}
break;
}
case SPL_AST_TYPE_SHAPE: /* TODO */
vec_for(te->type_expr.aggregate_list, i) {
sema_parse(sema, vec_at(te->type_expr.aggregate_list, i));
}
break;
default: {
spl_type_id_t tid = sema_parse(sema, n->type_decl.type_expr);
spl_type_def_resolve(sema->type, n->resolved_def_id, tid);
break;
}
}
} break;
case SPL_AST_VAR_DECL:
@@ -340,15 +412,10 @@ static spl_type_id_t sema_parse(spl_sema_t *sema, spl_ast_node_ref_t ref) {
spl_symbol_t symbol = {0};
symbol.name = n->var_const_decl.name;
symbol.kind = SPL_SYMBOL_KIND_VAR;
symbol.node = spl_type_def_alloc(sema->type);
symbol.node = spl_type_def_alloc(sema->type, SPL_DEF_VAR, symbol.name, n->dbg, ref);
n->resolved_def_id = symbol.node;
spl_def_node_t *def = spl_type_def(sema->type, symbol.node);
def->kind = SPL_DEF_VAR;
spl_scope_insert(sema->scope, sema->scope->current_scope, symbol);
}
spl_def_node_t *def = spl_type_def(sema->type, n->resolved_def_id);
Assert(def != NULL);
spl_type_id_t decl_tid = 0;
if (n->var_const_decl.type_expr) {
decl_tid = sema_parse(sema, n->var_const_decl.type_expr);
@@ -364,13 +431,15 @@ static spl_type_id_t sema_parse(spl_sema_t *sema, spl_ast_node_ref_t ref) {
SPL_ERROR(&n->dbg, "decl type must not none %d");
sema->error_count += 1;
}
def->type_id = decl_tid;
def->var_def.type_id = decl_tid;
spl_type_def_resolve(sema->type, n->resolved_def_id, decl_tid);
} break;
case SPL_AST_MEMBER_DECL: {
/* 字段/变体不建 def, 类型由 TYPE_DECL 组装成员时统一构造 */
spl_type_id_t mtid = 0;
if (n->member_decl.type_expr) {
sema_parse(sema, n->member_decl.type_expr);
mtid = sema_parse(sema, n->member_decl.type_expr);
}
return mtid;
} break;
case SPL_AST__COMPTIME_STMT:
case SPL_AST__DIRECTIVE_BLOCK:
@@ -380,19 +449,15 @@ static spl_type_id_t sema_parse(spl_sema_t *sema, spl_ast_node_ref_t ref) {
spl_symbol_t symbol = {0};
symbol.name = n->param_decl.name;
symbol.kind = SPL_SYMBOL_KIND_VAR;
symbol.node = spl_type_def_alloc(sema->type);
symbol.node = spl_type_def_alloc(sema->type, SPL_DEF_VAR, symbol.name, n->dbg, ref);
n->resolved_def_id = symbol.node;
spl_def_node_t *def = spl_type_def(sema->type, symbol.node);
def->kind = SPL_DEF_VAR;
spl_scope_insert(sema->scope, sema->scope->current_scope, symbol);
}
spl_type_id_t ptid = 0;
if (n->param_decl.type_expr) {
ptid = sema_parse(sema, n->param_decl.type_expr);
}
spl_def_node_t *pd = spl_type_def(sema->type, n->resolved_def_id);
pd->var_def.type_id = ptid;
spl_type_def_resolve(sema->type, n->resolved_def_id, ptid);
return ptid;
} break;
case SPL_AST_ATTR_ITEM:
@@ -451,10 +516,23 @@ static spl_type_id_t sema_parse(spl_sema_t *sema, spl_ast_node_ref_t ref) {
}
} break;
case SPL_AST_FOR_STATEMENT: {
sema_push_scope(sema);
vec_for(n->for_statement.expr_vec, i) {
sema_parse(sema, vec_at(n->for_statement.expr_vec, i));
spl_ast_node_ref_t eref = vec_at(n->for_statement.expr_vec, i);
spl_type_id_t stid = sema_parse(sema, eref);
spl_type_id_t etid = sema_for_elem_type(sema, stid);
if (i < vec_size(n->for_statement.ident_vec)) {
const char *vname = vec_at(n->for_statement.ident_vec, i);
spl_symbol_t symbol = {0};
symbol.name = vname;
symbol.kind = SPL_SYMBOL_KIND_VAR;
symbol.node = spl_type_def_alloc(sema->type, SPL_DEF_VAR, vname, n->dbg, eref);
spl_type_def_resolve(sema->type, symbol.node, etid);
spl_scope_insert(sema->scope, sema->scope->current_scope, symbol);
}
}
vec_for(n->for_statement.block, i) { sema_parse(sema, vec_at(n->for_statement.block, i)); }
vec_for(n->for_statement.block, j) { sema_parse(sema, vec_at(n->for_statement.block, j)); }
sema_pop_scope(sema);
} break;
case SPL_AST_MATCH_STATEMENT: {
if (n->match_statement.expr) {
@@ -545,7 +623,7 @@ static spl_type_id_t sema_parse(spl_sema_t *sema, spl_ast_node_ref_t ref) {
sema->error_count++;
break;
}
spl_type_id_t bt = spl_type_node_push(sema->type, (spl_type_node_t){.kind = SPL_TYPE_BOOL});
spl_type_id_t bt = spl_type_builder_simple(sema->type, SPL_TYPE_BOOL);
n->resolved_type_id = bt;
return bt;
}
@@ -577,12 +655,20 @@ static spl_type_id_t sema_parse(spl_sema_t *sema, spl_ast_node_ref_t ref) {
sema->error_count++;
break;
}
spl_type_id_t bt = spl_type_node_push(sema->type, (spl_type_node_t){.kind = SPL_TYPE_BOOL});
spl_type_id_t bt = spl_type_builder_simple(sema->type, SPL_TYPE_BOOL);
n->resolved_type_id = bt;
return bt;
}
case SPL_AST_RANGE_EXPR:
break;
case SPL_AST_RANGE_EXPR: {
if (n->op_expr.left)
sema_parse(sema, n->op_expr.left);
if (n->op_expr.right)
sema_parse(sema, n->op_expr.right);
spl_type_id_t i64 = spl_type_builder_int(sema->type, 64, true);
spl_type_id_t rt = spl_type_builder_range(sema->type, i64);
n->resolved_type_id = rt;
return rt;
}
case SPL_AST_LSHIFT_EXPR:
case SPL_AST_RSHIFT_EXPR: {
spl_type_id_t lt = sema_parse(sema, n->op_expr.left);
@@ -604,6 +690,8 @@ static spl_type_id_t sema_parse(spl_sema_t *sema, spl_ast_node_ref_t ref) {
case SPL_AST_MOD_EXPR: {
spl_type_id_t lt = sema_parse(sema, n->op_expr.left);
spl_type_id_t rt = sema_parse(sema, n->op_expr.right);
spl_type_node_t *ln = spl_type_node(sema->type, lt);
spl_type_node_t *rn = spl_type_node(sema->type, rt);
spl_type_id_t peer = sema_coerce_balance(sema, lt, rt);
spl_type_node_t *pn = spl_type_node(sema->type, peer);
if (!pn || (pn->kind != SPL_TYPE_INT && pn->kind != SPL_TYPE_FLOAT)) {
@@ -617,19 +705,12 @@ static spl_type_id_t sema_parse(spl_sema_t *sema, spl_ast_node_ref_t ref) {
case SPL_AST_MINUS_EXPR: {
spl_ast_node_t *op = spl_ast_node(sema->ast, n->prefix_expr.postfix_expr);
if (op && op->kind == SPL_AST_EXPR_INTEGER_LIT) {
spl_type_id_t ct = spl_type_node_push(sema->type, (spl_type_node_t){
.kind = SPL_TYPE_INT,
.int_type.bits = 0,
.int_type.is_signed = true,
});
spl_type_id_t ct = spl_type_builder_int(sema->type, 0, true);
n->resolved_type_id = ct;
return ct;
}
if (op && op->kind == SPL_AST_EXPR_FLOAT_LIT) {
spl_type_id_t ct = spl_type_node_push(sema->type, (spl_type_node_t){
.kind = SPL_TYPE_FLOAT,
.float_type.bits = 0,
});
spl_type_id_t ct = spl_type_builder_float(sema->type, 0);
n->resolved_type_id = ct;
return ct;
}
@@ -651,7 +732,7 @@ static spl_type_id_t sema_parse(spl_sema_t *sema, spl_ast_node_ref_t ref) {
sema->error_count++;
break;
}
spl_type_id_t bt = spl_type_node_push(sema->type, (spl_type_node_t){.kind = SPL_TYPE_BOOL});
spl_type_id_t bt = spl_type_builder_simple(sema->type, SPL_TYPE_BOOL);
n->resolved_type_id = bt;
return bt;
}
@@ -678,11 +759,7 @@ static spl_type_id_t sema_parse(spl_sema_t *sema, spl_ast_node_ref_t ref) {
sema->error_count++;
break;
}
if (vec_size(n->postfix_expr.call_expr) != vec_size(fn->fn_type.params)) {
SPL_ERROR(&n->dbg, "call argument count mismatch");
sema->error_count++;
break;
}
// TODO type check
vec_for(n->postfix_expr.call_expr, i) {
spl_type_id_t at = sema_parse(sema, vec_at(n->postfix_expr.call_expr, i));
if (sema_coerce(sema, vec_at(fn->fn_type.params, i), at) == 0) {
@@ -693,17 +770,65 @@ static spl_type_id_t sema_parse(spl_sema_t *sema, spl_ast_node_ref_t ref) {
n->resolved_type_id = fn->fn_type.ret;
return fn->fn_type.ret;
}
case SPL_AST_FIELD_EXPR:
case SPL_AST_DEREF_EXPR:
if (n->postfix_expr.primary_expr)
sema_parse(sema, n->postfix_expr.primary_expr);
break;
case SPL_AST_INDEX_EXPR:
if (n->postfix_expr.primary_expr)
sema_parse(sema, n->postfix_expr.primary_expr);
case SPL_AST_DEREF_EXPR: {
spl_type_id_t btid = sema_parse(sema, n->postfix_expr.primary_expr);
spl_type_node_t *bn = spl_type_node(sema->type, btid);
if (!bn || bn->kind != SPL_TYPE_PTR) {
SPL_ERROR(&n->dbg, "deref requires pointer");
sema->error_count++;
break;
}
n->resolved_type_id = bn->ptr_pointee;
return bn->ptr_pointee;
}
case SPL_AST_FIELD_EXPR: {
spl_type_id_t btid = sema_parse(sema, n->postfix_expr.primary_expr);
spl_type_node_t *bn = spl_type_node(sema->type, btid);
spl_type_id_t agg_tid = btid;
if (bn && bn->kind == SPL_TYPE_PTR)
agg_tid = bn->ptr_pointee; /* 自动单层解引用 */
spl_type_node_t *an = spl_type_node(sema->type, agg_tid);
const char *fname = n->postfix_expr.field_expr;
const spl_type_member_t *m = NULL;
if (an && (an->kind == SPL_TYPE_STRUCT || an->kind == SPL_TYPE_UNION))
m = spl_type_agg_member(sema->type, agg_tid, fname);
if (!m) {
SPL_ERROR(&n->dbg, "no field `%s`", fname);
sema->error_count++;
break;
}
n->resolved_type_id = m->type_id;
return m->type_id;
}
case SPL_AST_INDEX_EXPR: {
spl_type_id_t btid = sema_parse(sema, n->postfix_expr.primary_expr);
if (n->postfix_expr.index_expr)
sema_parse(sema, n->postfix_expr.index_expr);
break;
spl_type_node_t *bn = spl_type_node(sema->type, btid);
spl_type_id_t etid = 0;
if (bn) {
switch (bn->kind) {
case SPL_TYPE_SLICE:
etid = bn->slice_element;
break;
case SPL_TYPE_ARRAY:
etid = bn->array_type.element;
break;
case SPL_TYPE_PTR:
etid = bn->ptr_pointee;
break;
default:
break;
}
}
if (etid == 0) {
SPL_ERROR(&n->dbg, "index base must be slice/array/ptr");
sema->error_count++;
break;
}
n->resolved_type_id = etid;
return etid;
}
case SPL_AST_SLICE_EXPR:
if (n->postfix_expr.primary_expr)
sema_parse(sema, n->postfix_expr.primary_expr);
@@ -726,39 +851,37 @@ static spl_type_id_t sema_parse(spl_sema_t *sema, spl_ast_node_ref_t ref) {
return tt;
}
case SPL_AST_EXPR_INTEGER_LIT: {
spl_type_id_t ct = spl_type_node_push(sema->type, (spl_type_node_t){
.kind = SPL_TYPE_INT,
.int_type.bits = 0,
.int_type.is_signed = true,
});
spl_type_id_t ct = spl_type_builder_int(sema->type, 0, true);
n->resolved_type_id = ct;
return ct;
}
case SPL_AST_EXPR_FLOAT_LIT: {
spl_type_id_t ct = spl_type_node_push(sema->type, (spl_type_node_t){
.kind = SPL_TYPE_FLOAT,
.float_type.bits = 0,
});
spl_type_id_t ct = spl_type_builder_float(sema->type, 0);
n->resolved_type_id = ct;
return ct;
}
case SPL_AST_EXPR_CHAR_LIT:
case SPL_AST_EXPR_STRING_LIT:
break;
case SPL_AST_EXPR_STRING_LIT: {
/* SPL.md: 字符串字面量 -> []u8 */
spl_type_id_t u8 = spl_type_builder_int(sema->type, 8, false);
spl_type_id_t st = spl_type_builder_slice(sema->type, u8);
n->resolved_type_id = st;
return st;
}
case SPL_AST_EXPR_NULL: {
spl_type_id_t nt = spl_type_node_push(sema->type, (spl_type_node_t){.kind = SPL_TYPE_NULL});
spl_type_id_t nt = spl_type_builder_simple(sema->type, SPL_TYPE_NULL);
n->resolved_type_id = nt;
return nt;
}
case SPL_AST_EXPR_TRUE:
case SPL_AST_EXPR_FALSE: {
spl_type_id_t bt = spl_type_node_push(sema->type, (spl_type_node_t){.kind = SPL_TYPE_BOOL});
spl_type_id_t bt = spl_type_builder_simple(sema->type, SPL_TYPE_BOOL);
n->resolved_type_id = bt;
return bt;
}
case SPL_AST_EXPR_UNDEFINED: {
spl_type_id_t ut =
spl_type_node_push(sema->type, (spl_type_node_t){.kind = SPL_TYPE_UNDEFINED});
spl_type_id_t ut = spl_type_builder_simple(sema->type, SPL_TYPE_UNDEFINED);
n->resolved_type_id = ut;
return ut;
}
@@ -772,19 +895,60 @@ static spl_type_id_t sema_parse(spl_sema_t *sema, spl_ast_node_ref_t ref) {
Assert(symbol.node != 0);
n->resolved_def_id = symbol.node;
spl_def_node_t *d = spl_type_def(sema->type, symbol.node);
if (!d) {
return 0;
}
if (d->kind == SPL_DEF_VAR || d->kind == SPL_DEF_MEMBER) {
return d->var_def.type_id;
}
Assert(d != 0);
return d->type_id;
}
case SPL_AST_ARGGREGATE_INIT:
vec_for(n->primary_expr.aggregate_init.expr, i) {
sema_parse(sema, vec_at(n->primary_expr.aggregate_init.expr, i));
case SPL_AST_ARGGREGATE_INIT: {
const char *tname = n->primary_expr.aggregate_init.name;
if (!tname) {
SPL_ERROR(&n->dbg, "anonymous aggregate init TODO");
sema->error_count++;
break;
}
break;
spl_symbol_t sym = {0};
if (!spl_scope_find(sema->scope, tname, &sym)) {
SPL_ERROR(&n->dbg, "aggregate init: unknown type `%s`", tname);
sema->error_count++;
break;
}
spl_def_node_t *d = spl_type_def(sema->type, sym.node);
spl_type_id_t tid = d ? d->type_id : 0;
spl_type_node_t *tn = spl_type_node(sema->type, tid);
if (!tn || (tn->kind != SPL_TYPE_STRUCT && tn->kind != SPL_TYPE_UNION)) {
SPL_ERROR(&n->dbg, "aggregate init: `%s` is not a struct", tname);
sema->error_count++;
break;
}
usize got = 0;
vec_for(n->primary_expr.aggregate_init.expr, i) {
spl_ast_node_t *item =
spl_ast_node(sema->ast, vec_at(n->primary_expr.aggregate_init.expr, i));
if (!item || item->kind != SPL_AST_ARGG_INIT_ITEM)
continue;
got++;
const char *fname = item->aggregate_init_item.ident;
spl_type_id_t etid = item->aggregate_init_item.expr
? sema_parse(sema, item->aggregate_init_item.expr)
: 0;
const spl_type_member_t *m = spl_type_agg_member(sema->type, tid, fname);
if (!m) {
SPL_ERROR(&item->dbg, "aggregate init: no field `%s` in `%s`", fname, tname);
sema->error_count++;
continue;
}
if (sema_coerce(sema, m->type_id, etid) == 0) {
SPL_ERROR(&item->dbg, "aggregate init: field `%s` type mismatch", fname);
sema->error_count++;
}
}
if (tn->kind == SPL_TYPE_STRUCT && got != vec_size(tn->agg_members)) {
SPL_ERROR(&n->dbg, "aggregate init: field count mismatch (%zu/%zu)", got,
vec_size(tn->agg_members));
sema->error_count++;
}
n->resolved_type_id = tid;
return tid;
}
case SPL_AST_EXPR_EXPR: {
spl_type_id_t t = sema_parse(sema, n->primary_expr.expr);
n->resolved_type_id = t;
@@ -815,26 +979,65 @@ static spl_type_id_t sema_parse(spl_sema_t *sema, spl_ast_node_ref_t ref) {
if (n->type_expr.fn_type.type_expr)
sema_parse(sema, n->type_expr.fn_type.type_expr);
break;
case SPL_AST_BASE_TYPE_PATH:
case SPL_AST_BASE_TYPE_PATH: {
vec_for(n->type_expr.attr_list, i) { sema_parse(sema, vec_at(n->type_expr.attr_list, i)); }
if (vec_size(n->type_expr.type_path.ident_vec) == 0)
break;
const char *tname = vec_at(n->type_expr.type_path.ident_vec, 0);
if (vec_size(n->type_expr.type_path.ident_vec) == 1) {
spl_symbol_t sym = {0};
if (spl_scope_find(sema->scope, tname, &sym)) {
spl_def_node_t *d = spl_type_def(sema->type, sym.node);
if (d && d->type_id) {
n->resolved_type_id = d->type_id;
return d->type_id;
}
}
SPL_ERROR(&n->dbg, "type `%s` not found", tname);
sema->error_count++;
break;
}
/* 多段命名空间路径（如 Str.Inner）：TODO */
SPL_ERROR(&n->dbg, "nested type path TODO");
sema->error_count++;
break;
case SPL_AST_TYPE_POINTER:
}
case SPL_AST_TYPE_POINTER: {
vec_for(n->type_expr.attr_list, i) { sema_parse(sema, vec_at(n->type_expr.attr_list, i)); }
spl_type_id_t ptid = 0;
if (n->type_expr.pointer_type.pointee)
sema_parse(sema, n->type_expr.pointer_type.pointee);
break;
case SPL_AST_TYPE_ARRAY:
ptid = sema_parse(sema, n->type_expr.pointer_type.pointee);
spl_type_id_t tid = spl_type_builder_ptr(sema->type, ptid);
n->resolved_type_id = tid;
return tid;
}
case SPL_AST_TYPE_ARRAY: {
vec_for(n->type_expr.attr_list, i) { sema_parse(sema, vec_at(n->type_expr.attr_list, i)); }
spl_type_id_t etid = 0;
if (n->type_expr.array_type.element)
sema_parse(sema, n->type_expr.array_type.element);
if (n->type_expr.array_type.size)
sema_parse(sema, n->type_expr.array_type.size);
break;
case SPL_AST_TYPE_SLICE:
etid = sema_parse(sema, n->type_expr.array_type.element);
usize len = 0;
if (n->type_expr.array_type.size) {
spl_ast_node_t *sz = spl_ast_node(sema->ast, n->type_expr.array_type.size);
if (sz && sz->kind == SPL_AST_EXPR_INTEGER_LIT) {
len = (usize)sz->primary_expr.integer_expr;
} else {
sema_parse(sema, n->type_expr.array_type.size);
}
}
spl_type_id_t tid = spl_type_builder_array(sema->type, etid, len);
n->resolved_type_id = tid;
return tid;
}
case SPL_AST_TYPE_SLICE: {
vec_for(n->type_expr.attr_list, i) { sema_parse(sema, vec_at(n->type_expr.attr_list, i)); }
spl_type_id_t etid = 0;
if (n->type_expr.slice_type.element)
sema_parse(sema, n->type_expr.slice_type.element);
break;
etid = sema_parse(sema, n->type_expr.slice_type.element);
spl_type_id_t tid = spl_type_builder_slice(sema->type, etid);
n->resolved_type_id = tid;
return tid;
}
case SPL_AST_TYPE_STRUCT:
case SPL_AST_TYPE_UNION:
case SPL_AST_TYPE_SHAPE:
@@ -845,85 +1048,35 @@ static spl_type_id_t sema_parse(spl_sema_t *sema, spl_ast_node_ref_t ref) {
}
break;
case SPL_AST_TYPE_VOID:
return spl_type_node_push(sema->type, (spl_type_node_t){
.kind = SPL_TYPE_VOID,
});
return spl_type_builder_simple(sema->type, SPL_TYPE_VOID);
case SPL_AST_TYPE_BOOL:
return spl_type_node_push(sema->type, (spl_type_node_t){
.kind = SPL_TYPE_BOOL,
});
return spl_type_builder_simple(sema->type, SPL_TYPE_BOOL);
case SPL_AST_TYPE_OPAQUE:
break;
return 0;
case SPL_AST_TYPE_I8:
return spl_type_node_push(sema->type, (spl_type_node_t){
.kind = SPL_TYPE_INT,
.int_type.bits = 8,
.int_type.is_signed = true,
});
return spl_type_builder_int(sema->type, 8, true);
case SPL_AST_TYPE_U8:
return spl_type_node_push(sema->type, (spl_type_node_t){
.kind = SPL_TYPE_INT,
.int_type.bits = 8,
.int_type.is_signed = false,
});
return spl_type_builder_int(sema->type, 8, false);
case SPL_AST_TYPE_I16:
return spl_type_node_push(sema->type, (spl_type_node_t){
.kind = SPL_TYPE_INT,
.int_type.bits = 16,
.int_type.is_signed = true,
});
return spl_type_builder_int(sema->type, 16, true);
case SPL_AST_TYPE_U16:
return spl_type_node_push(sema->type, (spl_type_node_t){
.kind = SPL_TYPE_INT,
.int_type.bits = 16,
.int_type.is_signed = false,
});
return spl_type_builder_int(sema->type, 16, false);
case SPL_AST_TYPE_I32:
return spl_type_node_push(sema->type, (spl_type_node_t){
.kind = SPL_TYPE_INT,
.int_type.bits = 32,
.int_type.is_signed = true,
});
return spl_type_builder_int(sema->type, 32, true);
case SPL_AST_TYPE_U32:
return spl_type_node_push(sema->type, (spl_type_node_t){
.kind = SPL_TYPE_INT,
.int_type.bits = 32,
.int_type.is_signed = false,
});
return spl_type_builder_int(sema->type, 32, false);
case SPL_AST_TYPE_I64:
return spl_type_node_push(sema->type, (spl_type_node_t){
.kind = SPL_TYPE_INT,
.int_type.bits = 64,
.int_type.is_signed = true,
});
return spl_type_builder_int(sema->type, 64, true);
case SPL_AST_TYPE_U64:
return spl_type_node_push(sema->type, (spl_type_node_t){
.kind = SPL_TYPE_INT,
.int_type.bits = 64,
.int_type.is_signed = false,
});
return spl_type_builder_int(sema->type, 64, false);
case SPL_AST_TYPE_ISIZE:
return spl_type_node_push(sema->type, (spl_type_node_t){
.kind = SPL_TYPE_INT,
.int_type.bits = sizeof(void *) * 8, /* FIXME */
.int_type.is_signed = true,
});
return spl_type_builder_int(sema->type, sizeof(void *) * 8, true); /* FIXME */
case SPL_AST_TYPE_USIZE:
return spl_type_node_push(sema->type, (spl_type_node_t){
.kind = SPL_TYPE_INT,
.int_type.bits = sizeof(void *) * 8, /* FIXME */
.int_type.is_signed = false,
});
return spl_type_builder_int(sema->type, sizeof(void *) * 8, false); /* FIXME */
case SPL_AST_TYPE__F32:
return spl_type_node_push(sema->type, (spl_type_node_t){
.kind = SPL_TYPE_FLOAT,
.float_type.bits = 32,
});
return spl_type_builder_float(sema->type, 32);
case SPL_AST_TYPE__F64:
return spl_type_node_push(sema->type, (spl_type_node_t){
.kind = SPL_TYPE_FLOAT,
.float_type.bits = 64,
});
return spl_type_builder_float(sema->type, 64);
case SPL_AST_TYPE_ANY:
case SPL_AST_TYPE_IDENT:
break;
@@ -983,6 +1136,7 @@ void spl_sema_dump(spl_sema_t *sema) {
vec_for(sema->type->def_table, i) {
printf(" def#%zu ", i);
spl_type_def_dump(sema->type, i);
spl_def_node_t *d = spl_type_def(sema->type, i);
printf("\n");
}
}

404
stage1/spl_type.c
View File

@@ -29,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.fixed_align_bits;
vec_for(n.agg_field_types, i) { hash += vec_at(n.agg_field_types, i); }
hash += n.layout.mode * 31 + n.layout.fixed_align_bits;
vec_for(n.agg_members, 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.fixed_align_bits;
hash += n.layout.mode * 31 + 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;
@@ -92,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) {
if (vec_at(n1.agg_field_types, i) != vec_at(n2.agg_field_types, i))
vec_for(n1.agg_members, 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;
@@ -108,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;
@@ -128,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) {
spl_type_id_t ret = 0;
int ok = map_get(type->type_map, type_node, &ret);
if (ok) {
return ret;
static usize spl_type_map_hash(usize k) { return MAP_HASH_INT(k); }
static int spl_type_map_cmp(usize a, usize b) { return MAP_CMP_INT(a, b); }
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) {
vec_push(type->def_table, (spl_def_node_t){0});
return vec_size(type->def_table) - 1;
spl_type_id_t spl_type_node_push(spl_type_t *type, spl_type_node_t *tn) {
usize hash = spl_type_hash(*tn);
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,
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;
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;
}
spl_def_node_t *d = spl_type_def(type, def);
if (!d) {
return 0;
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) {
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_for(d->agg_def, 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);
vec_init(tn.agg_members);
for (usize i = 0; i < nmembers; i++) {
vec_push(tn.agg_members, members[i]);
}
}
usize old = vec_size(type->type_table);
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;
return spl_type_node_push(type, &tn);
}
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_node_t *d = spl_type_def(type, def);
spl_def_id_t spl_type_def_alloc(spl_type_t *type, spl_def_node_kind_t kind, const char *name,
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;
}
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);
return;
}
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_node_push(type, (spl_type_node_t){.kind = SPL_TYPE_BOOL});
spl_type_node_push(type, (spl_type_node_t){
.kind = SPL_TYPE_INT,
.int_type.bits = 8,
.int_type.is_signed = false,
});
spl_type_node_push(type, (spl_type_node_t){
.kind = SPL_TYPE_INT,
.int_type.bits = 16,
.int_type.is_signed = false,
});
spl_type_node_push(type, (spl_type_node_t){
.kind = SPL_TYPE_INT,
.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});
spl_type_builder_simple(type, SPL_TYPE_VOID);
spl_type_builder_simple(type, SPL_TYPE_BOOL);
spl_type_builder_simple(type, SPL_TYPE_UNDEFINED);
spl_type_builder_simple(type, SPL_TYPE_NULL);
spl_type_builder_int(type, 8, false);
spl_type_builder_int(type, 16, false);
spl_type_builder_int(type, 32, false);
spl_type_builder_int(type, 64, false);
spl_type_builder_int(type, 8, true);
spl_type_builder_int(type, 16, true);
spl_type_builder_int(type, 32, true);
spl_type_builder_int(type, 64, true);
spl_type_builder_float(type, 32);
spl_type_builder_float(type, 64);
}
void spl_type_drop(spl_type_t *type) {
@@ -262,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);
@@ -275,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);
@@ -360,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++) {
if (i)
vec_for(n->fn_type.params, 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);
@@ -407,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";
@@ -419,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);
switch (node->kind) {
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;
}
printf("kind=%s type_id=%zu name=%s", def_kind_name, node->type_id,
node->name ? node->name : "?");
}

74
stage1/spl_type.h
View File

@@ -39,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;
@@ -57,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 {
@@ -71,40 +78,29 @@ typedef struct {
} spl_type_node_t;
typedef VEC(spl_type_node_t) spl_type_node_vec_t;
typedef struct {
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 enum {
SPL_DEF_ERROR,
SPL_DEF_SCALAR,
SPL_DEF_MEMBER,
SPL_DEF_VAR,
SPL_DEF_FN_PARAMS,
SPL_DEF_AGG, // include enum variants
SPL_DEF_DISTINCT, // newtype
SPL_DEF_ALIAS, // sametypes
} spl_def_node_kind_t;
typedef struct {
enum {
SPL_DEF_ERROR,
SPL_DEF_SCALAR,
SPL_DEF_MEMBER,
SPL_DEF_VAR,
SPL_DEF_FN_PARAMS,
SPL_DEF_AGG, // include enum variants
SPL_DEF_DISTINCT, // newtype
SPL_DEF_ALIAS, // sametypes
} kind;
spl_def_node_kind_t kind;
const char *name;
spl_dbg_node_t dbg_node;
spl_type_id_t type_id;
union {
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;
};
usize ast_node_ref;
} 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;
@@ -118,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_node_push(spl_type_t *type, spl_type_node_t type_node);
spl_type_id_t spl_type_def_alloc(spl_type_t *type, spl_def_node_kind_t kind, const char *name,
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 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);
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);
#endif /* __SPL_TYPE_H__ */