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

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");
}
}