// WRITE BY AI /* spl_sema.c SPL 语义分析 * * 两趟 AST 遍历（splc0 显式先 run 再 check）： * spl_sema_run —— Pass1：预登记顶层名字（聚合壳/别名/fn/var），使兄弟前向引用成立 * spl_sema_check —— Pass2：边构建聚合成员与方法 def，边检查函数体（类型检查） * * scope 符号表存 spl_def_id_t（def 第一公民）；匿名类型放 type_table， * 命名实体放 def_table，两张表 id 空间完全独立。 */ #include "spl_sema.h" #include "spl_builtin.h" #include #include typedef struct { spl_type_id_t ret; } spl_sema_ctx_t; static spl_ast_node_t *node_at(spl_ast_t *ast, spl_ast_node_ref_t ref) { if (!ref || ref >= ast->buckets.size) return NULL; return &ast->buckets.data[ref]; } static void sema_error(spl_sema_t *sema, spl_ast_node_ref_t ref, const char *msg) { spl_ast_node_t *n = node_at(sema->ast, ref); sema->error_count++; if (n) { LOG_ERROR("%s error: %s (%s:%d:%d)", "sema", msg, n->loc.fname ? n->loc.fname : "?", n->loc.line, n->loc.col); } else { LOG_ERROR("%s error: %s", "sema", msg); } } static void sema_warn(spl_sema_t *sema, spl_ast_node_ref_t ref, const char *msg) { spl_ast_node_t *n = node_at(sema->ast, ref); if (n) { LOG_WARN("%s warning: %s (%s:%d:%d)", "sema", msg, n->loc.fname ? n->loc.fname : "?", n->loc.line, n->loc.col); } else { LOG_WARN("%s warning: %s", "sema", msg); } } /* ---- def/type 快捷访问 ---- */ static spl_def_node_t *def_at(spl_sema_t *sema, spl_def_id_t id) { return spl_type_def(&sema->type, id); } static spl_type_id_t def_type(spl_sema_t *sema, spl_def_id_t id) { spl_def_node_t *d = def_at(sema, id); return d ? d->type_id : 0; } /* 由匿名类型 id 反查拥有它的 def（聚合优先；别名/ distinct 次之） */ static spl_def_id_t def_for_type(spl_sema_t *sema, spl_type_id_t tid) { if (!tid) return 0; spl_def_id_t fallback = 0; for (usize i = 1; i < sema->type.def_table.size; i++) { spl_def_node_t *d = &sema->type.def_table.data[i]; if (d->type_id == tid) { if (d->kind == SPL_DEF_AGG) return i; if (!fallback && (d->kind == SPL_DEF_ALIAS || d->kind == SPL_DEF_DISTINCT)) fallback = i; } } return fallback; } static spl_def_id_t def_alloc(spl_sema_t *sema, int kind) { spl_def_id_t id = spl_type_def_alloc(&sema->type); def_at(sema, id)->kind = kind; return id; } static spl_def_id_t new_var_def(spl_sema_t *sema, const char *name, spl_type_id_t type, spl_scope_id_t scope) { spl_def_id_t id = def_alloc(sema, SPL_DEF_VAR); spl_def_node_t *d = def_at(sema, id); d->type_id = type; d->var_def.name = name; d->var_def.def_id = id; d->var_def.type_id = type; d->var_def.scope_id = scope; return id; } /* 裸名查找：从 current_scope 沿父链到 root（字段名不在 symbols，天然不命中） */ static spl_def_id_t find_bare(spl_sema_t *sema, const char *name) { spl_scope_id_t cur = sema->current_scope; while (cur) { if (cur >= sema->scopes.size) break; spl_def_id_t val = 0; if (map_get(sema->scopes.data[cur].symbols, name, &val)) return val; cur = sema->scopes.data[cur].parent; } return 0; } /* 名字 → 其类型（def → type_id） */ static spl_type_id_t find_type(spl_sema_t *sema, const char *name) { return def_type(sema, find_bare(sema, name)); } /* ---- 聚合成员登记（def 层 agg_def） ---- */ static void agg_add_member(spl_sema_t *sema, spl_def_id_t def, const char *name, spl_type_id_t type, spl_scope_id_t scope, spl_def_id_t member_def) { spl_def_node_t *d = def_at(sema, def); if (!d || d->kind != SPL_DEF_AGG) return; spl_var_def_t v = {name, member_def, type, scope}; vec_push(d->agg_def, v); } /* 聚合/枚举成员查找：匿名类型 id → 拥有它的 def → agg_def */ static spl_type_id_t agg_member_type(spl_sema_t *sema, spl_type_id_t agg_tid, const char *name) { spl_def_id_t d = def_for_type(sema, agg_tid); if (!d) return 0; spl_def_node_t *def = def_at(sema, d); for (usize i = 0; i < def->agg_def.size; i++) { if (def->agg_def.data[i].name && strcmp(def->agg_def.data[i].name, name) == 0) return def->agg_def.data[i].type_id; } return 0; } /* ---- 类型解析 ---- */ static spl_type_id_t resolve_type_expr(spl_sema_t *sema, spl_ast_node_ref_t ref); static spl_type_id_t resolve_type_atom(spl_sema_t *sema, spl_ast_node_ref_t ref); static spl_type_id_t build_agg(spl_sema_t *sema, spl_ast_node_ref_t ref, spl_scope_id_t parent, const char *name); /* 路径类型：首段裸名（含内置），后续段逐级查聚合 agg_def */ static spl_type_id_t resolve_type_path(spl_sema_t *sema, spl_ast_node_ref_vec_t *path) { if (!path->size) return 0; spl_type_id_t tid = resolve_type_atom(sema, path->data[0]); if (!tid) return 0; for (usize i = 1; i < path->size; i++) { spl_ast_node_t *atom = node_at(sema->ast, path->data[i]); if (!atom) { sema_error(sema, path->data[i], "bad type path segment"); return 0; } spl_type_id_t mt = agg_member_type(sema, tid, atom->type_atom.ident); if (!mt) { char buf[128]; snprintf(buf, sizeof buf, "no member '%s' in type", atom->type_atom.ident); sema_error(sema, path->data[i], buf); return 0; } tid = mt; } return tid; } static spl_type_id_t resolve_type_atom(spl_sema_t *sema, spl_ast_node_ref_t ref) { spl_ast_node_t *n = node_at(sema->ast, ref); if (!n) return 0; switch (n->type_atom.kind) { case SPL_AST_TYPE_VOID: return spl_type_void(&sema->type); case SPL_AST_TYPE_BOOL: return spl_type_bool(&sema->type); case SPL_AST_TYPE_I8: return spl_type_int(&sema->type, 8, 1); case SPL_AST_TYPE_U8: return spl_type_int(&sema->type, 8, 0); case SPL_AST_TYPE_I16: return spl_type_int(&sema->type, 16, 1); case SPL_AST_TYPE_U16: return spl_type_int(&sema->type, 16, 0); case SPL_AST_TYPE_I32: return spl_type_int(&sema->type, 32, 1); case SPL_AST_TYPE_U32: return spl_type_int(&sema->type, 32, 0); case SPL_AST_TYPE_I64: return spl_type_int(&sema->type, 64, 1); case SPL_AST_TYPE_U64: return spl_type_int(&sema->type, 64, 0); case SPL_AST_TYPE_ISIZE: return spl_type_int(&sema->type, sizeof(isize) * 8, 1); case SPL_AST_TYPE_USIZE: return spl_type_int(&sema->type, sizeof(usize) * 8, 0); case SPL_AST_TYPE__F32: return spl_type_float(&sema->type, 32); case SPL_AST_TYPE__F64: return spl_type_float(&sema->type, 64); case SPL_AST_TYPE_PTR: case SPL_AST_TYPE_ANY: /* `_`/`ptr` 均为通配：只能作为指针目标，等于 *void。 * 裸用（无 * 前缀）由 resolve_type_expr 报错；ptr 关键字暂不使用 */ return spl_type_void(&sema->type); case SPL_AST_TYPE_IDENT: { spl_type_id_t tid = find_type(sema, n->type_atom.ident); if (!tid) { char buf[160]; snprintf(buf, sizeof buf, "unknown type '%s'", n->type_atom.ident); sema_error(sema, ref, buf); return 0; } return tid; } } return 0; } static spl_type_id_t resolve_type_expr(spl_sema_t *sema, spl_ast_node_ref_t ref) { spl_ast_node_t *n = node_at(sema->ast, ref); if (!n) return 0; spl_type_id_t base = 0; switch (n->type_expr.kind) { case SPL_AST_BASE_TYPE_PATH: base = resolve_type_path(sema, &n->type_expr.type_path); break; case SPL_AST_BASE_TYPE_FN: { spl_type_id_vec_t params; vec_init(params); for (usize i = 0; i < n->type_expr.fn_type.param_list.size; i++) { spl_ast_node_t *pd = node_at(sema->ast, n->type_expr.fn_type.param_list.data[i]); spl_type_id_t pt = 0; if (pd && pd->param_decl.type_expr) pt = resolve_type_expr(sema, pd->param_decl.type_expr); vec_push(params, pt); } spl_type_id_t ret = 0; if (n->type_expr.fn_type.type_expr) ret = resolve_type_expr(sema, n->type_expr.fn_type.type_expr); else ret = spl_type_void(&sema->type); base = spl_type_fn(&sema->type, params, ret); break; } case SPL_AST_TYPE_STRUCT: case SPL_AST_TYPE_UNION: case SPL_AST_TYPE_ENUM: /* 内联匿名聚合：构建聚合类型（不注册名字，parent 为当前 scope） */ base = build_agg(sema, ref, sema->current_scope, NULL); break; default: return 0; } /* 前缀修饰：* → ptr，[] → slice，[n] → array（逆序包裹） */ for (usize i = n->type_expr.type_prefixs.size; i > 0; i--) { spl_ast_node_t *pf = node_at(sema->ast, n->type_expr.type_prefixs.data[i - 1]); if (!pf) continue; if (pf->prefix_type.pointer == 1) { base = spl_type_ptr(&sema->type, base); } else if (pf->prefix_type.pointer == 2) { if (pf->prefix_type.array_size > 0) base = spl_type_array(&sema->type, base, (usize)pf->prefix_type.array_size); else base = spl_type_slice(&sema->type, base); } } /* `_`/`ptr` 只能在指针目标位置（*_ = *void）；裸用是无类型值，报错 */ if (n->type_expr.kind == SPL_AST_BASE_TYPE_PATH && n->type_expr.type_path.size) { spl_ast_node_t *atom = node_at(sema->ast, n->type_expr.type_path.data[n->type_expr.type_path.size - 1]); int ptr_pre = 0; for (usize i = 0; i < n->type_expr.type_prefixs.size; i++) { spl_ast_node_t *pf = node_at(sema->ast, n->type_expr.type_prefixs.data[i]); if (pf && pf->prefix_type.pointer == 1) ptr_pre = 1; } if (atom && !ptr_pre && (atom->type_atom.kind == SPL_AST_TYPE_ANY || atom->type_atom.kind == SPL_AST_TYPE_PTR)) sema_error(sema, ref, "bare `_` type only allowed as pointer target `*_`"); } /* AST 注解：该 type_expr 解析到的 def（聚合/别名/内置为 0；ast2ir 据此直接取类型） */ if (base) n->resolved_def_id = def_for_type(sema, base); return base; } /* ---- 声明处理 ---- */ static void sema_fn_decl(spl_sema_t *sema, spl_ast_node_ref_t ref, spl_scope_id_t scope, spl_def_id_t agg_def); static void sema_type_decl(spl_sema_t *sema, spl_ast_node_ref_t ref, spl_scope_id_t scope, spl_def_id_t agg_def); static void sema_var_decl(spl_sema_t *sema, spl_ast_node_ref_t ref, spl_scope_id_t scope, spl_def_id_t agg_def); static void sema_const_decl(spl_sema_t *sema, spl_ast_node_ref_t ref, spl_scope_id_t scope, spl_def_id_t agg_def); static void check_fn_body(spl_sema_t *sema, spl_ast_node_ref_t ref, spl_def_id_t fdef, spl_scope_id_t parent_scope); typedef struct { spl_type_id_t tid; spl_def_id_t def; } agg_handle_t; /* 只建匿名聚合类型 + AGG def（名字由调用方注册到目标 scope），不做成员解析。 * 用于顶层聚合在 Pass1 预登记，使兄弟/自引用 `type Node{next:*Node}` 成立。 */ static agg_handle_t agg_prepare(spl_sema_t *sema, spl_ast_node_ref_t ref) { agg_handle_t h = {0, 0}; spl_ast_node_t *te = node_at(sema->ast, ref); if (!te) return h; spl_type_id_t tid = spl_type_alloc(&sema->type); spl_type_node_t *tn = spl_type_node(&sema->type, tid); switch (te->type_expr.kind) { case SPL_AST_TYPE_STRUCT: tn->kind = SPL_TYPE_STRUCT; vec_init(tn->agg_field_types); break; case SPL_AST_TYPE_UNION: tn->kind = SPL_TYPE_UNION; vec_init(tn->agg_field_types); break; case SPL_AST_TYPE_ENUM: tn->kind = SPL_TYPE_ENUM; vec_init(tn->enum_type.variants); tn->enum_type.tag_type = 0; break; default: return h; /* 非聚合 */ } spl_def_id_t def = def_alloc(sema, SPL_DEF_AGG); def_at(sema, def)->type_id = tid; vec_init(def_at(sema, def)->agg_def); te->resolved_def_id = def; /* 注解：该 type_expr 解析到的 def */ h.tid = tid; h.def = def; return h; } /* 聚合成员解析：建聚合 scope（自名注册）→ 嵌套类型 pass1 → 成员/方法 pass2 → 方法体 pass3 */ static void agg_resolve(spl_sema_t *sema, spl_ast_node_ref_t ref, spl_type_id_t tid, spl_def_id_t def, spl_scope_id_t parent, const char *name) { spl_ast_node_t *te = node_at(sema->ast, ref); if (!te) return; spl_scope_id_t agg_scope = spl_sema_scope_alloc(sema); sema->scopes.data[agg_scope].parent = parent; if (name) spl_sema_scope_insert(sema, agg_scope, name, def); spl_scope_id_t save = sema->current_scope; sema->current_scope = agg_scope; /* pass1: 先构建嵌套类型（type 声明），使字段类型可前向引用嵌套类型 */ for (usize i = 0; i < te->type_expr.aggregate_list.size; i++) { spl_ast_node_t *m = node_at(sema->ast, te->type_expr.aggregate_list.data[i]); if (m && m->kind == SPL_AST_TYPE_DECL) sema_type_decl(sema, te->type_expr.aggregate_list.data[i], agg_scope, def); } /* pass2: 成员 + 方法 def（兄弟方法全部登记后再检查体） */ for (usize i = 0; i < te->type_expr.aggregate_list.size; i++) { spl_ast_node_ref_t mref = te->type_expr.aggregate_list.data[i]; spl_ast_node_t *m = node_at(sema->ast, mref); if (!m) continue; switch (m->kind) { case SPL_AST_MEMBER_DECL: { spl_type_id_t ft = m->member_decl.type_expr ? resolve_type_expr(sema, m->member_decl.type_expr) : 0; /* resolve_type_expr 可能 alloc 新类型 → 两表 realloc，须重新取节点 */ spl_type_node_t *tn = spl_type_node(&sema->type, tid); /* 每个 MEMBER_DECL 建一个 SPL_DEF_MEMBER def（结构字段/枚举变体） */ spl_type_id_t mtype = 0; if (tn->kind == SPL_TYPE_ENUM) { mtype = ft ? ft : tid; /* 哨兵：无载荷变体 = 枚举自身 tid */ vec_push(tn->enum_type.variants, mtype); } else { mtype = ft; vec_push(tn->agg_field_types, ft); } spl_def_id_t mdef = def_alloc(sema, SPL_DEF_MEMBER); def_at(sema, mdef)->type_id = mtype; def_at(sema, mdef)->var_def.name = m->member_decl.name; agg_add_member(sema, def, m->member_decl.name, mtype, agg_scope, mdef); m->resolved_def_id = mdef; /* 注解：member_decl → 其 SPL_DEF_MEMBER def */ break; } case SPL_AST_FN_DECL: case SPL_AST_FN_DEFINE: sema_fn_decl(sema, mref, agg_scope, def); break; case SPL_AST_TYPE_DECL: /* 已在 pass1 处理 */ break; case SPL_AST_VAR_DECL: sema_var_decl(sema, mref, agg_scope, def); break; case SPL_AST_CONST_DECL: sema_const_decl(sema, mref, agg_scope, def); break; default: break; } } /* pass3: 检查方法体（当前聚合所有方法已登记，兄弟可互调） */ for (usize i = 0; i < te->type_expr.aggregate_list.size; i++) { spl_ast_node_ref_t mref = te->type_expr.aggregate_list.data[i]; spl_ast_node_t *m = node_at(sema->ast, mref); if (m && m->kind == SPL_AST_FN_DEFINE) { spl_def_id_t mdef = find_bare(sema, m->fn_decl.name); check_fn_body(sema, mref, mdef, agg_scope); } } sema->current_scope = save; } /* 嵌套/内联聚合：prepare + resolve 一步完成 */ static spl_type_id_t build_agg(spl_sema_t *sema, spl_ast_node_ref_t ref, spl_scope_id_t parent, const char *name) { agg_handle_t h = agg_prepare(sema, ref); if (!h.tid) return 0; agg_resolve(sema, ref, h.tid, h.def, parent, name); return h.tid; } /* 变量/常量/绑定节点：建 VAR def（不包 SPL_TYPE_ID） */ static void register_binding(spl_sema_t *sema, const char *name, spl_ast_node_ref_t type_expr, spl_scope_id_t scope, spl_def_id_t agg_def, spl_ast_node_ref_t node_ref) { spl_type_id_t t = type_expr ? resolve_type_expr(sema, type_expr) : 0; spl_def_id_t def = new_var_def(sema, name, t, scope); if (!spl_sema_scope_insert(sema, scope, name, def)) sema_error(sema, 0, "duplicate symbol"); if (agg_def) agg_add_member(sema, agg_def, name, t, scope, def); if (node_ref) { spl_ast_node_t *nn = node_at(sema->ast, node_ref); if (nn) nn->resolved_def_id = def; /* 注解：var/const 声明 → 其 VAR def */ } } static void sema_var_decl(spl_sema_t *sema, spl_ast_node_ref_t ref, spl_scope_id_t scope, spl_def_id_t agg_def) { spl_ast_node_t *n = node_at(sema->ast, ref); if (!n) return; register_binding(sema, n->var_decl.name, n->var_decl.type_expr, scope, agg_def, ref); } static void sema_const_decl(spl_sema_t *sema, spl_ast_node_ref_t ref, spl_scope_id_t scope, spl_def_id_t agg_def) { spl_ast_node_t *n = node_at(sema->ast, ref); if (!n) return; register_binding(sema, n->const_decl.name, n->const_decl.type_expr, scope, agg_def, ref); /* 标记 const：赋值检查拒绝写入 */ spl_ast_node_t *nn = node_at(sema->ast, ref); if (nn && nn->resolved_def_id) { spl_def_node_t *d = def_at(sema, nn->resolved_def_id); if (d) d->var_def.is_const = 1; } } /* fn 声明：建 fn type + FN_PARAMS def + 登记名字。不建 fn_scope（由 check 新建）。 * 形参只把 name/type 记入 fn_params_def（def_id=0），实际参数 def 在 check 时创建。 */ static void sema_fn_decl(spl_sema_t *sema, spl_ast_node_ref_t ref, spl_scope_id_t scope, spl_def_id_t agg_def) { spl_ast_node_t *n = node_at(sema->ast, ref); if (!n) return; spl_type_id_vec_t params; vec_init(params); for (usize i = 0; i < n->fn_decl.param_list.size; i++) { spl_ast_node_t *pd = node_at(sema->ast, n->fn_decl.param_list.data[i]); spl_type_id_t pt = 0; if (pd && pd->param_decl.type_expr) pt = resolve_type_expr(sema, pd->param_decl.type_expr); vec_push(params, pt); } spl_type_id_t ret = 0; if (n->fn_decl.type_expr) ret = resolve_type_expr(sema, n->fn_decl.type_expr); else ret = spl_type_void(&sema->type); spl_type_id_t fid = spl_type_fn(&sema->type, params, ret); spl_def_id_t fdef = def_alloc(sema, SPL_DEF_FN_PARAMS); spl_def_node_t *d = def_at(sema, fdef); d->type_id = fid; vec_init(d->fn_params_def); for (usize i = 0; i < n->fn_decl.param_list.size; i++) { spl_ast_node_t *pd = node_at(sema->ast, n->fn_decl.param_list.data[i]); if (!pd) continue; spl_var_def_t pv = {pd->param_decl.name, 0, params.data[i], 0}; vec_push(d->fn_params_def, pv); } if (!spl_sema_scope_insert(sema, scope, n->fn_decl.name, fdef)) sema_error(sema, ref, "duplicate function name"); if (agg_def) agg_add_member(sema, agg_def, n->fn_decl.name, fid, scope, fdef); n->resolved_def_id = fdef; /* 注解：fn 声明 → 其 FN_PARAMS def */ } static void sema_type_decl(spl_sema_t *sema, spl_ast_node_ref_t ref, spl_scope_id_t scope, spl_def_id_t agg_def) { spl_ast_node_t *n = node_at(sema->ast, ref); if (!n) return; spl_ast_node_t *te = node_at(sema->ast, n->type_decl.type_expr); spl_type_id_t tid = 0; spl_def_id_t def = 0; if (te && (te->type_expr.kind == SPL_AST_TYPE_STRUCT || te->type_expr.kind == SPL_AST_TYPE_UNION || te->type_expr.kind == SPL_AST_TYPE_ENUM)) { agg_handle_t h = agg_prepare(sema, n->type_decl.type_expr); tid = h.tid; def = h.def; agg_resolve(sema, n->type_decl.type_expr, h.tid, h.def, scope, n->type_decl.name); } else if (te) { tid = resolve_type_expr(sema, n->type_decl.type_expr); def = def_alloc(sema, SPL_DEF_ALIAS); spl_def_node_t *d = def_at(sema, def); d->type_id = tid; d->type_def.name = n->type_decl.name; d->type_def.def_id = def; d->type_def.type_id = tid; d->type_def.scope_id = scope; } if (!tid || !def) return; if (!spl_sema_scope_insert(sema, scope, n->type_decl.name, def)) sema_error(sema, ref, "duplicate type name"); if (agg_def) agg_add_member(sema, agg_def, n->type_decl.name, tid, scope, def); /* 嵌套类型提升到文件作用域：兄弟聚合可裸名引用（如 Lexer 方法内 Tag.eof） */ if (agg_def) spl_sema_scope_insert(sema, sema->root_scope, n->type_decl.name, def); n->resolved_def_id = def; /* 注解：type_decl → 其 AGG/ALIAS def */ } /* ================================================================ * 类型检查（阶段 B） * ================================================================ */ static spl_type_id_t infer_expr(spl_sema_t *sema, spl_ast_node_ref_t ref); /* 类型节点快捷查询 */ static spl_type_node_t *type_node(spl_sema_t *sema, spl_type_id_t tid) { return spl_type_node(&sema->type, tid); } static bool is_int_tid(spl_sema_t *sema, spl_type_id_t tid) { spl_type_node_t *t = type_node(sema, tid); return t && t->kind == SPL_TYPE_INT; } static bool is_numeric_tid(spl_sema_t *sema, spl_type_id_t tid) { spl_type_node_t *t = type_node(sema, tid); return t && (t->kind == SPL_TYPE_INT || t->kind == SPL_TYPE_FLOAT); } static bool is_agg_tid(spl_sema_t *sema, spl_type_id_t tid) { spl_type_node_t *t = type_node(sema, tid); return t && (t->kind == SPL_TYPE_STRUCT || t->kind == SPL_TYPE_UNION || t->kind == SPL_TYPE_ENUM); } /* 表达式是否为整数字面量（含一元负号） */ static bool expr_is_int_literal(spl_sema_t *sema, spl_ast_node_ref_t ref) { spl_ast_node_t *n = node_at(sema->ast, ref); if (!n || n->kind != SPL_AST_EXPR) return false; switch (n->expr.op) { case SPL_AST_PRIMARY_EXPR: { spl_ast_node_t *pn = node_at(sema->ast, n->expr.op_expr.left); int k = pn && pn->kind == SPL_AST_EXPR ? (int)pn->primary_expr.kind : -1; return k == SPL_AST_INTEGER || k == SPL_AST_CHAR_LIT; } case SPL_AST_PREFIX_EXPR: return expr_is_int_literal(sema, n->expr.op_expr.left); default: return false; } } /* 浮点字面量（含负号前缀）：允许拓宽/窄化到目标浮点类型 */ static bool expr_is_float_literal(spl_sema_t *sema, spl_ast_node_ref_t ref) { spl_ast_node_t *n = node_at(sema->ast, ref); if (!n || n->kind != SPL_AST_EXPR) return false; switch (n->expr.op) { case SPL_AST_PRIMARY_EXPR: { spl_ast_node_t *pn = node_at(sema->ast, n->expr.op_expr.left); int k = pn && pn->kind == SPL_AST_EXPR ? (int)pn->primary_expr.kind : -1; return k == SPL_AST_FLOAT; } case SPL_AST_PREFIX_EXPR: return expr_is_float_literal(sema, n->expr.op_expr.left); default: return false; } } /* 字面量（整型或浮点）：检查时允许类型拓宽 */ static bool expr_is_literal(spl_sema_t *sema, spl_ast_node_ref_t ref) { return expr_is_int_literal(sema, ref) || expr_is_float_literal(sema, ref); } /* 打开 SPL_TYPE_ID 绑定节点，返回真实类型（newtype 预留；当前无调用产生该节点） */ static spl_type_id_t underlying(spl_sema_t *sema, spl_type_id_t tid) { spl_type_node_t *t = type_node(sema, tid); if (t && t->kind == SPL_TYPE_ID) return t->type_id; return tid; } /* 结构递归相等：ptr/slice/array/fn 等构造类型按结构比较， * 因为 spl_type_ptr/slice/array 不去重，相同结构可能有不同 id */ static int type_same(spl_sema_t *sema, spl_type_id_t a, spl_type_id_t b) { if (a == b) return 1; a = underlying(sema, a); b = underlying(sema, b); if (a == b) return 1; spl_type_node_t *na = type_node(sema, a); spl_type_node_t *nb = type_node(sema, b); if (!na || !nb || na->kind != nb->kind) return 0; switch (na->kind) { case SPL_TYPE_INT: return na->int_type.bits == nb->int_type.bits && na->int_type.is_signed == nb->int_type.is_signed; case SPL_TYPE_FLOAT: return na->float_type.bits == nb->float_type.bits; case SPL_TYPE_PTR: return type_same(sema, na->ptr_pointee, nb->ptr_pointee); case SPL_TYPE_SLICE: return type_same(sema, na->slice_element, nb->slice_element); case SPL_TYPE_RANGE: return type_same(sema, na->range_element, nb->range_element); case SPL_TYPE_ARRAY: return na->array_type.len == nb->array_type.len && type_same(sema, na->array_type.element, nb->array_type.element); case SPL_TYPE_FN: { if (na->fn_type.params.size != nb->fn_type.params.size) return 0; for (usize i = 0; i < na->fn_type.params.size; i++) if (!type_same(sema, na->fn_type.params.data[i], nb->fn_type.params.data[i])) return 0; return type_same(sema, na->fn_type.ret, nb->fn_type.ret); } default: return 0; } } /* 兼容性检查：src 可赋给 dst？is_literal 表示 src 是整数字面量 */ /* 返回值：1 兼容，0 不兼容 */ static int type_compatible(spl_sema_t *sema, spl_type_id_t dst, spl_type_id_t src, int is_literal, int *warned) { if (warned) *warned = 0; if (!dst || !src) return 0; dst = underlying(sema, dst); src = underlying(sema, src); spl_type_node_t *d = type_node(sema, dst); spl_type_node_t *s = type_node(sema, src); if (!d || !s) return 0; if (type_same(sema, dst, src)) return 1; /* 整数字面量可拓宽到目标整数 */ if (is_literal && d->kind == SPL_TYPE_INT && s->kind == SPL_TYPE_INT) { /* 字面量值已隐含满足范围（检查时由调用方保证），此处允许拓宽 */ return 1; } /* 浮点字面量可赋值到目标浮点（f64 字面量 → f32 变量，值可表示则允许） */ if (is_literal && d->kind == SPL_TYPE_FLOAT && s->kind == SPL_TYPE_FLOAT) return 1; /* isize/usize（机器字宽）与 i32 混合：比较/算术/传参可用（splc1 与旧测试事实标准） */ if (d->kind == SPL_TYPE_INT && s->kind == SPL_TYPE_INT) { int dbits = d->int_type.bits, sbits = s->int_type.bits; int word = (int)(sizeof(usize) * 8); if ((dbits == word && sbits == 32) || (dbits == 32 && sbits == word)) { if (warned) *warned = 1; return 1; } } /* 数组 [N]T -> 切片 []T */ if (d->kind == SPL_TYPE_SLICE && s->kind == SPL_TYPE_ARRAY) { if (d->slice_element == s->array_type.element) return 1; } /* *T -> *_ 与 *_ -> *T（警告转换；*_ 即 *void） */ if (d->kind == SPL_TYPE_PTR && s->kind == SPL_TYPE_PTR) { spl_type_id_t void_t = spl_type_void(&sema->type); if (d->ptr_pointee == void_t && s->ptr_pointee != void_t) { if (warned) *warned = 1; return 1; } if (s->ptr_pointee == void_t && d->ptr_pointee != void_t) { if (warned) *warned = 1; return 1; } /* *T -> *u8：字节指针视图（splc1 事实标准，如 vm_fwrite(buf:*u8, &x)） */ spl_type_node_t *dtn = type_node(sema, d->ptr_pointee); if (dtn && dtn->kind == SPL_TYPE_INT && dtn->int_type.bits == 8 && dtn->int_type.is_signed == 0 && !type_same(sema, d->ptr_pointee, s->ptr_pointee)) { if (warned) *warned = 1; return 1; } } return 0; } /* expr 是否为 null 字面量（不参与类型推导，需上下文） */ static bool expr_is_null_literal(spl_sema_t *sema, spl_ast_node_ref_t ref) { spl_ast_node_t *n = node_at(sema->ast, ref); if (!n || n->kind != SPL_AST_EXPR) return false; if (n->expr.op == SPL_AST_PRIMARY_EXPR) return expr_is_null_literal(sema, n->expr.op_expr.left); return n->primary_expr.kind == SPL_AST_NULL; } /* 二元算术/位运算：两侧类型一致，或整数字面量拓宽；含指针算术 *T + int */ static spl_type_id_t infer_binary_arith(spl_sema_t *sema, spl_ast_node_ref_t ref, spl_ast_node_t *e) { spl_type_id_t l = infer_expr(sema, e->expr.op_expr.left); spl_type_id_t r = infer_expr(sema, e->expr.op_expr.right); if (!l || !r) { sema_error(sema, ref, "bad operand in arithmetic"); return 0; } l = underlying(sema, l); r = underlying(sema, r); /* 指针算术：*T + int / int + *T / *T - int → *T */ if (e->expr.op == SPL_AST_ADD_EXPR || e->expr.op == SPL_AST_SUB_EXPR) { spl_type_node_t *lt = type_node(sema, l); spl_type_node_t *rt = type_node(sema, r); if (lt && lt->kind == SPL_TYPE_PTR && rt && is_int_tid(sema, r)) return l; if (rt && rt->kind == SPL_TYPE_PTR && lt && is_int_tid(sema, l) && e->expr.op == SPL_AST_ADD_EXPR) return r; } if (l == r) { if (!is_numeric_tid(sema, l)) { sema_error(sema, ref, "arithmetic requires numeric operands"); return 0; } return l; } int ll = expr_is_int_literal(sema, e->expr.op_expr.left); int rl = expr_is_int_literal(sema, e->expr.op_expr.right); if (ll && is_int_tid(sema, r)) { int w = 0; if (type_compatible(sema, r, l, 1, &w)) return r; } if (rl && is_int_tid(sema, l)) { int w = 0; if (type_compatible(sema, l, r, 1, &w)) return l; } /* isize/usize 与 i32 混合算术：结果取左操作数类型 */ if (is_int_tid(sema, l) && is_int_tid(sema, r)) { int w = 0; if (type_compatible(sema, l, r, 0, &w)) return l; } sema_error(sema, ref, "type mismatch in arithmetic"); return 0; } /* 比较运算：兼容则返回 bool */ static spl_type_id_t infer_binary_cmp(spl_sema_t *sema, spl_ast_node_ref_t ref, spl_ast_node_t *e) { spl_type_id_t l = infer_expr(sema, e->expr.op_expr.left); spl_type_id_t r = infer_expr(sema, e->expr.op_expr.right); /* null 与指针比较合法 */ if (expr_is_null_literal(sema, e->expr.op_expr.left)) { if (r && type_node(sema, underlying(sema, r))->kind == SPL_TYPE_PTR) return spl_type_bool(&sema->type); sema_error(sema, ref, "null can only compare with pointers"); return 0; } if (expr_is_null_literal(sema, e->expr.op_expr.right)) { if (l && type_node(sema, underlying(sema, l))->kind == SPL_TYPE_PTR) return spl_type_bool(&sema->type); sema_error(sema, ref, "null can only compare with pointers"); return 0; } if (!l || !r) { sema_error(sema, ref, "bad operand in comparison"); return 0; } int w = 0; if (type_compatible(sema, l, r, expr_is_literal(sema, e->expr.op_expr.right), &w) || type_compatible(sema, r, l, expr_is_literal(sema, e->expr.op_expr.left), &w)) { return spl_type_bool(&sema->type); } sema_error(sema, ref, "type mismatch in comparison"); return 0; } /* 逻辑运算：两侧 bool */ static spl_type_id_t infer_binary_logic(spl_sema_t *sema, spl_ast_node_ref_t ref, spl_ast_node_t *e) { spl_type_id_t l = infer_expr(sema, e->expr.op_expr.left); spl_type_id_t r = infer_expr(sema, e->expr.op_expr.right); if (underlying(sema, l) != underlying(sema, spl_type_bool(&sema->type)) || underlying(sema, r) != underlying(sema, spl_type_bool(&sema->type))) { sema_error(sema, ref, "logical operators require bool operands"); return 0; } return spl_type_bool(&sema->type); } /* 位运算：两侧整数同型或字面量拓宽 */ static spl_type_id_t infer_binary_bit(spl_sema_t *sema, spl_ast_node_ref_t ref, spl_ast_node_t *e) { spl_type_id_t l = infer_expr(sema, e->expr.op_expr.left); spl_type_id_t r = infer_expr(sema, e->expr.op_expr.right); if (!l || !r) { sema_error(sema, ref, "bad operand in bitwise"); return 0; } l = underlying(sema, l); r = underlying(sema, r); if (l == r) { if (!is_int_tid(sema, l)) { sema_error(sema, ref, "bitwise requires integer operands"); return 0; } return l; } int ll = expr_is_int_literal(sema, e->expr.op_expr.left); int rl = expr_is_int_literal(sema, e->expr.op_expr.right); if (ll && is_int_tid(sema, r)) return r; if (rl && is_int_tid(sema, l)) return l; sema_error(sema, ref, "type mismatch in bitwise"); return 0; } static spl_type_id_t infer_binary(spl_sema_t *sema, spl_ast_node_ref_t ref, spl_ast_node_t *e) { switch (e->expr.op) { case SPL_AST_ADD_EXPR: case SPL_AST_SUB_EXPR: case SPL_AST_MUL_EXPR: case SPL_AST_DIV_EXPR: case SPL_AST_MOD_EXPR: return infer_binary_arith(sema, ref, e); case SPL_AST_CMPEQ_EXPR: case SPL_AST_CMPNE_EXPR: case SPL_AST_CMP_LE_EXPR: case SPL_AST_CMP_GE_EXPR: case SPL_AST_CMP_LT_EXPR: case SPL_AST_CMP_GT_EXPR: return infer_binary_cmp(sema, ref, e); case SPL_AST_BOOLOR_EXPR: case SPL_AST_BOOLAND_EXPR: return infer_binary_logic(sema, ref, e); case SPL_AST_BITOR_EXPR: case SPL_AST_BITXOR_EXPR: case SPL_AST_BITAND_EXPR: case SPL_AST_LSHIFT_EXPR: case SPL_AST_RSHIFT_EXPR: return infer_binary_bit(sema, ref, e); default: return 0; } } /* 聚合初始化字面量：目标类型已知时校验字段 */ static spl_type_id_t infer_agg_init(spl_sema_t *sema, spl_ast_node_ref_t ref, spl_ast_node_t *n) { spl_ast_node_t *pn = n->kind == SPL_AST_EXPR ? node_at(sema->ast, n->expr.op_expr.left) : n; if (!pn || pn->primary_expr.kind != SPL_AST_ARGGREGATE_INIT) return 0; spl_type_id_t tid = 0; if (pn->primary_expr.aggregate_init.name) { tid = find_type(sema, pn->primary_expr.aggregate_init.name); if (!tid) { sema_error(sema, ref, "unknown aggregate type in literal"); return 0; } } else { /* 匿名 .{} 依赖上下文，由调用方（赋值/初始化）填充 */ return 0; } spl_type_node_t *tn = type_node(sema, tid); if (!tn || !is_agg_tid(sema, tid)) { sema_error(sema, ref, "aggregate literal target is not a struct/union/enum"); return 0; } /* 枚举无载荷初始化如 Color { .Red }：仅一个成员且为变体 */ if (tn->kind == SPL_TYPE_ENUM) { usize nitems = n->kind == SPL_AST_EXPR ? node_at(sema->ast, n->expr.op_expr.left)->primary_expr.aggregate_init.expr.size : pn->primary_expr.aggregate_init.expr.size; for (usize i = 0; i < nitems; i++) { spl_ast_node_ref_t iref = (n->kind == SPL_AST_EXPR ? node_at(sema->ast, n->expr.op_expr.left)->primary_expr.aggregate_init.expr : pn->primary_expr.aggregate_init.expr) .data[i]; spl_ast_node_t *item = node_at(sema->ast, iref); if (!item) continue; spl_type_id_t mt = agg_member_type(sema, tid, item->aggregate_init_item.ident); if (!mt) { sema_error(sema, iref, "unknown variant in enum literal"); continue; } if (item->aggregate_init_item.expr) infer_expr(sema, item->aggregate_init_item.expr); } return tid; } /* struct/union：逐字段校验 */ for (usize i = 0; i < (n->kind == SPL_AST_EXPR ? node_at(sema->ast, n->expr.op_expr.left)->primary_expr.aggregate_init.expr.size : pn->primary_expr.aggregate_init.expr.size); i++) { spl_ast_node_ref_t iref = (n->kind == SPL_AST_EXPR ? node_at(sema->ast, n->expr.op_expr.left)->primary_expr.aggregate_init.expr : pn->primary_expr.aggregate_init.expr) .data[i]; spl_ast_node_t *item = node_at(sema->ast, iref); if (!item) continue; spl_type_id_t mt = agg_member_type(sema, tid, item->aggregate_init_item.ident); if (!mt) { sema_error(sema, iref, "unknown field in aggregate literal"); continue; } if (item->aggregate_init_item.expr) { spl_type_id_t et = infer_expr(sema, item->aggregate_init_item.expr); int w = 0; if (!expr_is_null_literal(sema, item->aggregate_init_item.expr) && et && !type_compatible(sema, mt, et, expr_is_literal(sema, item->aggregate_init_item.expr), &w)) { sema_error(sema, iref, "field type mismatch in aggregate literal"); } } } return tid; } /* 数组字面量 [N]T{...} */ static spl_type_id_t infer_array_lit(spl_sema_t *sema, spl_ast_node_ref_t ref, spl_ast_node_t *n) { spl_ast_node_t *pn = n->kind == SPL_AST_EXPR ? node_at(sema->ast, n->expr.op_expr.left) : n; spl_type_id_t elem = 0; if (pn->primary_expr.array_lit_expr.type_expr) { elem = resolve_type_expr(sema, pn->primary_expr.array_lit_expr.type_expr); if (!elem) sema_error(sema, ref, "bad array literal element type"); } for (usize i = 0; i < pn->primary_expr.array_lit_expr.expr_list.size; i++) { spl_type_id_t et = infer_expr(sema, pn->primary_expr.array_lit_expr.expr_list.data[i]); if (elem) { int w = 0; if (!type_compatible( sema, elem, et, expr_is_literal(sema, pn->primary_expr.array_lit_expr.expr_list.data[i]), &w)) { sema_error(sema, pn->primary_expr.array_lit_expr.expr_list.data[i], "element type mismatch in array literal"); } } } return spl_type_array(&sema->type, elem ? elem : 0, (usize)pn->primary_expr.array_lit_expr.integer); } /* 标识符：scope 查找（def → 类型） */ static spl_type_id_t infer_ident(spl_sema_t *sema, spl_ast_node_ref_t ref, spl_ast_node_t *n) { spl_ast_node_t *pn = n->kind == SPL_AST_EXPR ? node_at(sema->ast, n->expr.op_expr.left) : n; spl_def_id_t def = find_bare(sema, pn->primary_expr.ident); spl_type_id_t t = def_type(sema, def); if (!t) { sema_error(sema, ref, "undefined identifier"); return 0; } /* 注解：IDENT 引用 → 其符号 def（var 用 VAR、fn 用 FN_PARAMS 等） */ pn->resolved_def_id = def; return t; } /* 表达式 ref 解析到的 def：取内层节点注解；裸 ident 兜底 find_bare */ static spl_def_id_t expr_def_at(spl_sema_t *sema, spl_ast_node_ref_t ref) { spl_ast_node_t *n = node_at(sema->ast, ref); if (!n || n->kind != SPL_AST_EXPR) return 0; spl_ast_node_t *inner = node_at(sema->ast, n->expr.op_expr.left); if (!inner) return 0; if (inner->resolved_def_id) return inner->resolved_def_id; if (n->expr.op == SPL_AST_PRIMARY_EXPR && inner->primary_expr.kind == SPL_AST_IDENT) return find_bare(sema, inner->primary_expr.ident); return 0; } static spl_type_id_t infer_postfix(spl_sema_t *sema, spl_ast_node_ref_t ref, spl_ast_node_t *n); static spl_type_id_t infer_prefix(spl_sema_t *sema, spl_ast_node_ref_t ref, spl_ast_node_t *n); static void check_stmt(spl_sema_t *sema, spl_ast_node_ref_t ref, spl_sema_ctx_t ctx); static spl_type_id_t infer_primary(spl_sema_t *sema, spl_ast_node_ref_t ref, spl_ast_node_t *n) { spl_ast_node_t *pn = n->kind == SPL_AST_EXPR ? node_at(sema->ast, n->expr.op_expr.left) : n; if (!pn) { sema_error(sema, ref, "invalid primary expression"); return 0; } switch (pn->primary_expr.kind) { case SPL_AST_INTEGER: return spl_type_int(&sema->type, 32, 1); case SPL_AST_FLOAT: return spl_type_float(&sema->type, 64); case SPL_AST_CHAR_LIT: /* 字符字面量即字节立即数（u8），经字面量宽化可赋给任意整数类型 */ return spl_type_int(&sema->type, 8, 0); case SPL_AST_STRING_LIT: /* 字符串字面量：底层为 *u8（NUL 终止）。splc1 自举源中一律传 *u8， * SPL.md 建议 []u8，但 IR 层按 *u8 处理，此处与实现一致 */ return spl_type_ptr(&sema->type, spl_type_int(&sema->type, 8, 0)); case SPL_AST_TRUE: case SPL_AST_FALSE: return spl_type_bool(&sema->type); case SPL_AST_NULL: return 0; /* null 无独立类型，需上下文 */ case SPL_AST_IDENT: return infer_ident(sema, ref, n); case SPL_AST_ARGGREGATE_INIT: return infer_agg_init(sema, ref, n); case SPL_AST_EXPR_EXPR: return infer_expr(sema, pn->primary_expr.expr); case SPL_AST_ARRAY_LIT: return infer_array_lit(sema, ref, n); case SPL_AST_BUILTIN_EXPR: { /* 内置调用：类型按注册表约定，参数按需推断（offsetof 字段名参数非表达式） */ const spl_builtin_t *bi = spl_builtin_lookup(pn->primary_expr.builtin_expr.ident); if (!bi) { sema_error(sema, ref, "unknown builtin"); return 0; } usize nargs = pn->primary_expr.builtin_expr.expr_list.size; if (nargs < (usize)bi->min_args || (bi->max_args >= 0 && nargs > (usize)bi->max_args)) { char buf[96]; snprintf(buf, sizeof buf, "builtin @%s: arg count mismatch", bi->name); sema_error(sema, ref, buf); return 0; } for (usize i = 0; i < nargs; i++) { /* offsetof 第二参数为字段标识符，不按表达式推断 */ if (bi->kind == SPL_BUILTIN_OFFSET_OF && i == 1) continue; infer_expr(sema, pn->primary_expr.builtin_expr.expr_list.data[i]); } if (bi->ret_is_void) return spl_type_void(&sema->type); if (bi->kind == SPL_BUILTIN_SIZE_OF || bi->kind == SPL_BUILTIN_BITSIZE_OF || bi->kind == SPL_BUILTIN_ALIGN_OF || bi->kind == SPL_BUILTIN_OFFSET_OF || bi->kind == SPL_BUILTIN_FIELD_COUNT) return spl_type_int(&sema->type, sizeof(usize) * 8, 0); sema_error(sema, ref, "unsupported builtin"); return 0; } case SPL_AST_BLOCK_EXPR: { /* 块表达式：有独立 scope；逐语句检查，返回末尾表达式类型（无则 void） */ spl_ast_node_ref_vec_t *items = &pn->primary_expr.block_expr; spl_scope_id_t scope = spl_sema_scope_alloc(sema); sema->scopes.data[scope].parent = sema->current_scope; spl_scope_id_t save = sema->current_scope; sema->current_scope = scope; spl_type_id_t rt = spl_type_void(&sema->type); spl_sema_ctx_t vctx = {0}; /* 表达式块内的 ret 暂不强制（罕见） */ for (usize i = 0; i < items->size; i++) { if (i + 1 == items->size) { spl_ast_node_t *last = node_at(sema->ast, items->data[i]); if (last && last->kind == SPL_AST_EXPR && !(last->expr.op == SPL_AST_PRIMARY_EXPR)) { rt = infer_expr(sema, items->data[i]); continue; } if (last && last->expr.op == SPL_AST_PRIMARY_EXPR) { spl_ast_node_t *in = node_at(sema->ast, last->expr.op_expr.left); if (in && in->primary_expr.kind == SPL_AST_BLOCK_EXPR) { rt = infer_primary(sema, items->data[i], last); continue; } } } check_stmt(sema, items->data[i], vctx); } sema->current_scope = save; return rt; } default: return 0; } } /* 前缀运算 */ static spl_type_id_t infer_prefix(spl_sema_t *sema, spl_ast_node_ref_t ref, spl_ast_node_t *n) { spl_ast_node_t *pf = n->kind == SPL_AST_EXPR ? node_at(sema->ast, n->expr.op_expr.left) : n; if (!pf) return 0; spl_type_id_t inner = infer_expr(sema, pf->prefix_expr.postfix_expr); if (!inner) return 0; inner = underlying(sema, inner); switch (pf->prefix_expr.kind) { case SPL_AST_MINUS_EXPR: if (!is_numeric_tid(sema, inner)) { sema_error(sema, ref, "unary minus requires numeric"); return 0; } return inner; case SPL_AST_BANG_EXPR: if (inner != underlying(sema, spl_type_bool(&sema->type))) { sema_error(sema, ref, "! requires bool"); return 0; } return spl_type_bool(&sema->type); case SPL_AST_TILDE_EXPR: if (!is_int_tid(sema, inner)) { sema_error(sema, ref, "~ requires integer"); return 0; } return inner; case SPL_AST_AMPERSAND_EXPR: if (type_node(sema, inner) && type_node(sema, inner)->kind == SPL_TYPE_FN) return inner; /* &foo 为函数值（fn 类型），非常规指针 */ return spl_type_ptr(&sema->type, inner); case SPL_AST_ASTERISK_EXPR: /* 前缀 * 不在 SPL 中使用（解引用为后缀 .*），忽略 */ return inner; default: return 0; } } /* 后缀运算 */ static spl_type_id_t infer_postfix(spl_sema_t *sema, spl_ast_node_ref_t ref, spl_ast_node_t *n) { spl_ast_node_t *pf = n->kind == SPL_AST_EXPR ? node_at(sema->ast, n->expr.op_expr.left) : n; if (!pf) return 0; spl_type_id_t base = infer_expr(sema, pf->postfix_expr.primary_expr); if (!base) return 0; base = underlying(sema, base); switch (pf->postfix_expr.kind) { case SPL_AST_FIELD_EXPR: { spl_type_node_t *t = type_node(sema, base); /* 指针自动解引用一层 */ if (t && t->kind == SPL_TYPE_PTR) base = underlying(sema, t->ptr_pointee); /* 注解：FIELD 节点 → 被访问聚合（自动解引用后）的 AGG def；非聚合为 0 */ pf->resolved_def_id = def_for_type(sema, base); t = type_node(sema, base); if (!t) { sema_error(sema, ref, "field access on non-aggregate"); return 0; } /* 切片字段 len/ptr 优先于聚合检查 */ if (t->kind == SPL_TYPE_SLICE) { if (strcmp(pf->postfix_expr.field_expr, "len") == 0) return spl_type_int(&sema->type, sizeof(usize) * 8, 0); if (strcmp(pf->postfix_expr.field_expr, "ptr") == 0) return spl_type_ptr(&sema->type, t->slice_element); sema_error(sema, ref, "unknown slice field"); return 0; } /* Range 内置字段 begin/end：元素类型 */ if (t->kind == SPL_TYPE_RANGE) { if (strcmp(pf->postfix_expr.field_expr, "begin") == 0 || strcmp(pf->postfix_expr.field_expr, "end") == 0) return t->range_element; sema_error(sema, ref, "unknown range field"); return 0; } if (!is_agg_tid(sema, base)) { sema_error(sema, ref, "field access on non-aggregate"); return 0; } spl_type_id_t mt = agg_member_type(sema, base, pf->postfix_expr.field_expr); if (!mt) { sema_error(sema, ref, "unknown field"); return 0; } /* 枚举变体表达式：带载荷变体（payload 为 struct/整数）整体值为枚举类型； * 方法(fn)/嵌套类型/无载荷固标保持 member 类型 */ spl_type_node_t *mtt = mt ? type_node(sema, underlying(sema, mt)) : NULL; if (t && t->kind == SPL_TYPE_ENUM && mtt && (mtt->kind == SPL_TYPE_STRUCT || mtt->kind == SPL_TYPE_INT)) return base; return mt; } case SPL_AST_DEREF_EXPR: { spl_type_node_t *t = type_node(sema, base); if (!t || t->kind != SPL_TYPE_PTR) { sema_error(sema, ref, ".* requires pointer"); return 0; } /* *_（即 *void）类型已丢失，不可解引用，须先转换为具体指针 */ spl_type_id_t pt = underlying(sema, t->ptr_pointee); spl_type_node_t *ptn = type_node(sema, pt); if (ptn && ptn->kind == SPL_TYPE_VOID) { sema_error(sema, ref, "cannot dereference `*_`; cast to a concrete pointer first"); return 0; } return underlying(sema, t->ptr_pointee); } case SPL_AST_INDEX_EXPR: { spl_type_node_t *t = type_node(sema, base); spl_type_id_t idx = infer_expr(sema, pf->postfix_expr.index_expr); t = type_node(sema, base); if (!is_int_tid(sema, underlying(sema, idx))) { sema_error(sema, ref, "index requires integer"); return 0; } if (t && t->kind == SPL_TYPE_ARRAY) return t->array_type.element; if (t && t->kind == SPL_TYPE_SLICE) return t->slice_element; if (t && t->kind == SPL_TYPE_PTR) return underlying(sema, t->ptr_pointee); sema_error(sema, ref, "index requires array/slice/pointer"); return 0; } case SPL_AST_SLICE_EXPR: { spl_type_node_t *t = type_node(sema, base); if (pf->postfix_expr.slice_expr.begin) infer_expr(sema, pf->postfix_expr.slice_expr.begin); if (pf->postfix_expr.slice_expr.end) infer_expr(sema, pf->postfix_expr.slice_expr.end); t = type_node(sema, base); if (t && t->kind == SPL_TYPE_ARRAY) return spl_type_slice(&sema->type, t->array_type.element); if (t && t->kind == SPL_TYPE_SLICE) return spl_type_slice(&sema->type, t->slice_element); sema_error(sema, ref, "slice requires array/slice"); return 0; } case SPL_AST_CALL_EXPR: { spl_type_node_t *t = type_node(sema, base); if (!t || t->kind != SPL_TYPE_FN) { sema_error(sema, ref, "call requires function type"); return 0; } /* 注解：CALL 节点 → 被调 fn 的 def（从 callee primary 节点/裸名解析） */ pf->resolved_def_id = expr_def_at(sema, pf->postfix_expr.primary_expr); spl_ast_node_ref_vec_t *args = &pf->postfix_expr.call_expr; /* 变参 fn（如 vm_printf）最后一个形参 name=NULL 且类型可为 0 */ /* 注意：infer_expr 可能新分配类型使 type_table realloc，t 会失效，须每次刷新 */ usize nparams = t->fn_type.params.size; for (usize i = 0; i < args->size; i++) { spl_type_id_t at = infer_expr(sema, args->data[i]); t = type_node(sema, base); if (i < nparams && t && t->fn_type.params.data[i]) { int w = 0; if (!expr_is_null_literal(sema, args->data[i]) && at && !type_compatible(sema, t->fn_type.params.data[i], at, expr_is_literal(sema, args->data[i]), &w)) { sema_error(sema, args->data[i], "argument type mismatch"); } } } t = type_node(sema, base); return t ? t->fn_type.ret : 0; } case SPL_AST_AS_EXPR: { spl_type_id_t st = infer_expr(sema, pf->postfix_expr.primary_expr); if (!st) return 0; spl_type_id_t dt = 0; if (pf->postfix_expr.type_expr) { /* 未知类型已由 resolve_type_atom 报错，此处不重复报"缺目标类型" */ dt = resolve_type_expr(sema, pf->postfix_expr.type_expr); } else { sema_error(sema, ref, "as requires a target type"); } if (!dt) return 0; return dt; } default: return 0; } } /* 表达式类型推断 */ static spl_type_id_t infer_expr(spl_sema_t *sema, spl_ast_node_ref_t ref) { if (!ref) return 0; spl_ast_node_t *n = node_at(sema->ast, ref); if (!n) return 0; spl_type_id_t tid = 0; if (n->kind == SPL_AST_EXPR) { switch (n->expr.op) { case SPL_AST_PRIMARY_EXPR: tid = infer_primary(sema, ref, n); break; case SPL_AST_PREFIX_EXPR: tid = infer_prefix(sema, ref, n); break; case SPL_AST_POSTFIX_EXPR: tid = infer_postfix(sema, ref, n); break; case SPL_AST_RANGE_EXPR: { spl_type_id_t l = 0, r = 0; if (n->expr.op_expr.left) l = underlying(sema, infer_expr(sema, n->expr.op_expr.left)); if (n->expr.op_expr.right) r = underlying(sema, infer_expr(sema, n->expr.op_expr.right)); if ((l && !is_int_tid(sema, l)) || (r && !is_int_tid(sema, r)) || (!l && !r)) { sema_error(sema, ref, "range bounds must be integers"); return 0; } return spl_type_range(&sema->type, r ? r : l); } case SPL_AST_ASSIGN_EXPR: case SPL_AST_ASSIGN_ADD_EXPR: case SPL_AST_ASSIGN_sUB_EXPR: case SPL_AST_ASSIGN_MUL_EXPR: case SPL_AST_ASSIGN_DIV_EXPR: case SPL_AST_ASSIGN_MOD_EXPR: case SPL_AST_ASSIGN_AND_EXPR: case SPL_AST_ASSIGN_OR_EXPR: case SPL_AST_ASSIGN_XOR_EXPR: case SPL_AST_ASSIGN_LSHIFT_EXPR: case SPL_AST_ASSIGN_USHIFT_EXPR: { spl_type_id_t l = infer_expr(sema, n->expr.op_expr.left); spl_type_id_t r = infer_expr(sema, n->expr.op_expr.right); if (!l || (!r && !expr_is_null_literal(sema, n->expr.op_expr.right))) { sema_error(sema, ref, "bad assignment"); return 0; } /* 不可写检查：赋值目标为 const 变量时拒绝 */ { spl_ast_node_t *lhs = node_at(sema->ast, n->expr.op_expr.left); if (lhs && lhs->kind == SPL_AST_EXPR && lhs->expr.op == SPL_AST_PRIMARY_EXPR) { spl_ast_node_t *lpn = node_at(sema->ast, lhs->expr.op_expr.left); if (lpn && lpn->kind == SPL_AST_EXPR && lpn->primary_expr.kind == SPL_AST_IDENT && lpn->resolved_def_id) { spl_def_node_t *ld = def_at(sema, lpn->resolved_def_id); if (ld && ld->kind == SPL_DEF_VAR && ld->var_def.is_const) { sema_error(sema, ref, "cannot assign to const"); return 0; } } } } int w = 0; if (!expr_is_null_literal(sema, n->expr.op_expr.right) && !type_compatible(sema, l, r, expr_is_literal(sema, n->expr.op_expr.right), &w)) { sema_error(sema, ref, "assignment type mismatch"); return 0; } return l; } default: tid = infer_binary(sema, ref, n); break; } } return tid; } /* ---- 语句类型检查 ---- */ static void check_stmt(spl_sema_t *sema, spl_ast_node_ref_t ref, spl_sema_ctx_t ctx); static void check_block(spl_sema_t *sema, spl_ast_node_ref_vec_t *block, spl_scope_id_t parent, spl_sema_ctx_t ctx); static spl_type_id_t infer_agg_init_with_type(spl_sema_t *sema, spl_ast_node_ref_t ref, spl_type_id_t expect); /* var/const 初始化与类型注解兼容性检查；name 用于 `var x := e` 推导类型回写 */ static void check_var_init(spl_sema_t *sema, spl_ast_node_ref_t ref, const char *name, spl_ast_node_ref_t type_expr, spl_ast_node_ref_t init_expr, spl_sema_ctx_t ctx) { (void)ctx; (void)type_expr; /* dt 取自已登记 def 的类型（check_block 已预登记），避免二次解析重复报错 */ spl_type_id_t dt = 0; if (name) { spl_scope_id_t cur = sema->current_scope; while (cur) { spl_def_id_t val = 0; if (map_get(sema->scopes.data[cur].symbols, name, &val)) { dt = def_type(sema, val); break; } cur = sema->scopes.data[cur].parent; } } spl_type_id_t it = 0; if (init_expr) { it = infer_expr(sema, init_expr); if (!it && !expr_is_null_literal(sema, init_expr)) { /* 匿名聚合依赖上下文类型 */ spl_ast_node_t *in = node_at(sema->ast, init_expr); if (in && in->kind == SPL_AST_EXPR && in->expr.op == SPL_AST_PRIMARY_EXPR) { spl_ast_node_t *pn = node_at(sema->ast, in->expr.op_expr.left); if (pn && pn->primary_expr.kind == SPL_AST_ARGGREGATE_INIT && dt) { spl_type_id_t save_scope = sema->current_scope; it = infer_agg_init_with_type(sema, init_expr, dt); sema->current_scope = save_scope; } } } if (dt) { int w = 0; if (!expr_is_null_literal(sema, init_expr) && it && !type_compatible(sema, dt, it, expr_is_literal(sema, init_expr), &w)) { sema_error(sema, ref, "initializer type mismatch"); } else if (w) { sema_warn(sema, ref, "pointer conversion involves wildcard"); } } else if (it && name) { /* `var x := e` 推导类型回写 binding def */ spl_scope_id_t cur = sema->current_scope; while (cur) { spl_def_id_t val = 0; if (map_get(sema->scopes.data[cur].symbols, name, &val)) { spl_def_node_t *d = def_at(sema, val); if (d && d->kind == SPL_DEF_VAR) { d->type_id = it; d->var_def.type_id = it; } break; } cur = sema->scopes.data[cur].parent; } } } } /* 带期望类型的匿名聚合推断 */ static spl_type_id_t infer_agg_init_with_type(spl_sema_t *sema, spl_ast_node_ref_t ref, spl_type_id_t expect) { spl_ast_node_t *n = node_at(sema->ast, ref); spl_ast_node_t *pn = n->kind == SPL_AST_EXPR ? node_at(sema->ast, n->expr.op_expr.left) : n; if (!pn || pn->primary_expr.kind != SPL_AST_ARGGREGATE_INIT) return 0; spl_type_id_t tid = underlying(sema, expect); if (!type_node(sema, tid)) return 0; for (usize i = 0; i < pn->primary_expr.aggregate_init.expr.size; i++) { spl_ast_node_ref_t iref = pn->primary_expr.aggregate_init.expr.data[i]; spl_ast_node_t *item = node_at(sema->ast, iref); if (!item) continue; spl_type_node_t *tn = type_node(sema, tid); spl_type_id_t mt = 0; /* 切片 {} 字面量支持 .ptr/.len */ if (tn->kind == SPL_TYPE_SLICE) { if (strcmp(item->aggregate_init_item.ident, "ptr") == 0) mt = spl_type_ptr(&sema->type, tn->slice_element); else if (strcmp(item->aggregate_init_item.ident, "len") == 0) mt = spl_type_int(&sema->type, sizeof(usize) * 8, 0); else { sema_error(sema, iref, "unknown field in slice literal"); continue; } } else if (is_agg_tid(sema, tid)) { mt = agg_member_type(sema, tid, item->aggregate_init_item.ident); if (!mt) { sema_error(sema, iref, "unknown field in aggregate literal"); continue; } } else { sema_error(sema, iref, "literal target not an aggregate"); continue; } if (item->aggregate_init_item.expr) { spl_type_id_t et = infer_expr(sema, item->aggregate_init_item.expr); int w = 0; if (!expr_is_null_literal(sema, item->aggregate_init_item.expr) && et && !type_compatible(sema, mt, et, expr_is_literal(sema, item->aggregate_init_item.expr), &w)) { sema_error(sema, iref, "field type mismatch in aggregate literal"); } } } return tid; } /* for 循环：序列类型 Range/[]T/[N]T，变量个数匹配 */ static void check_for(spl_sema_t *sema, spl_ast_node_ref_t ref, spl_ast_node_t *b, spl_sema_ctx_t ctx) { spl_ast_node_ref_vec_t *expr_vec = &b->block_item.for_statement.expr_vec; char **id_data = b->block_item.for_statement.ident_vec.data; usize id_size = b->block_item.for_statement.ident_vec.size; if (expr_vec->size != id_size) { sema_error(sema, ref, "for: sequence/variable count mismatch"); return; } spl_scope_id_t scope = spl_sema_scope_alloc(sema); sema->scopes.data[scope].parent = sema->current_scope; spl_scope_id_t save = sema->current_scope; sema->current_scope = scope; for (usize i = 0; i < expr_vec->size; i++) { spl_type_id_t et = infer_expr(sema, expr_vec->data[i]); et = underlying(sema, et); spl_type_node_t *t = type_node(sema, et); spl_type_id_t elem = 0; if (t && t->kind == SPL_TYPE_SLICE) elem = t->slice_element; else if (t && t->kind == SPL_TYPE_ARRAY) elem = t->array_type.element; else if (t && t->kind == SPL_TYPE_RANGE) /* Range 遍历绑定元素类型（0..n 通常为 usize 索引遍历） */ elem = t->range_element; else { sema_error(sema, expr_vec->data[i], "for: sequence must be Range/[]T/[N]T"); continue; } spl_def_id_t vdef = new_var_def(sema, id_data[i], elem, scope); spl_sema_scope_insert(sema, scope, id_data[i], vdef); } check_block(sema, &b->block_item.for_statement.block, scope, ctx); sema->current_scope = save; } /* match：被匹配表达式须为枚举/union；臂体类型一致性本轮简化为逐臂检查 */ static void check_match(spl_sema_t *sema, spl_ast_node_ref_t ref, spl_ast_node_t *b, spl_sema_ctx_t ctx) { spl_type_id_t mtype = infer_expr(sema, b->block_item.match_statement.expr); mtype = underlying(sema, mtype); spl_type_node_t *t = type_node(sema, mtype); /* 指针自动解引用 */ if (t && t->kind == SPL_TYPE_PTR) mtype = underlying(sema, t->ptr_pointee); t = type_node(sema, mtype); if (t && t->kind != SPL_TYPE_ENUM && t->kind != SPL_TYPE_UNION && !is_int_tid(sema, mtype)) { sema_error(sema, b->block_item.match_statement.expr, "match subject must be enum/union/integer"); } spl_ast_node_ref_vec_t *arms = &b->block_item.match_statement.paced_exprs; spl_ast_node_ref_vec_t *bodies = &b->block_item.match_statement.match_block; if (arms->size != bodies->size) { sema_error(sema, ref, "match: arm pattern/body count mismatch"); return; } /* 穷举检查：enum 必须覆盖所有变体，或含通配 _（含表达式的整数 match 免检） */ { spl_def_id_t adef = def_for_type(sema, mtype); spl_def_node_t *ad = adef ? &sema->type.def_table.data[adef] : NULL; int is_enum_agg = ad && ad->kind == SPL_DEF_AGG; if (is_enum_agg) { int has_wild = 0; usize covered = 0; for (usize i = 0; i < arms->size; i++) { spl_ast_node_t *pk = node_at(sema->ast, arms->data[i]); if (!pk) continue; /* _ 通配：ident 与 expr 均为空 */ if (!pk->packed_expr.ident && !pk->packed_expr.expr) { has_wild = 1; break; } if (pk->packed_expr.ident) { /* 变体被覆盖：匹配臂中出现的合法变体计数 */ if (agg_member_type(sema, mtype, pk->packed_expr.ident)) covered++; } } if (!has_wild && covered < ad->agg_def.size) sema_error(sema, ref, "match must be exhaustive"); } } for (usize i = 0; i < arms->size; i++) { spl_ast_node_t *pk = node_at(sema->ast, arms->data[i]); if (!pk) continue; /* 每个臂体是 BLOCK_EXPR，有自己的 scope */ spl_scope_id_t scope = spl_sema_scope_alloc(sema); sema->scopes.data[scope].parent = sema->current_scope; spl_scope_id_t save = sema->current_scope; sema->current_scope = scope; if (pk->packed_expr.ident) { /* 变体模式：若带绑定则登记绑定变量 */ if (is_agg_tid(sema, mtype) && pk->packed_expr.bind_ident) { spl_type_id_t vt = agg_member_type(sema, mtype, pk->packed_expr.ident); if (vt && vt != mtype) { spl_def_id_t vdef = new_var_def(sema, pk->packed_expr.bind_ident, vt, scope); spl_sema_scope_insert(sema, scope, pk->packed_expr.bind_ident, vdef); } } else if (is_agg_tid(sema, mtype)) { if (!agg_member_type(sema, mtype, pk->packed_expr.ident)) sema_error(sema, arms->data[i], "unknown variant in match arm"); } } else if (pk->packed_expr.expr) { spl_type_id_t et = infer_expr(sema, pk->packed_expr.expr); int w = 0; if (is_int_tid(sema, mtype) && et && !type_compatible(sema, mtype, et, expr_is_literal(sema, pk->packed_expr.expr), &w)) { sema_error(sema, pk->packed_expr.expr, "match arm pattern type mismatch"); } } /* 检查臂体 */ spl_ast_node_t *body = node_at(sema->ast, bodies->data[i]); if (body && body->kind == SPL_AST_EXPR && body->expr.op == SPL_AST_PRIMARY_EXPR) { spl_ast_node_t *pn = node_at(sema->ast, body->expr.op_expr.left); if (pn && pn->primary_expr.kind == SPL_AST_BLOCK_EXPR) { check_block(sema, &pn->primary_expr.block_expr, scope, ctx); } else { infer_expr(sema, bodies->data[i]); } } sema->current_scope = save; } } /* 单个语句检查 */ static void check_stmt(spl_sema_t *sema, spl_ast_node_ref_t ref, spl_sema_ctx_t ctx) { spl_ast_node_t *b = node_at(sema->ast, ref); if (!b) return; if (b->kind == SPL_AST_EXPR) { /* 裸 { } 块作为语句：不产生值，仅检查其内部 */ if (b->expr.op == SPL_AST_PRIMARY_EXPR) { spl_ast_node_t *pn = node_at(sema->ast, b->expr.op_expr.left); if (pn && pn->primary_expr.kind == SPL_AST_BLOCK_EXPR) { check_block(sema, &pn->primary_expr.block_expr, sema->current_scope, ctx); return; } } infer_expr(sema, ref); return; } switch (b->block_item.kind) { case SPL_AST_VARDECL: { spl_ast_node_t *vd = node_at(sema->ast, b->block_item.var_decl); if (vd) check_var_init(sema, b->block_item.var_decl, vd->var_decl.name, vd->var_decl.type_expr, vd->var_decl.expr, ctx); break; } case SPL_AST_CONSTDECL: { spl_ast_node_t *cd = node_at(sema->ast, b->block_item.const_decl); if (cd) check_var_init(sema, b->block_item.const_decl, cd->const_decl.name, cd->const_decl.type_expr, cd->const_decl.expr, ctx); break; } case SPL_AST_TYPEDECL: break; case SPL_AST_IF_STATEMENT: { spl_type_id_t c = infer_expr(sema, b->block_item.if_statement.expr); c = underlying(sema, c); if (c && c != underlying(sema, spl_type_bool(&sema->type))) sema_error(sema, b->block_item.if_statement.expr, "if condition must be bool"); spl_scope_id_t sc = sema->current_scope; check_block(sema, &b->block_item.if_statement.if_block, sc, ctx); if (b->block_item.if_statement.else_block.size) check_block(sema, &b->block_item.if_statement.else_block, sc, ctx); break; } case SPL_AST_IFVAR_STATEMENT: { spl_ast_node_t *pk = node_at(sema->ast, b->block_item.ifvar_statement.packed_expr); spl_type_id_t vt = 0; if (pk && pk->packed_expr.expr) vt = infer_expr(sema, pk->packed_expr.expr); spl_scope_id_t sc = sema->current_scope; if (pk && pk->packed_expr.bind_ident && vt) { spl_scope_id_t s2 = spl_sema_scope_alloc(sema); sema->scopes.data[s2].parent = sc; spl_def_id_t vdef = new_var_def(sema, pk->packed_expr.bind_ident, underlying(sema, vt), s2); spl_sema_scope_insert(sema, s2, pk->packed_expr.bind_ident, vdef); sema->current_scope = s2; } check_block(sema, &b->block_item.ifvar_statement.if_block, sema->current_scope, ctx); sema->current_scope = sc; if (b->block_item.ifvar_statement.else_block.size) check_block(sema, &b->block_item.ifvar_statement.else_block, sc, ctx); break; } case SPL_AST_WHILE_STATEMENT: { spl_type_id_t c = infer_expr(sema, b->block_item.while_statement.expr); c = underlying(sema, c); if (c && c != underlying(sema, spl_type_bool(&sema->type))) sema_error(sema, b->block_item.while_statement.expr, "while condition must be bool"); check_block(sema, &b->block_item.while_statement.while_block, sema->current_scope, ctx); break; } case SPL_AST_LOOP_STATEMENT: check_block(sema, &b->block_item.loop_statement.loop_block, sema->current_scope, ctx); break; case SPL_AST_FOR_STATEMENT: check_for(sema, ref, b, ctx); break; case SPL_AST_MATCH_STATEMENT: check_match(sema, ref, b, ctx); break; case SPL_AST_RET_STATEMENT: { spl_ast_node_t *rd = b; if (rd->block_item.ret_statement.expr) { spl_type_id_t et = infer_expr(sema, rd->block_item.ret_statement.expr); if (ctx.ret) { if (!expr_is_null_literal(sema, rd->block_item.ret_statement.expr) && et && !type_compatible(sema, ctx.ret, et, expr_is_literal(sema, rd->block_item.ret_statement.expr), NULL)) { sema_error(sema, rd->block_item.ret_statement.expr, "ret type mismatch"); } } } break; } case SPL_AST_BREAK_STATEMENT: case SPL_AST_CONTINUE_STATEMENT: break; case SPL_AST_DEFER_STATEMENT: check_block(sema, &b->block_item.defer_statement.block_or_statement, sema->current_scope, ctx); break; case SPL_AST_EXPR_STATEMENT: if (b->block_item.expr_statement) infer_expr(sema, b->block_item.expr_statement); break; default: break; } } /* 块检查：为块建子 scope 并检查其中语句 */ static void check_block(spl_sema_t *sema, spl_ast_node_ref_vec_t *block, spl_scope_id_t parent, spl_sema_ctx_t ctx) { spl_scope_id_t scope = spl_sema_scope_alloc(sema); sema->scopes.data[scope].parent = parent; spl_scope_id_t save = sema->current_scope; sema->current_scope = scope; /* 变量声明先登记进本块 scope，随后语句检查 */ for (usize i = 0; i < block->size; i++) { spl_ast_node_t *b = node_at(sema->ast, block->data[i]); if (!b || b->kind == SPL_AST_EXPR) continue; if (b->block_item.kind == SPL_AST_VARDECL) { spl_ast_node_t *vd = node_at(sema->ast, b->block_item.var_decl); if (vd) register_binding(sema, vd->var_decl.name, vd->var_decl.type_expr, scope, 0, b->block_item.var_decl); } else if (b->block_item.kind == SPL_AST_CONSTDECL) { spl_ast_node_t *cd = node_at(sema->ast, b->block_item.const_decl); if (cd) { register_binding(sema, cd->const_decl.name, cd->const_decl.type_expr, scope, 0, b->block_item.const_decl); /* 标记 const：赋值检查拒绝写入 */ spl_ast_node_t *cn = node_at(sema->ast, b->block_item.const_decl); if (cn && cn->resolved_def_id) { spl_def_node_t *cdd = def_at(sema, cn->resolved_def_id); if (cdd) cdd->var_def.is_const = 1; } } } else if (b->block_item.kind == SPL_AST_TYPEDECL) { spl_ast_node_t *td = node_at(sema->ast, b->block_item.type_decl); if (td) sema_type_decl(sema, b->block_item.type_decl, scope, 0); } } for (usize i = 0; i < block->size; i++) check_stmt(sema, block->data[i], ctx); sema->current_scope = save; } /* 函数体检查：新建 fn_scope、登记形参（复用 def 里的 fn_params_def 类型），随后检查块 */ static void check_fn_body(spl_sema_t *sema, spl_ast_node_ref_t ref, spl_def_id_t fdef, spl_scope_id_t parent_scope) { spl_ast_node_t *n = node_at(sema->ast, ref); if (!n || !fdef) return; spl_type_id_t fid = def_type(sema, fdef); spl_type_id_t ret = 0; spl_type_node_t *ft = type_node(sema, fid); if (ft && ft->kind == SPL_TYPE_FN) ret = ft->fn_type.ret; spl_sema_ctx_t ctx = {ret}; spl_scope_id_t fn_scope = spl_sema_scope_alloc(sema); sema->scopes.data[fn_scope].parent = parent_scope; spl_scope_id_t save = sema->current_scope; sema->current_scope = fn_scope; /* 先复制参数信息，避免 new_var_def 触发 def_table 扩容使指针失效 */ spl_def_node_t *d = def_at(sema, fdef); usize nparams = d ? d->fn_params_def.size : 0; for (usize i = 0; i < nparams; i++) { d = def_at(sema, fdef); spl_var_def_t *pv = &d->fn_params_def.data[i]; if (pv->name) { spl_def_id_t pdef = new_var_def(sema, pv->name, pv->type_id, fn_scope); spl_sema_scope_insert(sema, fn_scope, pv->name, pdef); /* 注解：param_decl → 其在 fn_scope 的 VAR def */ spl_ast_node_t *pd = node_at(sema->ast, n->fn_decl.param_list.data[i]); if (pd) pd->resolved_def_id = pdef; } } check_block(sema, &n->fn_decl.block, fn_scope, ctx); sema->current_scope = save; } void spl_sema_init(spl_sema_t *sema) { memset(sema, 0, sizeof *sema); spl_type_init(&sema->type); vec_init(sema->scopes); /* scope id 0 保留为 error */ spl_scope_node_t s0; memset(&s0, 0, sizeof s0); map_init(s0.symbols, MAP_HASH_STR, MAP_CMP_STR); vec_push(sema->scopes, s0); sema->root_scope = spl_sema_scope_alloc(sema); sema->current_scope = sema->root_scope; /* 文件聚合根：$root 即文件聚合（root_def = AGG，成员为顶层声明） */ spl_type_id_t root_type = spl_type_alloc(&sema->type); spl_type_node_t *rn = spl_type_node(&sema->type, root_type); rn->kind = SPL_TYPE_STRUCT; vec_init(rn->agg_field_types); sema->root_def = def_alloc(sema, SPL_DEF_AGG); def_at(sema, sema->root_def)->type_id = root_type; vec_init(def_at(sema, sema->root_def)->agg_def); /* 关键字类型注册进 root（每个关键字一个 BUILTIN def） */ #define SPL_REG_KEYWORD(nm, tid) \ do { \ spl_def_id_t _d = def_alloc(sema, SPL_DEF_BUILTIN); \ def_at(sema, _d)->type_id = (tid); \ spl_sema_scope_insert(sema, sema->root_scope, (nm), _d); \ } while (0) SPL_REG_KEYWORD("void", spl_type_void(&sema->type)); SPL_REG_KEYWORD("bool", spl_type_bool(&sema->type)); SPL_REG_KEYWORD("i8", spl_type_int(&sema->type, 8, 1)); SPL_REG_KEYWORD("u8", spl_type_int(&sema->type, 8, 0)); SPL_REG_KEYWORD("i16", spl_type_int(&sema->type, 16, 1)); SPL_REG_KEYWORD("u16", spl_type_int(&sema->type, 16, 0)); SPL_REG_KEYWORD("i32", spl_type_int(&sema->type, 32, 1)); SPL_REG_KEYWORD("u32", spl_type_int(&sema->type, 32, 0)); SPL_REG_KEYWORD("i64", spl_type_int(&sema->type, 64, 1)); SPL_REG_KEYWORD("u64", spl_type_int(&sema->type, 64, 0)); SPL_REG_KEYWORD("isize", spl_type_int(&sema->type, sizeof(isize) * 8, 1)); SPL_REG_KEYWORD("usize", spl_type_int(&sema->type, sizeof(usize) * 8, 0)); SPL_REG_KEYWORD("f32", spl_type_float(&sema->type, 32)); SPL_REG_KEYWORD("f64", spl_type_float(&sema->type, 64)); #undef SPL_REG_KEYWORD } void spl_sema_drop(spl_sema_t *sema) { for (usize i = 0; i < sema->scopes.size; i++) map_free(sema->scopes.data[i].symbols); vec_free(sema->scopes); spl_type_drop(&sema->type); } /* Pass1：预登记顶层名字，使兄弟/自引用成立（不解析成员、不检查函数体） */ void spl_sema_run(spl_sema_t *sema) { if (!sema->ast || !sema->ast->root) return; spl_ast_node_t *c = node_at(sema->ast, sema->ast->root); if (!c || c->kind != SPL_AST_CONTAINER_ITEM) return; LOG_DEBUG("sema_run root=%zu kind=%d members=%zu", sema->ast->root, c->kind, c->container_item.members.size); sema->current_scope = sema->root_scope; /* 1a. 聚合壳 + 别名（类型名先全部登记，兄弟聚合可互引） */ for (usize i = 0; i < c->container_item.members.size; i++) { spl_ast_node_ref_t mref = c->container_item.members.data[i]; spl_ast_node_t *m = node_at(sema->ast, mref); if (!m || m->kind != SPL_AST_TYPE_DECL) continue; spl_ast_node_t *te = node_at(sema->ast, m->type_decl.type_expr); if (te && (te->type_expr.kind == SPL_AST_TYPE_STRUCT || te->type_expr.kind == SPL_AST_TYPE_UNION || te->type_expr.kind == SPL_AST_TYPE_ENUM)) { agg_handle_t h = agg_prepare(sema, m->type_decl.type_expr); if (!h.def) continue; if (!spl_sema_scope_insert(sema, sema->root_scope, m->type_decl.name, h.def)) sema_error(sema, mref, "duplicate type name"); agg_add_member(sema, sema->root_def, m->type_decl.name, h.tid, sema->root_scope, h.def); } else if (te) { spl_type_id_t tid = resolve_type_expr(sema, m->type_decl.type_expr); spl_def_id_t def = def_alloc(sema, SPL_DEF_ALIAS); spl_def_node_t *d = def_at(sema, def); d->type_id = tid; d->type_def.name = m->type_decl.name; d->type_def.def_id = def; d->type_def.type_id = tid; d->type_def.scope_id = sema->root_scope; if (!spl_sema_scope_insert(sema, sema->root_scope, m->type_decl.name, def)) sema_error(sema, mref, "duplicate type name"); agg_add_member(sema, sema->root_def, m->type_decl.name, tid, sema->root_scope, def); } } /* 1b. fn 名（建 fn type + def） */ for (usize i = 0; i < c->container_item.members.size; i++) { spl_ast_node_ref_t mref = c->container_item.members.data[i]; spl_ast_node_t *m = node_at(sema->ast, mref); if (!m) continue; if (m->kind == SPL_AST_FN_DECL || m->kind == SPL_AST_FN_DEFINE) sema_fn_decl(sema, mref, sema->root_scope, sema->root_def); } /* 1c. 顶层 var/const */ for (usize i = 0; i < c->container_item.members.size; i++) { spl_ast_node_ref_t mref = c->container_item.members.data[i]; spl_ast_node_t *m = node_at(sema->ast, mref); if (!m) continue; if (m->kind == SPL_AST_VAR_DECL) sema_var_decl(sema, mref, sema->root_scope, sema->root_def); else if (m->kind == SPL_AST_CONST_DECL) sema_const_decl(sema, mref, sema->root_scope, sema->root_def); else if (m->kind == SPL_AST_MEMBER_DECL && m->member_decl.name) register_binding(sema, m->member_decl.name, m->member_decl.type_expr, sema->root_scope, sema->root_def, mref); } sema->current_scope = sema->root_scope; } /* Pass2：构建聚合成员（含方法 def）并检查函数体，一次遍历完成 */ void spl_sema_check(spl_sema_t *sema) { if (!sema->ast || !sema->ast->root) return; spl_ast_node_t *c = node_at(sema->ast, sema->ast->root); if (!c || c->kind != SPL_AST_CONTAINER_ITEM) return; sema->current_scope = sema->root_scope; /* 构建所有顶层聚合成员 */ for (usize i = 0; i < c->container_item.members.size; i++) { spl_ast_node_ref_t mref = c->container_item.members.data[i]; spl_ast_node_t *m = node_at(sema->ast, mref); if (!m || m->kind != SPL_AST_TYPE_DECL) continue; spl_ast_node_t *te = node_at(sema->ast, m->type_decl.type_expr); if (te && (te->type_expr.kind == SPL_AST_TYPE_STRUCT || te->type_expr.kind == SPL_AST_TYPE_UNION || te->type_expr.kind == SPL_AST_TYPE_ENUM)) { spl_def_id_t def = find_bare(sema, m->type_decl.name); if (!def) continue; agg_resolve(sema, m->type_decl.type_expr, def_type(sema, def), def, sema->root_scope, m->type_decl.name); } } /* 检查顶层函数体 */ for (usize i = 0; i < c->container_item.members.size; i++) { spl_ast_node_ref_t mref = c->container_item.members.data[i]; spl_ast_node_t *m = node_at(sema->ast, mref); if (!m || m->kind != SPL_AST_FN_DEFINE) continue; spl_def_id_t def = find_bare(sema, m->fn_decl.name); check_fn_body(sema, mref, def, sema->root_scope); } sema->current_scope = sema->root_scope; } spl_scope_id_t spl_sema_scope_alloc(spl_sema_t *sema) { spl_scope_node_t n; memset(&n, 0, sizeof n); map_init(n.symbols, MAP_HASH_STR, MAP_CMP_STR); vec_push(sema->scopes, n); return sema->scopes.size - 1; } bool spl_sema_scope_insert(spl_sema_t *sema, spl_scope_id_t id, const char *symbol_name, spl_def_id_t symbol_val) { if (!id || id >= sema->scopes.size) return false; spl_def_id_t old = 0; if (map_get(sema->scopes.data[id].symbols, symbol_name, &old)) return false; map_put(sema->scopes.data[id].symbols, symbol_name, symbol_val); return true; } spl_def_id_t spl_sema_scope_find(spl_sema_t *sema, spl_symbol_path_t path) { if (!path.size) return 0; spl_def_id_t def = find_bare(sema, path.data[0]); if (!def) return 0; for (usize i = 1; i < path.size; i++) { spl_type_id_t t = def_type(sema, def); spl_def_id_t owner = def_for_type(sema, t); if (!owner) return 0; spl_def_node_t *od = def_at(sema, owner); spl_def_id_t next = 0; for (usize j = 0; j < od->agg_def.size; j++) { if (od->agg_def.data[j].name && strcmp(od->agg_def.data[j].name, path.data[i]) == 0) { next = od->agg_def.data[j].def_id ? od->agg_def.data[j].def_id : def_for_type(sema, od->agg_def.data[j].type_id); break; } } if (!next) return 0; def = next; } return def; }