Serendipity/l-language
1
1
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases 2 Wiki Activity

refactor: 拆分 sema analyze_expr 为 9 个辅助函数 + 调度器

Browse Source
This commit is contained in:
刘航宇
2026-06-06 01:36:37 +08:00
parent de91886712
commit 031dedfb8e
2 changed files with 649 additions and 407 deletions
Download Patch File Download Diff File Expand all files Collapse all files
docs/analysis/architecture-analysis-report-2026-06-06-0050.md
+307
View File
@@ -0,0 +1,307 @@
# L Language 架构分析报告 v0.6
> 日期: 2026-06-06 00:50 | 自动生成 | **重大代码变更**
> 上次代码基线: `a15cd9d` (2026-06-05 17:08 报告, v0.5)
> 当前 HEAD: `de91886` fix: CreateProcess 替代 system() 调 ld.lld，消除 shell 转义问题
> **版本: v0.6**
---
## 代码变更检查
```
git log a15cd9d..HEAD → 20 新提交, 36 文件变更, +2483/-163 行
```
自 v0.5 以来累计 20 个提交，涵盖 6 个新语言特性、语法差异化调整、链接器重构、安装包系统。
详细提交链:
| # | 提交 | 类别 |
|---|------|------|
| 1-2 | CHANGELOG/语言参考文档 | 文档 |
| 3-4 | CLAUDE.md 语言设计哲学 | 文档 |
| 5 | 数组初始化 `= arr` 语法说明 | 文档 |
| 6 | match/sema 单元测试 (145→158) | 测试 |
| 7 | 数组支持 struct 元素类型 `Point[N]` | P1-5 修复 |
| 8 | 测试计数更新 145→158 + 23→24 | 测试 |
| 9 | for..in 范围语法 `..` → `to` | 语法差异化 |
| 10 | `let mut` → `var` | 语法差异化 |
| 11 | `[T; N]` → `T[N]` 后置语法 | 语法差异化 |
| 12 | `impl` → `extend` | 语法差异化 |
| 13 | 新增 i32/u64/char 类型 + 字符字面量 | 新功能 |
| 14 | guard 语句 | 新功能 |
| 15 | 命名参数 | 新功能 |
| 16 | 管道 `|>` + 字符串插值 `\(expr)` — P0 四特性收官 | 新功能 |
| 17 | README/CHANGELOG/语言参考更新至 v0.6 | 文档 |
| 18 | 链接器 gcc → clang + lld | 基础设施 |
| 19 | NSIS 安装包脚本 | 基础设施 |
| 20 | CreateProcess 替代 system() 调 ld.lld | 基础设施 |
---
## 1. 当前架构快照 (v0.6)
### 1.1 编译流水线
```
源码(.l) → Lexer(词法) → Parser(语法) → Sema(语义) → Codegen(LLVM IR) → Target(obj) → clang+lld 链接(.exe)
58 Token 25 AST 节点 类型标注 LLVMModuleRef .o 文件 优先 clang→fallback gcc
```
v0.5 的 GCC 链接器已被 clang + lld 替代（自动 fallback）。`system()` 调用被 `CreateProcess` 替代，消除 shell 转义问题。
### 1.2 模块清单与行数
| 模块 | 文件 | 行数 | vs v0.5 | 职责 |
|------|------|------|---------|------|
| include/ | l_lang.h | 55 | -2 | TypeKind (13), SourceLoc, 公共类型 |
| lexer/ | lexer.c + token.c (+ .h) | 168+53+47 = 268 | +11 | 手写状态机, 58 Token 类型 |
| ast/ | ast.c + ast.h | 221+152 = 373 | -31 | 25 种 AST 节点, 工厂函数 (arg_names 扩展) |
| parser/ | parser.c + parser.h | 851+10 = 861 | +23 | 递归下降+Pratt, guard/pipe/插值去糖 |
| sema/ | sema.c + symbol.c (+ .h) | 871+148+63 = 1082 | +77 | 类型推断, can_implicit_convert, 命名参数重排 |
| codegen/ | codegen.c + target.c (+ .h) | 764+30+15 = 809 | -55 | LLVM IR 生成, coerce_int 隐式转换 |
| driver/ | main.c + error.c (+ .h) | 205+46+18 = 269 | +58 | 流水线串联, CreateProcess 链接 |
| util/ | arena.c + arena.h | 39+13 = 52 | 不变 | Bump allocator (8MB) |
| **实现总计** | | **~3,769 行** | **+434 vs v0.5** | |
> 注意: codegen.c 从 824 行收缩到 764 行（-7.3%），说明新加入的 pipe/guard/插值等功能去糖后不需要 codegen 层改动。
### 1.3 核心类型系统变化
| 枚举 | v0.5 | v0.6 | 变更 |
|------|------|------|------|
| TypeKind | 10 | **13** | +TYPE_I32, TYPE_U64, TYPE_CHAR |
| TokenKind | 50 | **58** | +TOK_VAR, TOK_GUARD, TOK_I32, TOK_U64, TOK_CHAR, TOK_CHAR_LIT, TOK_PIPE, TOK_TO; TOK_IMPL→TOK_EXTEND |
| AstNodeKind | 25 | **25** | 不变 — 所有新功能经去糖复用现有节点 |
| SymbolKind | 5 | **5** | 不变 |
**TypeKind 完整列表**: TYPE_I32, TYPE_I64, TYPE_U64, TYPE_F64, TYPE_BOOL, TYPE_CHAR, TYPE_STR, TYPE_VOID, TYPE_STRUCT, TYPE_ENUM, TYPE_ARRAY, TYPE_UNKNOWN, TYPE_ERROR
**Token 新增**:
| 新增 Token | 用途 |
|------------|------|
| TOK_VAR | `var` 关键字 (替代 `let mut`) |
| TOK_GUARD | `guard` 关键字 |
| TOK_I32 / TOK_U64 / TOK_CHAR | 新基本类型 |
| TOK_CHAR_LIT | 字符字面量 `'"'"'A'"'"'` |
| TOK_PIPE | 管道运算符 `|>` |
| TOK_TO | 范围运算符 `to` (替代 `..`) |
| TOK_EXTEND | `extend` 关键字 (替代 `impl`) |
**AST 结构体扩展**:
- `AST_CALL_EXPR.call` 新增 `arg_names` 字段 — 支持命名参数
- `AST_METHOD_CALL.method_call` 新增 `arg_names` 字段 — 支持命名参数
- `AST_LITERAL_EXPR.literal` 新增 `lit_type` + union 扩展 — 支持 char 字面量
**Symbol 扩展**:
- `Symbol.param_names` 新增 — 支持命名参数匹配
---
## 2. 功能完成度总览
### 2.1 P0 (v0.1-v0.4) — 100%
全 12 项保持完成状态。
### 2.2 P1 (v0.5) — 100%
全 6 项保持完成，P1-5 (数组 struct 元素类型) 在本轮修复。
### 2.3 P0-扩展 (v0.6 新增) — 100%
| # | 功能 | 去糖策略 | 灵感来源 | 影响层 |
|---|------|---------|---------|--------|
| 13 | `i32` / `u64` / `char` 类型 | TypeKind 扩展 + can_implicit_convert | Rust/ML | lexer/ast/sema/codegen |
| 14 | `guard x >= 0 else { return -1; }` | parser 去糖为 if-else | Swift | parser |
| 15 | `draw_rect(width: 10, height: 20)` | sema 重排序为位置参数 | Python/Swift | parser/sema |
| 16 | `10 |> double() |> add(5)` | parser 去糖为 `add(double(10), 5)` | F#/Elixir | parser |
| 17 | `"Hello, \(name)!"` | lexer+parser 去糖为 `str+str` | Swift/Rust | lexer/parser |
| 18 | `extend` 方法块 | 即原 `impl` mangle，改名 | 差异化 | lexer |
### 2.4 语法差异化 (L 语言独有)
| L 语法 | Rust 对应 | 理由 |
|--------|----------|------|
| `var` | `let mut` | 更简洁，2 字符 vs 6 字符 |
| `T[N]` | `[T; N]` | C 风格直觉，减少括号 |
| `to` | `..` | 明确语义 (省略终值 `to` vs 闭区间 `..=`) |
| `extend` | `impl` | 避免 Rust 预留词 |
| `guard` | 无直接对应 | Swift 灵感，前条件守卫 |
| `|>` | 无直接对应 | F#/Elixir 灵感，函数组合 |
| `\(expr)` | 无直接对应 | Swift 风格字符串插值 |
---
## 3. Rust 对标缺失清单
### 3.1 已完成
| 特性 | 状态 | 版本 |
|------|------|------|
| 默认不可变 (let) / 可变 (var) | ✅ | v0.1-v0.6 |
| 复合赋值 | ✅ | v0.2 |
| for + range | ✅ | v0.3 |
| struct 具名域 | ✅ | v0.4 |
| impl/extend 方法 | ✅ | v0.5 |
| enum + match | ✅ | v0.5 |
| 类型别名 | ✅ | v0.5 |
| 数组固定大小 | ✅ | v0.5 |
| 数组 struct 元素类型 | ✅ | v0.6 |
| RAII 自动释放 | ✅ | v0.4 |
| 命名参数 | ✅ | v0.6 |
| 管道运算符 | ✅ | v0.6 |
| 字符串插值 | ✅ | v0.6 |
| guard 守卫语句 | ✅ | v0.6 |
| i32/u64/char 多种整数类型 | ✅ | v0.6 |
### 3.2 缺失 (P2 — 中期, 按难度排序)
| # | 功能 | 预计工时 | 优先级 | Rust 对应 | 说明 |
|---|------|---------|--------|----------|------|
| 19 | 表达式作为值 (块返回最后表达式) | 2-3 天 | **高** | 块是表达式 | sema/codegen 需处理块类型推断, 当前 block→void |
| 20 | 枚举关联数据 (ADT) | 2-3 天 | **高** | `enum Option<T>` | 当前仅简单常量枚举, 需 payload + 模式匹配扩展 |
| 21 | `if let` / `while let` | 1 天 | 中 | `if let Some(x) = opt` | 基于枚举关联数据 |
| 22 | 模块系统 `mod` + `use` | 3-5 天 | **高** | `mod`, `use`, `pub` | 多文件编译, 符号可见性 |
| 23 | 泛型 (单态化) | 5-7 天 | 中 | `fn<T>(x: T)` | sema 类型参数收集, codegen 复制 |
| 24 | trait / 接口 | 5-7 天 | 中 | `trait`, `impl Trait` | vtable 或单态化分派 |
| 25 | 引用/切片 | 7-10 天 | 中 | `&T`, `&[T]` | 需指针层次, 生命周期标注 |
### 3.3 缺失 (P3 — 长期)
| # | 功能 | 预计工时 | Rust 对应 |
|---|------|---------|----------|
| 26 | 所有权 / 借用检查 | 2-4 周 | borrow checker |
| 27 | 闭包 (lambda) | 3-5 天 | `|x| x+1` |
| 28 | 自举 (L 编译 L) | 4-6 周 | — |
| 29 | 标准库 (prelude) | 4-6 周 | std |
---
## 4. 测试覆盖
| 测试文件 | 测试函数 | vs v0.5 | 覆盖范围 |
|---------|----------|---------|---------|
| test_lexer.c | 3 | 不变 | token 识别 |
| test_parser.c | 5 | 不变 | 语法解析基本路径 |
| test_sema.c | 24 | +3 | i32/u64/char 转换, named args, guard, 管道, 插值 |
| test_codegen.c | 10 | +1 | 隐式转换, 命名参数, i32/u64/char codegen |
| **单元合计** | **42** | **+4** | |
| 集成 .l 程序 | **29** | **+6** | 24_array_struct, 25_new_types, 26_guard, 27_named_args, 28_pipe, 29_interp |
| **测试总计** | **71** | **+10** | |
新集成测试覆盖:
- `24_array_struct.l` — struct 数组 (P1-5 修复验证)
- `25_new_types.l` — i32/u64/char 类型 + 隐式转换
- `26_guard.l` — guard 守卫语句
- `27_named_args.l` — 命名参数任意顺序
- `28_pipe.l` — 管道 |> 函数组合
- `29_interp.l` — 字符串插值
---
## 5. 代码审查 — 风险区域
### 5.1 去糖策略的评价
v0.6 延续了 v0.5 的去糖哲学: pipe/guard/插值/named_args 全在 parser 层去糖为现有 AST 节点。优势是 sema/codegen 改动极小（codegen 甚至缩水 60 行），但代价是:
1. **parser.c 进一步膨胀**: 825→851 行，去糖逻辑散落在 `parse_expr` 和 `parse_statement` 之间
2. **错误消息质量下降**: 去糖后生成的 AST 丢失原始语法信息，错误报告指向去糖后的 if-else 而非原始 `guard` 语句
3. **调试/IR 可读性**: 用户写 `10 |> double()` 但 IR 中看到的是 `double(10)`，不利于学习
**建议**: v0.7 考虑将 guard/match/named_args/pipe 去糖抽取为独立 desugar pass，在 parser 生成 AST 之后、sema 之前运行。这既能保持"去糖"优势，又能改善错误消息质量。
### 5.2 sema.c 持续膨胀
sema.c 从 809→871 行 (v0.5→v0.6)，analyze_expr 仍然是单函数怪兽 (~380 行)。新增的 `can_implicit_convert()` 是好的模块化进步，但类型检查逻辑仍需拆分。
### 5.3 TypeKind 耦合未改善
TypeKind 从 10 增加到 13，修改范围涉及 7+ 文件。加新类型仍是全局搜索替换作业。
### 5.4 链接器变更风险
gcc→clang+lld 变更是正确方向，但 fallback 链 (clang→gcc) 增加了 CI 配置复杂度。自包含安装包 (39MB) 和 NSIS 安装包 (62MB) 是两个并行方案，后续需统一。
---
## 6. 技术债务更新
### 6.1 已解决
| # | 原问题 | 解决提交 |
|---|--------|---------|
| 5 | 数组 struct 元素类型 `[Point; N]` 未实现 | `a45f7d8` |
| 6 | match/sema 无独立单元测试 | `beac40f` |
| 9 | CHANGELOG 未更新 v0.4/v0.5 | `5a0bf60` + `2baf762` |
### 6.2 当前债务 (优先级排序)
| # | 问题 | 严重度 | 现状 | 备注 |
|---|------|--------|------|------|
| 1 | analyze_expr 膨胀 (~380 行) | **高** | 未修复, 反而增加 | sema.c 871 行, +62 vs v0.5 |
| 2 | parser.c 单文件 851 行 | **高** | 未修复, +26 行 | 去糖逻辑散落 |
| 3 | 去糖无独立 pass, 错误消息受损 | **中** | 需求显现 | v0.6 新暴露 |
| 4 | codegen.c 824→764 行, 但仍有优化空间 | 中 | 改善中 | struct/element_type 逻辑可精简 |
| 5 | TypeKind 耦合 (改 7+ 文件) | 低 | 未修复 | 13 种类型, 加新类型成本递增 |
| 6 | AST Visitor 缺失 | 低 | 未修复 | 加节点需改 4 个 switch |
| 7 | LLVM 22 无 mem2reg C API | 低 | 平台限制 | IR 含冗余 alloca/store/load |
---
## 7. 基础设施变更
| 组件 | v0.5 | v0.6 | 影响 |
|------|------|------|------|
| 链接器 | GCC (外部依赖) | clang + lld (优先), fallback gcc | 用户需安装 LLVM 或将 ld.lld 打包 |
| 进程启动 | `system()` | `CreateProcess` | 消除 shell 注入/转义风险 |
| 发布 | 无 | NSIS 安装包 (62MB) / 自包含包 (39MB) | 零依赖部署 |
| 文档 | README + CHANGELOG | +语言参考手册 (643 行) + CLAUDE.md | 开发者友好 |
---
## 8. 与 PRD 对照
PRD v0.1 设定了"学习编译器全流程"的短期目标。对照 PRD 中的非目标列表:
| PRD 非目标 (v0.1 不做) | 当前状态 |
|------------------------|---------|
| 字符串类型 | ✅ v0.2 实现 `str` |
| 数组/切片/结构体 | ✅ v0.4-v0.5 实现 struct/array |
| 模块系统 | ❌ 仍缺失 |
| 泛型/trait | ❌ 仍缺失 |
| 模式匹配 | ✅ v0.5 match (简化) |
| 标准库 | ❌ 仍缺失 |
| 垃圾回收 | ❌ 不做 (采用 RAII) |
v0.6 已大幅超出 v0.1 PRD 范围。建议更新 PRD 到 v0.6 以反映当前功能边界。
---
## 9. 推荐开发路线图
### v0.7 (短期, 2-3 天)
1. **独立 desugar pass** — 将 guard/pipe/named_args 去糖从 parser 移到独立 pass，改善错误消息和 parser 复杂度
2. **analyze_expr 拆分** — 按节点类型拆分为 4-6 个辅助函数
3. **枚举关联数据 (ADT)** — `enum Option { Some(i64), None }`，打开类型安全编程新范式
4. **表达式作为值** — `let x = if a { 1 } else { 2 }`，函数体最后表达式即返回值
### v0.8 (中期, 1 周)
1. **模块系统** — `mod` + `use` + `pub`，多文件编译
2. `if let` / `while let` — 简化 ADT 匹配
3. 标准库起步: `io`, `convert`, `vec`
### v0.9 (中期, 1-2 周)
1. 泛型 (单态化)
2. trait / 接口
3. AST Visitor 宏驱动
---
*本报告由 Codex 自动生成于 2026-06-06 00:50。自上次代码基线 `a15cd9d` (v0.5) 以来共 20 个提交, +2483/-163 行。P0 扩展 6 个新特性全部实现, 语法完成差异化定型, 链接器/进程启动基础设施升级。v0.7 应聚焦 parser 结构优化和枚举 ADT。*
src/sema/sema.c
+342 -407
View File
@@ -52,442 +52,377 @@ static bool is_comparable(TypeKind a, TypeKind b) {
// === 向前声明 ===
static void analyze_node(AstNode* node, Scope* scope, ErrorList* errors, Arena* a);
// === 检查表达式 ===
static void analyze_expr(AstNode* node, Scope* scope, ErrorList* errors, Arena* a) {
switch (node->kind) {
case AST_LITERAL_EXPR:
break; // 类型已在创建时设置
// === 表达式类型检查辅助函数 ===
static void analyze_expr(AstNode* node, Scope* scope, ErrorList* errors, Arena* a);
case AST_IDENT_EXPR: {
Symbol* sym = scope_lookup(scope, node->as.ident.name);
if (!sym) {
static void analyze_ident_expr(AstNode* node, Scope* scope, ErrorList* errors, Arena* a) {
(void)a;
Symbol* sym = scope_lookup(scope, node->as.ident.name);
if (!sym) {
error_add(errors, "<sema>", node->loc.line, node->loc.col,
"未定义的变量 '%s'", node->as.ident.name);
node->type.kind = TYPE_ERROR;
} else if (sym->is_type_alias) {
error_add(errors, "<sema>", node->loc.line, node->loc.col,
"'%s' 是类型别名，不能作为表达式使用", node->as.ident.name);
node->type.kind = TYPE_ERROR;
} else if (sym->kind == SYM_FUNCTION) {
error_add(errors, "<sema>", node->loc.line, node->loc.col,
"'%s' 是函数，不能作为表达式使用", node->as.ident.name);
node->type.kind = TYPE_ERROR;
} else {
node->type.kind = sym->type;
if (sym->type == TYPE_STRUCT && sym->struct_type_name)
node->type.struct_name = sym->struct_type_name;
if (sym->type == TYPE_ARRAY) {
node->type.element_type = sym->array_element_type;
node->type.element_struct_name = sym->array_element_struct_name;
node->type.array_size = sym->array_size;
}
}
}
static void analyze_unary_expr(AstNode* node, Scope* scope, ErrorList* errors, Arena* a) {
analyze_expr(node->as.unary.operand, scope, errors, a);
TypeKind inner = node->as.unary.operand->type.kind;
if (node->as.unary.op == OP_NEG) {
if (!is_numeric(inner)) {
error_add(errors, "<sema>", node->loc.line, node->loc.col,
"未定义的变量 '%s'", node->as.ident.name);
node->type.kind = TYPE_ERROR;
} else if (sym->is_type_alias) {
error_add(errors, "<sema>", node->loc.line, node->loc.col,
"'%s' 是类型别名，不能作为表达式使用", node->as.ident.name);
node->type.kind = TYPE_ERROR;
} else if (sym->kind == SYM_FUNCTION) {
error_add(errors, "<sema>", node->loc.line, node->loc.col,
"'%s' 是函数，不能作为表达式使用", node->as.ident.name);
"一元 '-' 只能用于数值类型");
node->type.kind = TYPE_ERROR;
} else {
node->type.kind = sym->type;
if (sym->type == TYPE_STRUCT && sym->struct_type_name) {
node->type.struct_name = sym->struct_type_name;
}
if (sym->type == TYPE_ARRAY) {
node->type.element_type = sym->array_element_type;
node->type.element_struct_name = sym->array_element_struct_name;
node->type.array_size = sym->array_size;
}
node->type.kind = inner;
}
break;
}
case AST_UNARY_EXPR: {
analyze_expr(node->as.unary.operand, scope, errors, a);
TypeKind inner = node->as.unary.operand->type.kind;
if (node->as.unary.op == OP_NEG) {
if (!is_numeric(inner)) {
error_add(errors, "<sema>", node->loc.line, node->loc.col,
"一元 '-' 只能用于数值类型");
node->type.kind = TYPE_ERROR;
} else {
node->type.kind = inner;
}
} else { // OP_NOT
if (inner != TYPE_BOOL) {
error_add(errors, "<sema>", node->loc.line, node->loc.col,
"'!' 只能用于布尔类型，得到 '%s'", type_name(inner));
node->type.kind = TYPE_ERROR;
} else {
node->type.kind = TYPE_BOOL;
}
}
break;
}
case AST_BINARY_EXPR: {
analyze_expr(node->as.binary.left, scope, errors, a);
analyze_expr(node->as.binary.right, scope, errors, a);
TypeKind l = node->as.binary.left->type.kind;
TypeKind r = node->as.binary.right->type.kind;
if (l == TYPE_ERROR || r == TYPE_ERROR) { node->type.kind = TYPE_ERROR; break; }
switch (node->as.binary.op) {
case OP_ADD:
if (l == TYPE_STR || r == TYPE_STR) {
// 字符串拼接：两边都必须是 str 类型
if (l != TYPE_STR || r != TYPE_STR) {
error_add(errors, "<sema>", node->loc.line, node->loc.col,
"字符串拼接需要两边都是 str 类型，得到 '%s' + '%s'",
type_name(l), type_name(r));
node->type.kind = TYPE_ERROR;
} else {
node->type.kind = TYPE_STR;
}
} else if (!is_numeric(l) || !is_numeric(r)) {
error_add(errors, "<sema>", node->loc.line, node->loc.col,
"算术运算需要数值类型");
node->type.kind = TYPE_ERROR;
} else {
node->type.kind = promote(l, r);
}
break;
case OP_SUB: case OP_MUL: case OP_DIV: case OP_MOD:
if (!is_numeric(l) || !is_numeric(r)) {
error_add(errors, "<sema>", node->loc.line, node->loc.col,
"算术运算需要数值类型");
node->type.kind = TYPE_ERROR;
} else {
node->type.kind = promote(l, r);
}
break;
case OP_EQ: case OP_NE: case OP_LT: case OP_GT: case OP_LE: case OP_GE:
if (!is_comparable(l, r)) {
error_add(errors, "<sema>", node->loc.line, node->loc.col,
"类型 '%s' 和 '%s' 无法比较", type_name(l), type_name(r));
node->type.kind = TYPE_ERROR;
} else {
node->type.kind = TYPE_BOOL;
}
break;
case OP_AND: case OP_OR:
if (l != TYPE_BOOL || r != TYPE_BOOL) {
error_add(errors, "<sema>", node->loc.line, node->loc.col,
"逻辑运算需要布尔类型");
node->type.kind = TYPE_ERROR;
} else {
node->type.kind = TYPE_BOOL;
}
break;
default: break;
}
break;
}
case AST_CALL_EXPR: {
Symbol* sym = scope_lookup(scope, node->as.call.name);
if (!sym || sym->kind != SYM_FUNCTION) {
} else { // OP_NOT
if (inner != TYPE_BOOL) {
error_add(errors, "<sema>", node->loc.line, node->loc.col,
"未定义的函数 '%s'", node->as.call.name);
"'!' 只能用于布尔类型，得到 '%s'", type_name(inner));
node->type.kind = TYPE_ERROR;
// 即使函数未定义，也要分析参数表达式（它们可能有更多错误）
for (size_t i = 0; i < node->as.call.arg_count; i++) {
analyze_expr(node->as.call.args[i], scope, errors, a);
}
break;
} else {
node->type.kind = TYPE_BOOL;
}
if (node->as.call.arg_count != sym->param_count) {
}
}
static void analyze_binary_expr(AstNode* node, Scope* scope, ErrorList* errors, Arena* a) {
analyze_expr(node->as.binary.left, scope, errors, a);
analyze_expr(node->as.binary.right, scope, errors, a);
TypeKind l = node->as.binary.left->type.kind;
TypeKind r = node->as.binary.right->type.kind;
if (l == TYPE_ERROR || r == TYPE_ERROR) { node->type.kind = TYPE_ERROR; return; }
switch (node->as.binary.op) {
case OP_ADD:
if (l == TYPE_STR || r == TYPE_STR) {
if (l != TYPE_STR || r != TYPE_STR) {
error_add(errors, "<sema>", node->loc.line, node->loc.col,
"字符串拼接需要两边都是 str 类型，得到 '%s' + '%s'",
type_name(l), type_name(r));
node->type.kind = TYPE_ERROR;
} else {
node->type.kind = TYPE_STR;
}
} else if (!is_numeric(l) || !is_numeric(r)) {
error_add(errors, "<sema>", node->loc.line, node->loc.col, "算术运算需要数值类型");
node->type.kind = TYPE_ERROR;
} else {
node->type.kind = promote(l, r);
}
break;
case OP_SUB: case OP_MUL: case OP_DIV: case OP_MOD:
if (!is_numeric(l) || !is_numeric(r)) {
error_add(errors, "<sema>", node->loc.line, node->loc.col, "算术运算需要数值类型");
node->type.kind = TYPE_ERROR;
} else {
node->type.kind = promote(l, r);
}
break;
case OP_EQ: case OP_NE: case OP_LT: case OP_GT: case OP_LE: case OP_GE:
if (!is_comparable(l, r)) {
error_add(errors, "<sema>", node->loc.line, node->loc.col,
"函数 '%s' 需要 %zu 个参数，但提供了 %zu 个",
node->as.call.name, sym->param_count, node->as.call.arg_count);
"类型 '%s' 和 '%s' 无法比较", type_name(l), type_name(r));
node->type.kind = TYPE_ERROR;
// 即使参数数量不匹配，也分析已有的参数
for (size_t i = 0; i < node->as.call.arg_count; i++) {
analyze_expr(node->as.call.args[i], scope, errors, a);
}
break;
} else {
node->type.kind = TYPE_BOOL;
}
// 命名参数重排序: 将命名 arg 按参数名映射到正确位置
if (node->as.call.arg_names) {
AstNode* reordered[16] = {0};
for (size_t i = 0; i < node->as.call.arg_count; i++) {
if (node->as.call.arg_names[i]) {
// 查找参数名匹配
bool found = false;
for (size_t j = 0; j < sym->param_count; j++) {
if (sym->param_names && sym->param_names[j] &&
strcmp(node->as.call.arg_names[i], sym->param_names[j]) == 0) {
reordered[j] = node->as.call.args[i];
found = true; break;
}
}
if (!found) {
error_add(errors, "<sema>", node->loc.line, node->loc.col,
"函数 '%s' 没有名为 '%s' 的参数",
node->as.call.name, node->as.call.arg_names[i]);
node->type.kind = TYPE_ERROR; return;
}
} else {
// 位置参数保持原位
reordered[i] = node->as.call.args[i];
break;
case OP_AND: case OP_OR:
if (l != TYPE_BOOL || r != TYPE_BOOL) {
error_add(errors, "<sema>", node->loc.line, node->loc.col, "逻辑运算需要布尔类型");
node->type.kind = TYPE_ERROR;
} else {
node->type.kind = TYPE_BOOL;
}
break;
default: break;
}
}
// 参数类型匹配检查（CALL_EXPR 和 METHOD_CALL 共用）
static void check_arg_type(AstNode* arg, TypeKind expected, const char* expected_sname,
size_t idx, AstNode* call_node, Scope* scope,
ErrorList* errors, Arena* a) {
(void)scope; (void)a;
TypeKind actual = arg->type.kind;
if (actual == TYPE_ERROR) return;
if (expected == TYPE_STRUCT) {
const char* actual_name = arg->type.struct_name;
if (actual != TYPE_STRUCT || !actual_name || !expected_sname ||
strcmp(actual_name, expected_sname) != 0) {
error_add(errors, "<sema>", call_node->loc.line, call_node->loc.col,
"参数 %zu 类型不匹配: 期望 '%s'，得到 '%s'",
idx + 1, expected_sname ? expected_sname : "struct",
actual_name ? actual_name : type_name(actual));
}
return;
}
if (actual == expected) return;
if (expected == TYPE_I64 && actual == TYPE_ENUM) return;
if (can_implicit_convert(actual, expected)) return;
if (actual == TYPE_I64 && arg->kind == AST_LITERAL_EXPR
&& (expected == TYPE_I32 || expected == TYPE_U64 || expected == TYPE_CHAR)) return;
error_add(errors, "<sema>", call_node->loc.line, call_node->loc.col,
"参数 %zu 类型不匹配: 期望 '%s'，得到 '%s'",
idx + 1, type_name(expected), type_name(actual));
}
// 命名参数重排序（CALL_EXPR 和 METHOD_CALL 共用）
static bool reorder_named_args(AstNode* node, Symbol* sym, int param_offset,
ErrorList* errors, const char* call_name) {
AstNode** args = node->as.call.args;
const char** arg_names = node->as.call.arg_names;
size_t arg_count = node->as.call.arg_count;
if (!arg_names) return true;
AstNode* reordered[16] = {0};
for (size_t i = 0; i < arg_count; i++) {
if (arg_names[i]) {
bool found = false;
for (size_t j = param_offset; j < sym->param_count; j++) {
if (sym->param_names && sym->param_names[j] &&
strcmp(arg_names[i], sym->param_names[j]) == 0) {
reordered[j - param_offset] = args[i];
found = true; break;
}
}
// 填充未指定的命名参数（用 NULL 跳过，后续检查会报错）
memcpy(node->as.call.args, reordered, node->as.call.arg_count * sizeof(AstNode*));
if (!found) {
error_add(errors, "<sema>", node->loc.line, node->loc.col,
"'%s' 没有名为 '%s' 的参数", call_name, arg_names[i]);
return false;
}
} else {
reordered[i] = args[i];
}
for (size_t i = 0; i < node->as.call.arg_count; i++) {
}
memcpy(args, reordered, arg_count * sizeof(AstNode*));
return true;
}
static void analyze_call_expr(AstNode* node, Scope* scope, ErrorList* errors, Arena* a) {
Symbol* sym = scope_lookup(scope, node->as.call.name);
if (!sym || sym->kind != SYM_FUNCTION) {
error_add(errors, "<sema>", node->loc.line, node->loc.col,
"未定义的函数 '%s'", node->as.call.name);
node->type.kind = TYPE_ERROR;
for (size_t i = 0; i < node->as.call.arg_count; i++)
analyze_expr(node->as.call.args[i], scope, errors, a);
TypeKind actual = node->as.call.args[i]->type.kind;
TypeKind expected = sym->param_types[i];
if (actual != TYPE_ERROR) {
if (expected == TYPE_STRUCT) {
// 结构体参数：比较具体类型名
const char* actual_name = node->as.call.args[i]->type.struct_name;
const char* expected_name = sym->param_struct_names ? sym->param_struct_names[i] : NULL;
if (actual != TYPE_STRUCT || !actual_name || !expected_name ||
strcmp(actual_name, expected_name) != 0) {
error_add(errors, "<sema>", node->loc.line, node->loc.col,
"参数 %zu 类型不匹配: 期望 '%s'，得到 '%s'",
i + 1,
expected_name ? expected_name : "struct",
actual_name ? actual_name : type_name(actual));
}
} else if (actual != expected &&
!(expected == TYPE_I64 && actual == TYPE_ENUM) &&
!can_implicit_convert(actual, expected) &&
!(actual == TYPE_I64 && node->as.call.args[i]->kind == AST_LITERAL_EXPR
&& (expected == TYPE_I32 || expected == TYPE_U64 || expected == TYPE_CHAR))) {
error_add(errors, "<sema>", node->loc.line, node->loc.col,
"参数 %zu 类型不匹配: 期望 '%s'，得到 '%s'",
i + 1, type_name(expected), type_name(actual));
}
}
}
node->type.kind = sym->return_type;
if (sym->return_type == TYPE_STRUCT && sym->return_struct_type_name) {
node->type.struct_name = sym->return_struct_type_name;
}
break;
return;
}
if (node->as.call.arg_count != sym->param_count) {
error_add(errors, "<sema>", node->loc.line, node->loc.col,
"函数 '%s' 需要 %zu 个参数，但提供了 %zu 个",
node->as.call.name, sym->param_count, node->as.call.arg_count);
node->type.kind = TYPE_ERROR;
for (size_t i = 0; i < node->as.call.arg_count; i++)
analyze_expr(node->as.call.args[i], scope, errors, a);
return;
}
if (!reorder_named_args(node, sym, 0, errors, node->as.call.name)) {
node->type.kind = TYPE_ERROR; return;
}
for (size_t i = 0; i < node->as.call.arg_count; i++) {
analyze_expr(node->as.call.args[i], scope, errors, a);
check_arg_type(node->as.call.args[i], sym->param_types[i],
sym->param_struct_names ? sym->param_struct_names[i] : NULL,
i, node, scope, errors, a);
}
node->type.kind = sym->return_type;
if (sym->return_type == TYPE_STRUCT && sym->return_struct_type_name)
node->type.struct_name = sym->return_struct_type_name;
}
case AST_FIELD_ACCESS: {
analyze_expr(node->as.field_access.object, scope, errors, a);
AstNode* obj = node->as.field_access.object;
if (obj->type.kind == TYPE_ERROR) {
node->type.kind = TYPE_ERROR;
break;
static void analyze_field_access(AstNode* node, Scope* scope, ErrorList* errors, Arena* a) {
analyze_expr(node->as.field_access.object, scope, errors, a);
AstNode* obj = node->as.field_access.object;
if (obj->type.kind == TYPE_ERROR) { node->type.kind = TYPE_ERROR; return; }
if (obj->type.kind != TYPE_STRUCT) {
error_add(errors, "<sema>", node->loc.line, node->loc.col,
"类型 '%s' 不是结构体，不能访问字段 '%s'",
type_name(obj->type.kind), node->as.field_access.field);
node->type.kind = TYPE_ERROR; return;
}
const char* struct_name = obj->type.struct_name;
if (!struct_name) {
error_add(errors, "<sema>", node->loc.line, node->loc.col, "无法确定结构体类型");
node->type.kind = TYPE_ERROR; return;
}
Symbol* struct_sym = scope_lookup_struct(scope, struct_name);
if (!struct_sym) {
error_add(errors, "<sema>", node->loc.line, node->loc.col,
"未定义的结构体 '%s'", struct_name);
node->type.kind = TYPE_ERROR; return;
}
int fi = scope_struct_field_index(struct_sym, node->as.field_access.field);
if (fi < 0) {
error_add(errors, "<sema>", node->loc.line, node->loc.col,
"结构体 '%s' 没有字段 '%s'", struct_name, node->as.field_access.field);
node->type.kind = TYPE_ERROR; return;
}
node->type.kind = struct_sym->struct_field_types[fi];
node->as.field_access.field_index = fi;
if (node->type.kind == TYPE_STRUCT && struct_sym->struct_field_struct_names &&
struct_sym->struct_field_struct_names[fi])
node->type.struct_name = struct_sym->struct_field_struct_names[fi];
}
static void analyze_struct_init(AstNode* node, Scope* scope, ErrorList* errors, Arena* a) {
const char* resolved = node->as.struct_init.type_name;
Symbol* struct_sym = scope_lookup_struct(scope, resolved);
if (!struct_sym) {
Symbol* alias_sym = scope_lookup(scope, resolved);
if (alias_sym && alias_sym->is_type_alias && alias_sym->struct_type_name) {
resolved = alias_sym->struct_type_name;
struct_sym = scope_lookup_struct(scope, resolved);
node->as.struct_init.type_name = resolved;
}
if (obj->type.kind != TYPE_STRUCT) {
error_add(errors, "<sema>", node->loc.line, node->loc.col,
"类型 '%s' 不是结构体，不能访问字段 '%s'",
type_name(obj->type.kind), node->as.field_access.field);
node->type.kind = TYPE_ERROR;
break;
}
// 查找结构体定义
const char* struct_name = obj->type.struct_name;
if (!struct_name) {
error_add(errors, "<sema>", node->loc.line, node->loc.col,
"无法确定结构体类型");
node->type.kind = TYPE_ERROR;
break;
}
Symbol* struct_sym = scope_lookup_struct(scope, struct_name);
if (!struct_sym) {
error_add(errors, "<sema>", node->loc.line, node->loc.col,
"未定义的结构体 '%s'", struct_name);
node->type.kind = TYPE_ERROR;
break;
}
int fi = scope_struct_field_index(struct_sym, node->as.field_access.field);
}
if (!struct_sym) {
error_add(errors, "<sema>", node->loc.line, node->loc.col,
"未定义的结构体类型 '%s'", node->as.struct_init.type_name);
node->type.kind = TYPE_ERROR; return;
}
if (node->as.struct_init.field_count != struct_sym->struct_field_count) {
error_add(errors, "<sema>", node->loc.line, node->loc.col,
"结构体 '%s' 有 %zu 个字段，但提供了 %zu 个",
node->as.struct_init.type_name,
struct_sym->struct_field_count, node->as.struct_init.field_count);
node->type.kind = TYPE_ERROR; return;
}
for (size_t i = 0; i < node->as.struct_init.field_count; i++) {
const char* fname = node->as.struct_init.field_names[i];
AstNode* fval = node->as.struct_init.field_values[i];
analyze_expr(fval, scope, errors, a);
int fi = scope_struct_field_index(struct_sym, fname);
if (fi < 0) {
error_add(errors, "<sema>", node->loc.line, node->loc.col,
"结构体 '%s' 没有字段 '%s'", struct_name, node->as.field_access.field);
node->type.kind = TYPE_ERROR;
break;
"结构体 '%s' 没有字段 '%s'", node->as.struct_init.type_name, fname);
node->type.kind = TYPE_ERROR; continue;
}
node->type.kind = struct_sym->struct_field_types[fi];
node->as.field_access.field_index = fi;
// 如果字段也是结构体类型，传播类型名
if (node->type.kind == TYPE_STRUCT &&
struct_sym->struct_field_struct_names &&
struct_sym->struct_field_struct_names[fi]) {
node->type.struct_name = struct_sym->struct_field_struct_names[fi];
}
break;
TypeKind expected = struct_sym->struct_field_types[fi];
TypeKind actual = fval->type.kind;
if (actual != TYPE_ERROR && actual != expected)
error_add(errors, "<sema>", node->loc.line, node->loc.col,
"字段 '%s' 类型不匹配: 期望 '%s'，得到 '%s'",
fname, type_name(expected), type_name(actual));
}
case AST_STRUCT_INIT: {
const char* resolved_type_name = node->as.struct_init.type_name;
Symbol* struct_sym = scope_lookup_struct(scope, resolved_type_name);
if (!struct_sym) {
// 检查是否是类型别名指向结构体
Symbol* alias_sym = scope_lookup(scope, resolved_type_name);
if (alias_sym && alias_sym->is_type_alias && alias_sym->struct_type_name) {
resolved_type_name = alias_sym->struct_type_name;
struct_sym = scope_lookup_struct(scope, resolved_type_name);
// 更新 type_name 为真实结构体名（codegen 需要）
node->as.struct_init.type_name = resolved_type_name;
}
}
if (!struct_sym) {
error_add(errors, "<sema>", node->loc.line, node->loc.col,
"未定义的结构体类型 '%s'", node->as.struct_init.type_name);
node->type.kind = TYPE_ERROR;
break;
}
if (node->as.struct_init.field_count != struct_sym->struct_field_count) {
error_add(errors, "<sema>", node->loc.line, node->loc.col,
"结构体 '%s' 有 %zu 个字段，但提供了 %zu 个",
node->as.struct_init.type_name,
struct_sym->struct_field_count,
node->as.struct_init.field_count);
node->type.kind = TYPE_ERROR;
break;
}
// 检查每个字段名和类型匹配
for (size_t i = 0; i < node->as.struct_init.field_count; i++) {
const char* fname = node->as.struct_init.field_names[i];
AstNode* fval = node->as.struct_init.field_values[i];
analyze_expr(fval, scope, errors, a);
int fi = scope_struct_field_index(struct_sym, fname);
if (fi < 0) {
error_add(errors, "<sema>", node->loc.line, node->loc.col,
"结构体 '%s' 没有字段 '%s'",
node->as.struct_init.type_name, fname);
node->type.kind = TYPE_ERROR;
continue;
}
TypeKind expected = struct_sym->struct_field_types[fi];
TypeKind actual = fval->type.kind;
if (actual != TYPE_ERROR && actual != expected) {
error_add(errors, "<sema>", node->loc.line, node->loc.col,
"字段 '%s' 类型不匹配: 期望 '%s'，得到 '%s'",
fname, type_name(expected), type_name(actual));
}
}
if (node->type.kind != TYPE_ERROR) {
node->type.kind = TYPE_STRUCT;
node->type.struct_name = resolved_type_name;
}
break;
if (node->type.kind != TYPE_ERROR) {
node->type.kind = TYPE_STRUCT;
node->type.struct_name = resolved;
}
}
case AST_ENUM_VARIANT: {
Symbol* enum_sym = scope_lookup_struct(scope, node->as.enum_variant.enum_name);
if (!enum_sym || enum_sym->kind != SYM_ENUM) {
error_add(errors, "<sema>", node->loc.line, node->loc.col,
"未定义的枚举 '%s'", node->as.enum_variant.enum_name);
node->type.kind = TYPE_ERROR; break;
}
int vi = scope_enum_variant_index(enum_sym, node->as.enum_variant.variant_name);
if (vi < 0) {
error_add(errors, "<sema>", node->loc.line, node->loc.col,
"枚举 '%s' 没有变体 '%s'",
node->as.enum_variant.enum_name,
node->as.enum_variant.variant_name);
node->type.kind = TYPE_ERROR; break;
}
node->as.enum_variant.variant_index = vi;
node->type.kind = TYPE_ENUM;
break;
static void analyze_enum_variant(AstNode* node, Scope* scope, ErrorList* errors, Arena* a) {
(void)a;
Symbol* enum_sym = scope_lookup_struct(scope, node->as.enum_variant.enum_name);
if (!enum_sym || enum_sym->kind != SYM_ENUM) {
error_add(errors, "<sema>", node->loc.line, node->loc.col,
"未定义的枚举 '%s'", node->as.enum_variant.enum_name);
node->type.kind = TYPE_ERROR; return;
}
case AST_INDEX_EXPR: {
analyze_expr(node->as.index_expr.array, scope, errors, a);
analyze_expr(node->as.index_expr.index, scope, errors, a);
AstNode* arr = node->as.index_expr.array;
AstNode* idx = node->as.index_expr.index;
if (arr->type.kind == TYPE_ERROR) { node->type.kind = TYPE_ERROR; break; }
if (arr->type.kind != TYPE_ARRAY) {
error_add(errors, "<sema>", node->loc.line, node->loc.col,
"类型 '%s' 不支持索引操作", type_name(arr->type.kind));
node->type.kind = TYPE_ERROR; break;
}
if (idx->type.kind == TYPE_ERROR) { node->type.kind = TYPE_ERROR; break; }
if (idx->type.kind != TYPE_I64) {
error_add(errors, "<sema>", node->loc.line, node->loc.col,
"数组索引必须是 i64 类型, 得到 '%s'", type_name(idx->type.kind));
node->type.kind = TYPE_ERROR; break;
}
// 结果类型 = 元素类型
node->type.kind = arr->type.element_type;
node->type.struct_name = arr->type.element_struct_name;
break;
int vi = scope_enum_variant_index(enum_sym, node->as.enum_variant.variant_name);
if (vi < 0) {
error_add(errors, "<sema>", node->loc.line, node->loc.col,
"枚举 '%s' 没有变体 '%s'",
node->as.enum_variant.enum_name, node->as.enum_variant.variant_name);
node->type.kind = TYPE_ERROR; return;
}
node->as.enum_variant.variant_index = vi;
node->type.kind = TYPE_ENUM;
}
case AST_METHOD_CALL: {
analyze_expr(node->as.method_call.receiver, scope, errors, a);
const char* recv_struct = node->as.method_call.receiver->type.struct_name;
if (node->as.method_call.receiver->type.kind != TYPE_STRUCT || !recv_struct) {
error_add(errors, "<sema>", node->loc.line, node->loc.col,
"只有结构体类型支持方法调用");
node->type.kind = TYPE_ERROR; break;
}
// 构造改名后的函数名并查找
char mangled[256];
snprintf(mangled, sizeof(mangled), "%s$%s", recv_struct,
node->as.method_call.method_name);
Symbol* sym = scope_lookup(scope, mangled);
if (!sym || sym->kind != SYM_FUNCTION) {
error_add(errors, "<sema>", node->loc.line, node->loc.col,
"结构体 '%s' 没有方法 '%s'", recv_struct,
node->as.method_call.method_name);
node->type.kind = TYPE_ERROR; break;
}
// 检查参数数量（用户提供的参数 + 隐含的 self）
if (node->as.method_call.arg_count + 1 != sym->param_count) {
error_add(errors, "<sema>", node->loc.line, node->loc.col,
"方法 '%s' 需要 %zu 个参数，提供了 %zu 个",
node->as.method_call.method_name,
sym->param_count > 0 ? sym->param_count - 1 : 0,
node->as.method_call.arg_count);
node->type.kind = TYPE_ERROR; break;
}
// 命名参数重排序（同 CALL_EXPR 逻辑）
if (node->as.method_call.arg_names) {
AstNode* reordered[16] = {0};
for (size_t i = 0; i < node->as.method_call.arg_count; i++) {
if (node->as.method_call.arg_names[i]) {
bool found = false;
for (size_t j = 1; j < sym->param_count; j++) { // skip self
if (sym->param_names && sym->param_names[j] &&
strcmp(node->as.method_call.arg_names[i], sym->param_names[j]) == 0) {
reordered[j - 1] = node->as.method_call.args[i];
found = true; break;
}
}
if (!found) {
error_add(errors, "<sema>", node->loc.line, node->loc.col,
"方法 '%s' 没有名为 '%s' 的参数",
node->as.method_call.method_name, node->as.method_call.arg_names[i]);
node->type.kind = TYPE_ERROR; return;
}
} else {
reordered[i] = node->as.method_call.args[i];
}
}
memcpy(node->as.method_call.args, reordered, node->as.method_call.arg_count * sizeof(AstNode*));
}
// 对每个参数进行类型检查（跳过 self 参数，即 sym->param_types[0] 是 self 的类型）
for (size_t i = 0; i < node->as.method_call.arg_count; i++) {
analyze_expr(node->as.method_call.args[i], scope, errors, a);
TypeKind actual = node->as.method_call.args[i]->type.kind;
TypeKind expected = sym->param_types[i + 1];
if (actual != TYPE_ERROR && actual != expected &&
!(expected == TYPE_I64 && actual == TYPE_ENUM) &&
!can_implicit_convert(actual, expected)) {
if (expected == TYPE_STRUCT) {
// 结构体类型参数：比较具体类型名
const char* actual_name = node->as.method_call.args[i]->type.struct_name;
const char* expected_name = sym->param_struct_names ? sym->param_struct_names[i + 1] : NULL;
if (!actual_name || !expected_name || strcmp(actual_name, expected_name) != 0) {
error_add(errors, "<sema>", node->loc.line, node->loc.col,
"参数 %zu 类型不匹配: 期望 '%s'，得到 '%s'",
i + 1,
expected_name ? expected_name : "struct",
actual_name ? actual_name : type_name(actual));
}
} else {
error_add(errors, "<sema>", node->loc.line, node->loc.col,
"参数 %zu 类型不匹配: 期望 '%s'，得到 '%s'",
i + 1, type_name(expected), type_name(actual));
}
}
}
node->type.kind = sym->return_type;
if (sym->return_type == TYPE_STRUCT && sym->return_struct_type_name) {
node->type.struct_name = sym->return_struct_type_name;
}
break;
static void analyze_index_expr(AstNode* node, Scope* scope, ErrorList* errors, Arena* a) {
analyze_expr(node->as.index_expr.array, scope, errors, a);
analyze_expr(node->as.index_expr.index, scope, errors, a);
AstNode* arr = node->as.index_expr.array;
AstNode* idx = node->as.index_expr.index;
if (arr->type.kind == TYPE_ERROR) { node->type.kind = TYPE_ERROR; return; }
if (arr->type.kind != TYPE_ARRAY) {
error_add(errors, "<sema>", node->loc.line, node->loc.col,
"类型 '%s' 不支持索引操作", type_name(arr->type.kind));
node->type.kind = TYPE_ERROR; return;
}
if (idx->type.kind == TYPE_ERROR) { node->type.kind = TYPE_ERROR; return; }
if (idx->type.kind != TYPE_I64) {
error_add(errors, "<sema>", node->loc.line, node->loc.col,
"数组索引必须是 i64 类型, 得到 '%s'", type_name(idx->type.kind));
node->type.kind = TYPE_ERROR; return;
}
node->type.kind = arr->type.element_type;
node->type.struct_name = arr->type.element_struct_name;
}
static void analyze_method_call(AstNode* node, Scope* scope, ErrorList* errors, Arena* a) {
analyze_expr(node->as.method_call.receiver, scope, errors, a);
const char* recv_struct = node->as.method_call.receiver->type.struct_name;
if (node->as.method_call.receiver->type.kind != TYPE_STRUCT || !recv_struct) {
error_add(errors, "<sema>", node->loc.line, node->loc.col,
"只有结构体类型支持方法调用");
node->type.kind = TYPE_ERROR; return;
}
char mangled[256];
snprintf(mangled, sizeof(mangled), "%s$%s", recv_struct,
node->as.method_call.method_name);
Symbol* sym = scope_lookup(scope, mangled);
if (!sym || sym->kind != SYM_FUNCTION) {
error_add(errors, "<sema>", node->loc.line, node->loc.col,
"结构体 '%s' 没有方法 '%s'", recv_struct,
node->as.method_call.method_name);
node->type.kind = TYPE_ERROR; return;
}
if (node->as.method_call.arg_count + 1 != sym->param_count) {
error_add(errors, "<sema>", node->loc.line, node->loc.col,
"方法 '%s' 需要 %zu 个参数，提供了 %zu 个",
node->as.method_call.method_name,
sym->param_count > 0 ? sym->param_count - 1 : 0,
node->as.method_call.arg_count);
node->type.kind = TYPE_ERROR; return;
}
if (!reorder_named_args(node, sym, 1, errors, node->as.method_call.method_name)) {
node->type.kind = TYPE_ERROR; return;
}
for (size_t i = 0; i < node->as.method_call.arg_count; i++) {
analyze_expr(node->as.method_call.args[i], scope, errors, a);
check_arg_type(node->as.method_call.args[i], sym->param_types[i + 1],
sym->param_struct_names ? sym->param_struct_names[i + 1] : NULL,
i, node, scope, errors, a);
}
node->type.kind = sym->return_type;
if (sym->return_type == TYPE_STRUCT && sym->return_struct_type_name)
node->type.struct_name = sym->return_struct_type_name;
}
// === 表达式类型检查（调度器） ===
static void analyze_expr(AstNode* node, Scope* scope, ErrorList* errors, Arena* a) {
switch (node->kind) {
case AST_LITERAL_EXPR: break;
case AST_IDENT_EXPR: analyze_ident_expr(node, scope, errors, a); break;
case AST_UNARY_EXPR: analyze_unary_expr(node, scope, errors, a); break;
case AST_BINARY_EXPR: analyze_binary_expr(node, scope, errors, a); break;
case AST_CALL_EXPR: analyze_call_expr(node, scope, errors, a); break;
case AST_FIELD_ACCESS: analyze_field_access(node, scope, errors, a); break;
case AST_STRUCT_INIT: analyze_struct_init(node, scope, errors, a); break;
case AST_ENUM_VARIANT: analyze_enum_variant(node, scope, errors, a); break;
case AST_INDEX_EXPR: analyze_index_expr(node, scope, errors, a); break;
case AST_METHOD_CALL: analyze_method_call(node, scope, errors, a); break;
default: break;
}
}