@xiaohuo123212/elench 0.0.0-stage → 0.1.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (69) hide show
  1. package/LICENSE +202 -0
  2. package/NOTICE +53 -0
  3. package/README.md +298 -2
  4. package/bin/elench.js +69 -0
  5. package/package.json +37 -4
  6. package/scripts/clean-pycache.js +37 -0
  7. package/scripts/npm_smoke.js +88 -0
  8. package/src/README-/345/205/274/345/256/271/345/261/202.md +26 -0
  9. package/src/ast_util.py +111 -0
  10. package/src/bench.py +376 -0
  11. package/src/borrow.py +282 -0
  12. package/src/bound.py +13 -0
  13. package/src/cfg.py +219 -0
  14. package/src/chart.py +209 -0
  15. package/src/check_docs.py +156 -0
  16. package/src/checker.py +2473 -0
  17. package/src/contract_metric.py +87 -0
  18. package/src/cost_check.py +13 -0
  19. package/src/cost_diff.py +533 -0
  20. package/src/cost_domain/__init__.py +32 -0
  21. package/src/cost_domain/bound.py +739 -0
  22. package/src/cost_domain/cost_check.py +394 -0
  23. package/src/cost_domain/cost_interp.py +1998 -0
  24. package/src/cost_domain/symbolic.py +554 -0
  25. package/src/cost_explain.py +503 -0
  26. package/src/cost_interp.py +13 -0
  27. package/src/cxx_map.py +184 -0
  28. package/src/dispatch.py +314 -0
  29. package/src/dsh.py +3980 -0
  30. package/src/dup_scan.py +180 -0
  31. package/src/elench.py +15 -0
  32. package/src/emit.py +56 -0
  33. package/src/ffi_c.py +70 -0
  34. package/src/fmt.py +115 -0
  35. package/src/formatter.py +596 -0
  36. package/src/grammar.py +272 -0
  37. package/src/guarantees.py +116 -0
  38. package/src/highlight.py +156 -0
  39. package/src/interp.py +2119 -0
  40. package/src/isolated.py +161 -0
  41. package/src/jsonval.py +236 -0
  42. package/src/kappa_vs_measured.py +347 -0
  43. package/src/kinds.py +122 -0
  44. package/src/lexer.py +559 -0
  45. package/src/migrate_docs.py +115 -0
  46. package/src/otel.py +579 -0
  47. package/src/otel_dashboard.py +218 -0
  48. package/src/otel_export.py +380 -0
  49. package/src/otel_local_sink.py +141 -0
  50. package/src/otel_view.py +156 -0
  51. package/src/parser.py +1909 -0
  52. package/src/parser.py.bak +1781 -0
  53. package/src/policy.py +271 -0
  54. package/src/rename_ch.py +81 -0
  55. package/src/requires.py +242 -0
  56. package/src/segment_plan.py +150 -0
  57. package/src/shape.py +130 -0
  58. package/src/stdlib.py +1856 -0
  59. package/src/stdlib.py.bak +1751 -0
  60. package/src/symbolic.py +13 -0
  61. package/src/sync_docs.py +225 -0
  62. package/src/test_checker.py.bak +443 -0
  63. package/src/test_formatter.py.bak +201 -0
  64. package/src/test_invalid.py.bak +342 -0
  65. package/src/test_parser.py.bak +423 -0
  66. package/src/typecheck.py +865 -0
  67. package/src/typecheck.py.bak +741 -0
  68. package/src/typenames.py +56 -0
  69. package/src/walk.py +197 -0
@@ -0,0 +1,865 @@
1
+ #!/usr/bin/env python3
2
+ # SPDX-License-Identifier: Apache-2.0
3
+ # Copyright 2026 Elench contributors
4
+
5
+ # -*- coding: utf-8 -*-
6
+ """typecheck.py —— 名字解析 + 类型检查(M1 的第一项交付)。
7
+
8
+ **为什么两件事放一个文件**:**名字解析的产物就是类型的载体**——
9
+ 不知道 `Token` 是类型还是变量,就没法判断 `Token::Plus` 是什么类型。
10
+ 分两个 pass 只是徒增一次遍历。
11
+
12
+ ## 设计取舍:**未知类型与任何类型兼容**
13
+
14
+ 一个只做"确凿错误"的检查器,比一个"到处误报"的检查器有用得多。
15
+
16
+ 所以本检查器有 `UNKNOWN` 类型,它与任何类型都可兼容。**只有当两边都确定且不兼容时才报错。**
17
+
18
+ 这样:
19
+ - **样例全部能过**(泛型、闭包等处一律 UNKNOWN)
20
+ **E12 的精度边界就在这里**:UNKNOWN 保证「不误报」,代价是「会漏报」。
21
+ - **确凿的错误照样抓住**(返回 `u64` 的函数 `return true;`)
22
+
23
+ ## 已实现的检查
24
+
25
+ | # | 规则 | 错误码 |
26
+ |---|---|---|
27
+ | T-1 | 未声明的名字 | `E-Name-Undefined` |
28
+ | T-2 | 同一作用域重复声明 | `E-Name-Duplicate` |
29
+ | T-3 | **遮蔽外层名字**(用户定:禁止) | `E-Name-Shadowed` |
30
+ | T-4 | 返回类型与签名不符 | `E-Type-Return` |
31
+ | T-5 | 实参类型与形参不符 | `E-Type-ArgMismatch` |
32
+ | T-6 | `?` 用在非 `Result` 上 | `E-Try-NotResult` |
33
+ | T-7 | `match` 臂不穷尽且无 `_` | `E-Match-NonExhaustive` |
34
+ | T-8 | 枚举变体不存在 | `E-Variant-Unknown` |
35
+ | T-9 | 赋值类型不符 | `E-Type-Assign` |
36
+ | T-10 | 条件不是 `bool` | `E-Type-Cond` |
37
+ """
38
+ import stdlib
39
+
40
+ from typing import Any, Dict, List, Optional, Set, Tuple
41
+
42
+ from parser import Node
43
+ from typenames import canon
44
+
45
+ # ---------------------------------------------------------------- 类型
46
+
47
+ UNKNOWN = "?" # 与任何类型兼容
48
+ NUMERIC = {"u8", "u16", "u32", "u64", "i8", "i16", "i32", "i64"}
49
+ FLOATS = {"f32", "f64"}
50
+ INT_WIDTH = {"u8": 8, "u16": 16, "u32": 32, "u64": 64,
51
+ "i8": 8, "i16": 16, "i32": 32, "i64": 64}
52
+
53
+
54
+ class Ty:
55
+ """一个类型。`kind` ∈ name / tuple / ref / fn / unknown。"""
56
+
57
+ __slots__ = ("kind", "name", "args", "mut")
58
+
59
+ def __init__(self, kind: str, name: str = "", args=(), mut: bool = False):
60
+ self.kind = kind
61
+ self.name = name
62
+ self.args = tuple(args)
63
+ self.mut = mut
64
+
65
+ def __repr__(self) -> str:
66
+ return self.render()
67
+
68
+ def render(self) -> str:
69
+ if self.kind == "unknown":
70
+ return UNKNOWN
71
+ if self.kind == "tuple":
72
+ return "(" + ", ".join(a.render() for a in self.args) + ")"
73
+ if self.kind == "ref":
74
+ return ("const " if not self.mut else "") + self.args[0].render() + "&"
75
+ if self.kind == "name":
76
+ if self.args:
77
+ return f"{self.name}<" + ", ".join(a.render() for a in self.args) + ">"
78
+ return self.name
79
+ if self.kind == "fn":
80
+ return "fn"
81
+ return "?"
82
+
83
+
84
+ TY_UNKNOWN = Ty("unknown")
85
+ TY_BOOL = Ty("name", "bool")
86
+ TY_U64 = Ty("name", "u64")
87
+ TY_I64 = Ty("name", "i64")
88
+ TY_F64 = Ty("name", "f64")
89
+ TY_VOID = Ty("name", "void")
90
+
91
+
92
+
93
+ def _is_float(t) -> bool:
94
+ """是不是浮点类型(`f32`/`f64`)。"""
95
+ return getattr(t, "kind", "") == "name" and t.name in FLOATS
96
+
97
+ def compatible(a: Ty, b: Ty) -> bool:
98
+ """a 能不能赋给 b。UNKNOWN 与任何类型兼容。"""
99
+ if a.kind == "unknown" or b.kind == "unknown":
100
+ return True
101
+ if a.kind == "ref":
102
+ a = a.args[0]
103
+ if b.kind == "ref":
104
+ b = b.args[0]
105
+ if a.kind != b.kind:
106
+ return False
107
+ if a.kind == "fn":
108
+ # **函数类型逐项比对**(L-06,2026-11-06):以前只比参数个数,
109
+ # 于是 `fn(u64) -> u64` 与 `fn(bool) -> u64` 被判成兼容——
110
+ # 调用点会把 `n` 传进一个要 `bool` 的函数,静态检查却放行。
111
+ # `Ty("fn").args` 是「参数…, 返回」的平铺列表,所以逐项比对
112
+ # 顺带把返回值也比了。`compatible` 对嵌套 `fn` 递归,结构有限必终止。
113
+ return (len(a.args) == len(b.args)
114
+ and all(compatible(x, y) for x, y in zip(a.args, b.args)))
115
+ if a.kind == "tuple":
116
+ return (len(a.args) == len(b.args)
117
+ and all(compatible(x, y) for x, y in zip(a.args, b.args)))
118
+ if a.kind == "name":
119
+ # **过 canon**:`Vec` 与 `vector` 是同一个类型(改名期两套写法都要能用)。
120
+ # 只改构造侧(内建返回类型)而不改比较侧,会让 read_stdin 这类
121
+ # "内建返回 vs 声明"的比较失败。
122
+ if canon(a.name) == canon(b.name):
123
+ return (len(a.args) == len(b.args)
124
+ and all(compatible(x, y) for x, y in zip(a.args, b.args)))
125
+ # 数值类型之间一律按 UNKNOWN 处理(N2 禁止隐式转换,这里不代替 N2,
126
+ # 只是不制造误报;真正的 N2 检查由 checker 的字面量规则负责)
127
+ if a.name in NUMERIC and b.name in NUMERIC:
128
+ return True
129
+ # **浮点之间可赋值**:`f32 → f64` 无损;反方向按 C++ 允许(收窄是 N2 的事)。
130
+ if a.name in FLOATS and b.name in FLOATS:
131
+ return True
132
+ # 整数 ↔ 浮点(`f64 x = 3;`)也放行,理由同上。
133
+ if (a.name in NUMERIC and b.name in FLOATS) or (a.name in FLOATS and b.name in NUMERIC):
134
+ return True
135
+ return False
136
+ return False
137
+
138
+
139
+ def ty_of_node(n: Optional[Node]) -> Ty:
140
+ """把 AST 的类型节点变成 Ty。"""
141
+ if n is None:
142
+ return TY_UNKNOWN
143
+ k = n.kind
144
+ if k == "type-name":
145
+ args = []
146
+ for c in n.children:
147
+ if c.kind == "type-args":
148
+ args = [ty_of_node(x) for x in c.children]
149
+ return Ty("name", n.name or "", args)
150
+ if k == "type-fn":
151
+ # **函数类型**:`func(u64, Vec<u8>) -> u64` → Ty("fn", "", [参数..., 返回])
152
+ ps = next((c for c in n.children if c.kind == "type-fn-params"), None)
153
+ ret = n.children[-1] if n.children else None
154
+ args = [ty_of_node(c) for c in (ps.children if ps else [])]
155
+ if ret is not None and ret.kind != "type-fn-params":
156
+ args.append(ty_of_node(ret))
157
+ return Ty("fn", "", args)
158
+ if k == "type-ref":
159
+ return Ty("ref", args=[ty_of_node(n.children[0])] if n.children else [TY_UNKNOWN],
160
+ mut=(n.value == "mut"))
161
+ if k == "type-tuple":
162
+ return Ty("tuple", args=[ty_of_node(c) for c in n.children])
163
+ if k == "type-slice":
164
+ return Ty("name", "vector", [ty_of_node(n.children[0])] if n.children else [TY_UNKNOWN])
165
+ return TY_UNKNOWN
166
+
167
+
168
+ # ---------------------------------------------------------------- 符号表
169
+
170
+ class Sym:
171
+ __slots__ = ("name", "kind", "ty", "node")
172
+
173
+ def __init__(self, name: str, kind: str, ty: Ty, node: Optional[Node] = None):
174
+ self.name = name
175
+ self.kind = kind # type / func / var / const / variant / error
176
+ self.ty = ty
177
+ self.node = node
178
+
179
+
180
+ class Diag:
181
+ __slots__ = ("code", "message", "line", "col", "severity")
182
+
183
+ def __init__(self, code: str, message: str, line: int = 0, col: int = 0,
184
+ severity: str = "error"):
185
+ self.code = code
186
+ self.message = message
187
+ self.line = line
188
+ self.col = col
189
+ self.severity = severity
190
+
191
+ def __repr__(self) -> str:
192
+ return f"{self.code}@{self.line}:{self.col} {self.message}"
193
+
194
+
195
+ class Scope:
196
+ def __init__(self, parent: Optional["Scope"] = None):
197
+ self.parent = parent
198
+ self.names: Dict[str, Sym] = {}
199
+
200
+ def declare(self, s: Sym) -> Optional[Sym]:
201
+ """声明;返回被遮蔽的外层同名符号(有的话)。"""
202
+ if s.name in self.names:
203
+ return self.names[s.name] # 同作用域重复
204
+ self.names[s.name] = s
205
+ outer = self.parent
206
+ while outer is not None:
207
+ if s.name in outer.names:
208
+ return outer.names[s.name]
209
+ outer = outer.parent
210
+ return None
211
+
212
+ def lookup(self, name: str) -> Optional[Sym]:
213
+ sc: Optional[Scope] = self
214
+ while sc is not None:
215
+ if name in sc.names:
216
+ return sc.names[name]
217
+ sc = sc.parent
218
+ return None
219
+
220
+
221
+ # ---------------------------------------------------------------- 检查器
222
+
223
+ class TypeChecker:
224
+ def __init__(self, tu_mod: Optional[Node], ch_mod: Optional[Node]):
225
+ self.tu = tu_mod
226
+ self.eln = ch_mod
227
+ self.diags: List[Diag] = []
228
+ self.globals = Scope()
229
+ self.types: Dict[str, Node] = {} # 类型名 → 声明节点
230
+ # 枚举名 → 变体名集合。**内置 `Io`** 是语言提供的错误枚举,
231
+ # 用户不必在每个 .tu 里重写(I/O 失败需要它)。
232
+ self.enums: Dict[str, Set[str]] = {
233
+ # **内置错误枚举**:每个程序都会遇到,让每个 .tu 重写一遍不合理。
234
+ # 变体由编译器给,**不增加可撒谎位置**。
235
+ "Io": {"NotFound", "Denied", "Failed"},
236
+ "Arithmetic": {"DivisionByZero", "Overflow"},
237
+ "Parse": {"BadNumber", "Overflow"},
238
+ "Range": {"OutOfBounds"},
239
+ "Option": {"Some", "None"},
240
+ }
241
+ self.enum_payload: Dict[Tuple[str, str], Ty] = {}
242
+ self.open_errors: Set[str] = set()
243
+ self.error_types: Set[str] = set()
244
+ self.funcs: Dict[str, Node] = {}
245
+ self.specs: Dict[str, Node] = {}
246
+ self._collect()
247
+
248
+ def _novariant(self, ty_name: str, variant: str) -> str:
249
+ """变体不存在的提示:错误类型和枚举说清楚是哪一个(E3)。"""
250
+ kind = "错误类型" if ty_name in self.error_types else "枚举"
251
+ return "%s %s 没有变体 %s" % (kind, ty_name, variant)
252
+
253
+ # ---------- 收集
254
+ def _collect(self) -> None:
255
+ for mod in (self.tu, self.eln):
256
+ if mod is None:
257
+ continue
258
+ for it in mod.children:
259
+ if it.kind in ("struct", "enum"):
260
+ self.types[it.name] = it
261
+ self.globals.declare(Sym(it.name, "type", Ty("name", it.name), it))
262
+ if it.kind == "enum":
263
+ vs = set()
264
+ for v in it.children:
265
+ if v.kind != "variant":
266
+ continue
267
+ vs.add(v.name)
268
+ payload = (ty_of_node(v.children[0])
269
+ if v.children else TY_UNKNOWN)
270
+ self.enum_payload[(it.name, v.name)] = payload
271
+ self.enums[it.name] = vs
272
+ elif it.kind == "error-decl":
273
+ self.globals.declare(Sym(it.name, "error", TY_UNKNOWN, it))
274
+ # **E3**:写了变体就是封闭(可校验),没写仍然开放(老行为)。
275
+ _vs = {v.name for v in (it.children or []) if getattr(v, 'name', None)}
276
+ if _vs:
277
+ self.enums[it.name] = _vs
278
+ self.error_types.add(it.name)
279
+ else:
280
+ self.open_errors.add(it.name)
281
+ continue
282
+ elif it.kind == "const":
283
+ ty = ty_of_node(it.children[0]) if it.children else TY_UNKNOWN
284
+ self.globals.declare(Sym(it.name, "const", ty, it))
285
+ elif it.kind == "fn":
286
+ self.funcs[it.name] = it
287
+ self.globals.declare(Sym(it.name, "func", self._fn_type(it), it))
288
+ elif it.kind == "spec":
289
+ self.specs[it.name] = it
290
+ self.globals.declare(Sym(it.name, "func", self._spec_type(it), it))
291
+ elif it.kind == "extern":
292
+ # **`extern` 也是可调用的函数**,但以前**根本没进符号表**——
293
+ # 于是调外部函数的程序一律报 `E-Name-Undefined`,
294
+ # 而消息还在说"请在 .tu 的 extern 块登记"(已经登记了)。
295
+ # 现在按 spec 的方式收进来:签名一样,只是没有实现体。
296
+ self.globals.declare(Sym(it.name, "func", self._spec_type(it), it))
297
+
298
+ def _params_of(self, n: Node) -> List[Tuple[str, Ty]]:
299
+ p = next((c for c in n.children if c.kind == "params"), None)
300
+ out = []
301
+ for c in (p.children if p else []):
302
+ if c.kind == "param":
303
+ out.append((c.name or "", ty_of_node(c.children[0]) if c.children else TY_UNKNOWN))
304
+ elif c.children:
305
+ out.append(("", ty_of_node(c.children[0])))
306
+ return out
307
+
308
+ def _ret_of(self, n: Node) -> Ty:
309
+ base = next((ty_of_node(c) for c in n.children if c.kind.startswith("type")),
310
+ TY_VOID)
311
+ if (n.value or {}).get("fallible"):
312
+ return Ty("name", "Result", [base, Ty("name", "CalcError")])
313
+ return base
314
+
315
+ def _fn_type(self, n: Node) -> Ty:
316
+ # **带返回类型**:与 `func(...)->R` 的 Ty 形状一致(末尾是返回类型)
317
+ ret = ty_of_node(next((c for c in n.children if c.kind in ("type-name", "type-ref", "type-fn")), None))
318
+ return Ty("fn", name=n.name or "",
319
+ args=[t for _, t in self._params_of(n)] + [ret])
320
+
321
+ def _spec_type(self, n: Node) -> Ty:
322
+ ret = ty_of_node(next((c for c in n.children if c.kind in ("type-name", "type-ref", "type-fn")), None))
323
+ return Ty("fn", name=n.name or "",
324
+ args=[t for _, t in self._params_of(n)] + [ret])
325
+
326
+ # ---------- 入口
327
+ def check(self) -> List[Diag]:
328
+ for mod in (self.tu, self.eln):
329
+ if mod is None:
330
+ continue
331
+ for it in mod.children:
332
+ if it.kind == "fn":
333
+ self._check_fn(it)
334
+ return self.diags
335
+
336
+ def _err(self, code: str, msg: str, n: Optional[Node]) -> None:
337
+ self.diags.append(Diag(code, msg, getattr(n, "line", 0) if n else 0,
338
+ getattr(n, "col", 0) if n else 0))
339
+
340
+ def _warn(self, code: str, msg: str, n: Optional[Node]) -> None:
341
+ self.diags.append(Diag(code, msg, getattr(n, "line", 0) if n else 0,
342
+ getattr(n, "col", 0) if n else 0,
343
+ severity="warning"))
344
+
345
+ def _check_fn(self, fn: Node) -> None:
346
+ sc = Scope(self.globals)
347
+ for name, ty in self._params_of(fn):
348
+ if name:
349
+ self._decl(sc, Sym(name, "var", ty, fn))
350
+ block = next((c for c in fn.children if c.kind == "block"), None)
351
+ body_scope = sc
352
+ if block is not None:
353
+ ret = self._ret_of(fn)
354
+ fallible = bool((fn.value or {}).get("fallible"))
355
+ body_scope = self._block(block, sc, ret, fallible)
356
+ # 内核候选体也要查(它们共享宿主的作用域)
357
+ for kern in fn.children:
358
+ if kern.kind != "kernels":
359
+ continue
360
+ for cand in kern.children:
361
+ if cand.kind != "candidate":
362
+ continue
363
+ b = next((c for c in cand.children if c.kind == "block"), None)
364
+ if b is not None:
365
+ # 候选默认 inline:能读宿主局部变量(`n`),所以用宿主的整块作用域
366
+ self._block(b, body_scope, self._ret_of(kern), True)
367
+
368
+ def _decl(self, sc: Scope, s: Sym) -> None:
369
+ # 同一作用域重复
370
+ if s.name in sc.names:
371
+ self._err("E-Name-Duplicate",
372
+ f"`{s.name}` 在同一作用域内重复声明", s.node)
373
+ return
374
+ # 遮蔽外层(用户定:禁止)
375
+ outer = sc.parent
376
+ while outer is not None:
377
+ if s.name in outer.names:
378
+ self._err("E-Name-Shadowed",
379
+ f"`{s.name}` 遮蔽了外层同名符号;本语言禁止遮蔽",
380
+ s.node)
381
+ return
382
+ outer = outer.parent
383
+ sc.names[s.name] = s
384
+
385
+ # ---------- 语句
386
+ def _block(self, blk: Node, outer: Scope, ret: Ty, fallible: bool) -> Scope:
387
+ sc = Scope(outer)
388
+ for st in blk.children:
389
+ self._stmt(st, sc, ret, fallible)
390
+ return sc
391
+
392
+ def _stmt(self, st: Node, sc: Scope, ret: Ty, fallible: bool) -> None:
393
+ k = st.kind
394
+
395
+ if k in ("const-decl", "var-decl"):
396
+ ty = ty_of_node(st.children[0]) if st.children else TY_UNKNOWN
397
+ self._decl(sc, Sym(st.name, "var", ty, st))
398
+ if len(st.children) >= 2:
399
+ vt = self._expr(st.children[-1], sc)
400
+ if not compatible(vt, ty):
401
+ self._err("E-Type-Assign",
402
+ f"`{st.name}` 声明为 {ty.render()},初值是 {vt.render()}",
403
+ st)
404
+ return
405
+
406
+ if k == "assign":
407
+ vt = self._expr(st.children[1], sc)
408
+ tt = self._place(st.children[0], sc)
409
+ if not compatible(vt, tt):
410
+ self._err("E-Type-Assign",
411
+ f"赋值类型不符:左边 {tt.render()},右边 {vt.render()}", st)
412
+ return
413
+
414
+ if k == "return":
415
+ if st.children:
416
+ vt = self._expr(st.children[0], sc)
417
+ want = ret
418
+ if fallible:
419
+ # `T!` 里 `return x` 自动包 Ok;也允许直接返回 Result
420
+ if vt.kind == "name" and vt.name == "Result":
421
+ return
422
+ want = ret.args[0] if (ret.kind == "name" and ret.args) else TY_UNKNOWN
423
+ if not compatible(vt, want):
424
+ self._err("E-Type-Return",
425
+ f"返回类型不符:签名 {want.render()},实际 {vt.render()}", st)
426
+ return
427
+
428
+ if k == "if":
429
+ ct = self._expr(st.children[0], sc) if st.children else TY_BOOL
430
+ if not compatible(ct, TY_BOOL):
431
+ self._err("E-Type-Cond",
432
+ f"if 的条件应是 bool,实际 {ct.render()}", st)
433
+ for c in st.children[1:]:
434
+ if c.kind == "block":
435
+ self._block(c, sc, ret, fallible)
436
+ elif c.kind == "if":
437
+ self._stmt(c, sc, ret, fallible)
438
+ return
439
+
440
+ if k == "while":
441
+ ct = self._expr(st.children[0], sc) if st.children else TY_BOOL
442
+ if not compatible(ct, TY_BOOL):
443
+ self._err("E-Type-Cond",
444
+ f"while 的条件应是 bool,实际 {ct.render()}", st)
445
+ for c in st.children[1:]:
446
+ if c.kind == "block":
447
+ self._block(c, sc, ret, fallible)
448
+ return
449
+
450
+ if k == "for":
451
+ for c in st.children:
452
+ if c.kind == "block":
453
+ inner = Scope(sc)
454
+ # **带下标的 for**:`for (i, x in xs)` —— 下标是 u64,
455
+ # 由语言维护(下标名存在 `st.value`,见 parser.parse_for)。
456
+ _ix = getattr(st, "value", None)
457
+ if _ix:
458
+ self._decl(inner, Sym(_ix, "var", TY_U64, st))
459
+ if st.name:
460
+ self._decl(inner, Sym(st.name, "var", TY_UNKNOWN, st))
461
+ self._block(c, inner, ret, fallible)
462
+ return
463
+
464
+ if k == "match":
465
+ self._match(st, sc, ret, fallible)
466
+ return
467
+
468
+ if k == "block":
469
+ self._block(st, sc, ret, fallible)
470
+ return
471
+
472
+ if k == "expr-stmt" and st.children:
473
+ self._expr(st.children[0], sc)
474
+ return
475
+
476
+ if k == "dispatch":
477
+ self._expr(st, sc)
478
+ return
479
+
480
+ def _place(self, n: Node, sc: Scope) -> Ty:
481
+ if n.kind == "path":
482
+ s = sc.lookup(n.name or "")
483
+ if s is None:
484
+ self._err("E-Name-Undefined", f"未声明的名字 `{n.name}`", n)
485
+ return TY_UNKNOWN
486
+ return s.ty
487
+ return self._expr(n, sc)
488
+
489
+ def _match(self, st: Node, sc: Scope, ret: Ty, fallible: bool) -> None:
490
+ scrut = self._expr(st.children[0], sc) if st.children else TY_UNKNOWN
491
+ arms = [c for c in st.children[1:] if c.kind == "arm"]
492
+ covered: Set[str] = set()
493
+ has_wild = False
494
+ for arm in arms:
495
+ pat = next((c for c in arm.children
496
+ if c.kind in ("pattern", "pattern-wildcard")), None)
497
+ if pat is not None and pat.kind == "pattern-wildcard":
498
+ has_wild = True
499
+ elif pat is not None and pat.name:
500
+ parts = pat.name.split(".")
501
+ if len(parts) == 2:
502
+ ty_name, variant = parts
503
+ covered.add(variant)
504
+ if (ty_name in self.enums and ty_name not in self.open_errors
505
+ and variant not in self.enums[ty_name]):
506
+ self._err("E-Variant-Unknown",
507
+ self._novariant(ty_name, variant), pat)
508
+ inner = Scope(sc)
509
+ # `Token::Number(n)` —— 绑定名是 **pattern 的子节点**,不是 arm 的直接子节点。
510
+ # 不在这里声明,`return n` 就会报 `E-Name-Undefined`(速查里最常用的
511
+ # enum + match 写法都过不了)。
512
+ if pat is not None:
513
+ for b in pat.children:
514
+ if b.kind == "binding":
515
+ # 载荷类型未跟踪(E12 的一部分),先给 UNKNOWN——它对任何类型都兼容
516
+ self._decl(inner, Sym(b.name or "", "var", TY_UNKNOWN, b))
517
+ if arm is not None:
518
+ for b in arm.children:
519
+ if b.kind == "binding":
520
+ self._decl(inner, Sym(b.name or "", "var", TY_UNKNOWN, b))
521
+ elif b.kind == "block":
522
+ self._block(b, inner, ret, fallible)
523
+ elif b.kind not in ("pattern", "pattern-wildcard"):
524
+ self._stmt(b, inner, ret, fallible)
525
+
526
+ # 穷尽性:scrutinee 是已知枚举,且没有 `_`
527
+ if (not has_wild and scrut.kind == "name"
528
+ and scrut.name in self.enums):
529
+ missing = self.enums[scrut.name] - covered
530
+ if missing:
531
+ self._err("E-Match-NonExhaustive",
532
+ f"match 未穷尽 {scrut.name}:缺 {sorted(missing)},也没有 `_` 臂",
533
+ st)
534
+
535
+ # ---------- 表达式
536
+ def _expr(self, n: Optional[Node], sc: Scope) -> Ty:
537
+ if n is None:
538
+ return TY_UNKNOWN
539
+ k = n.kind
540
+
541
+ if k == "lit-float":
542
+ # **浮点字面量默认 `f64`**(C++ 里 `1.5` 是 `double`)。
543
+ # 以前没有这个分支,`1.0 / 3.0` 被当整数除 → `Result<u64, Arithmetic>`。
544
+ return TY_F64
545
+ if k == "lit-int":
546
+ return TY_I64
547
+ if k == "lit-string":
548
+ return Ty("name", "vector", [Ty("name", "u8")])
549
+
550
+ if k == "lit-char":
551
+ return TY_U64
552
+ if k == "lit-bool":
553
+ return TY_BOOL
554
+ if k == "paren":
555
+ return self._expr(n.children[0], sc) if n.children else TY_UNKNOWN
556
+ if k == "tuple":
557
+ return Ty("tuple", args=[self._expr(c, sc) for c in n.children])
558
+ if k == "struct-literal":
559
+ ty_name = n.name or ""
560
+ decl = self.types.get(ty_name)
561
+ want: Dict[str, Ty] = {}
562
+ if decl is not None and decl.kind == "struct":
563
+ for f in decl.children:
564
+ if f.kind == "field" and f.children:
565
+ want[f.name] = ty_of_node(f.children[0])
566
+ got = set()
567
+ for fi in n.children:
568
+ if fi.kind != "field-init" or not fi.children:
569
+ continue
570
+ got.add(fi.name)
571
+ vt = self._expr(fi.children[0], sc)
572
+ if fi.name in want and not compatible(vt, want[fi.name]):
573
+ self._err("E-Type-FieldMismatch",
574
+ f"{ty_name}.{fi.name} 是 {want[fi.name].render()},"
575
+ f"给的是 {vt.render()}", fi)
576
+ elif want and fi.name not in want:
577
+ self._err("E-Type-NoField",
578
+ f"{ty_name} 没有字段 {fi.name}"
579
+ f"(有:{', '.join(sorted(want))})", fi)
580
+ missing = set(want) - got
581
+ if missing:
582
+ self._err("E-Type-MissingField",
583
+ f"{ty_name} 缺字段 {sorted(missing)}", n)
584
+ return Ty("name", ty_name)
585
+
586
+ if k == "path":
587
+ name = n.name or ""
588
+ if "." in name:
589
+ ty_name, variant = name.rsplit(".", 1)
590
+ if (ty_name in self.enums and ty_name not in self.open_errors
591
+ and variant not in self.enums[ty_name]):
592
+ self._err("E-Variant-Unknown",
593
+ self._novariant(ty_name, variant), n)
594
+ return self.enum_payload.get((ty_name, variant),
595
+ Ty("name", ty_name))
596
+ s = sc.lookup(name)
597
+ if s is None:
598
+ # **弃用内建**:名字还认(老代码能跑),但给出改写指引
599
+ try:
600
+ import stdlib as _std
601
+ if _std.is_deprecated(name):
602
+ self._warn(
603
+ "W-Builtin-Deprecated",
604
+ f"`{name}` 已弃用(v0.73 移除):改用 "
605
+ + _std.replacement_for(name), n)
606
+ return TY_UNKNOWN
607
+ except Exception: # noqa: BLE001
608
+ pass
609
+ self._err("E-Name-Undefined", f"未声明的名字 `{name}`", n)
610
+ return TY_UNKNOWN
611
+ return s.ty
612
+
613
+ if k == "unary":
614
+ t = self._expr(n.children[0], sc) if n.children else TY_UNKNOWN
615
+ return TY_BOOL if (n.value or "") == "not" else t
616
+
617
+ if k == "binary":
618
+ op = n.value or ""
619
+ a = self._expr(n.children[0], sc) if n.children else TY_UNKNOWN
620
+ b = self._expr(n.children[1], sc) if len(n.children) > 1 else TY_UNKNOWN
621
+ if op in ("and", "or"):
622
+ return TY_BOOL
623
+ if op in ("<", "<=", ">", ">=", "==", "!="):
624
+ return TY_BOOL
625
+ if op in ("/", "%"):
626
+ # **浮点除法不失败**(2026-11-05):IEEE 754 里 `1.0/0.0 = inf`、
627
+ # `0.0/0.0 = nan`,是**有定义的值**,不是错误。所以浮点走原类型,
628
+ # 只有整数除法才返回 `Result<_, Arithmetic>`(除零要 `requires`)。
629
+ if _is_float(a) or _is_float(b):
630
+ return a if _is_float(a) else b
631
+ return Ty("name", "Result", [a if a.kind != "unknown" else TY_U64,
632
+ Ty("name", "Arithmetic")])
633
+ return a if a.kind != "unknown" else b
634
+
635
+ if k == "call":
636
+ name = n.name or ""
637
+ args = []
638
+ for c in n.children:
639
+ if c.kind == "args":
640
+ args = [self._expr(a, sc) for a in c.children
641
+ if a.kind != "named-arg"] + \
642
+ [self._expr(a.children[0], sc) for a in c.children
643
+ if a.kind == "named-arg" and a.children]
644
+ if "." in name:
645
+ ty_name, variant = name.rsplit(".", 1)
646
+ if (ty_name in self.enums and ty_name not in self.open_errors
647
+ and variant not in self.enums[ty_name]):
648
+ self._err("E-Variant-Unknown",
649
+ self._novariant(ty_name, variant), n)
650
+ return Ty("name", ty_name)
651
+ if name in ("Ok", "Err"):
652
+ return Ty("name", "Result", args[:1] or [TY_UNKNOWN])
653
+ if name in ("push_heap", "pop_heap"):
654
+ # 堆原语(对齐 std::push_heap / std::pop_heap):返回 u64。
655
+ return TY_U64
656
+ if name == "swap":
657
+ # 原地交换(B3):3 个实参,返回 u64(0)。
658
+ if len(args) != 3:
659
+ self._err("E-Type-ArgCount",
660
+ f"swap 要 3 个实参(容器, i, j),给了 {len(args)}", n)
661
+ return TY_U64
662
+ if name in ("sort", "sort_by"):
663
+ # 原地排序,返回元素个数(u64)。比较器是**名字**,不是值。
664
+ return TY_U64
665
+ if name == "for_each":
666
+ # **高阶内建**:`for_each(容器, 具名函数)`(v0.73 起支持 Vec)。
667
+ # 以前只在解释器里有实现、名字表里没有 → 合法程序被 check 拒。
668
+ if len(args) != 2:
669
+ self._err("E-Type-ArgCount",
670
+ f"for_each 要 2 个实参(容器 + 具名函数),给了 {len(args)}", n)
671
+ return TY_U64
672
+ if stdlib.is_stdlib(name):
673
+ # **弃用内建**:还能用,但要告诉作者该改写成什么(v0.73 移除)
674
+ if stdlib.is_deprecated(name):
675
+ self._warn(
676
+ "W-Builtin-Deprecated",
677
+ f"`{name}` 已弃用(v0.73 移除):改用 "
678
+ + stdlib.replacement_for(name), n)
679
+ # 最小基本库:本批全部是 `(容器, …) -> u64`,只校验实参个数。
680
+ if len(args) != stdlib.arity(name):
681
+ self._err("E-Type-ArgCount",
682
+ f"{name} 要 {stdlib.arity(name)} 个实参,给了 {len(args)}", n)
683
+ return TY_UNKNOWN
684
+ # **高阶内建**(v0.71):参数是具名函数,返回容器或 u64
685
+ if name in ("map", "filter"):
686
+ return Ty("name", "vector", [TY_U64])
687
+ if name in ("fold", "count_if"):
688
+ return TY_U64
689
+ _rk = stdlib.ret_kind(name)
690
+ if _rk == "i64":
691
+ return TY_I64
692
+ if _rk == "vec-vec-u8":
693
+ return Ty("name", "vector", [Ty("name", "vector", [Ty("name", "u8")])])
694
+ if _rk == "vec-u8":
695
+ return Ty("name", "vector", [Ty("name", "u8")])
696
+ if _rk == "any":
697
+ return TY_UNKNOWN
698
+ if _rk == "result-vec-u64":
699
+ return Ty("name", "Result", [Ty("name", "vector", [TY_U64])])
700
+ if _rk == "result-u64":
701
+ return Ty("name", "Result", [TY_U64])
702
+ if _rk == "option-vec-u8":
703
+ return Ty("name", "Option", [Ty("name", "vector", [Ty("name", "u8")])])
704
+ if _rk == "result-vec-u8":
705
+ return Ty("name", "Result", [Ty("name", "vector", [Ty("name", "u8")])])
706
+ return TY_U64
707
+ if name in ("map", "filter", "fold", "count_if"):
708
+ # 这些是**解释器直接实现**的(不在 stdlib 注册表里),单独处理
709
+ if name in ("map", "filter"):
710
+ return Ty("name", "vector", [TY_U64])
711
+ return TY_U64
712
+
713
+ if name == "print":
714
+ if not args:
715
+ self._err("E-Type-ArgCount", "print 至少要 1 个实参", n)
716
+ return TY_UNKNOWN
717
+ return TY_U64
718
+ if name in ("min", "max"):
719
+ # 内建二参整数函数:`(T, T) -> T`。成本常数、不改变阶,
720
+ # 所以它能替掉 `if` 串两支而不动成本契约。
721
+ if len(args) != 2:
722
+ self._err("E-Type-ArgCount",
723
+ f"{name} 要 2 个实参,给了 {len(args)}", n)
724
+ return TY_UNKNOWN
725
+ if not (compatible(args[0], args[1])):
726
+ self._err("E-Type-ArgMismatch",
727
+ f"{name} 的两个实参类型不同:"
728
+ f"{args[0].render()} vs {args[1].render()}", n)
729
+ return args[0] if compatible(args[0], args[1]) else TY_UNKNOWN
730
+ if name == "":
731
+ # `FixedVec<T,N>::make()` 这类静态构造:callee 是 field,不是名字
732
+ return TY_UNKNOWN
733
+ s = sc.lookup(name)
734
+ if s is None:
735
+ self._err("E-Name-Undefined",
736
+ f"调用了未声明的函数 `{name}`"
737
+ f"(若它是外部符号,请在 `.tu` 的 `extern` 块登记,"
738
+ f"否则无法只数次数)", n)
739
+ return TY_UNKNOWN
740
+ callee = self.funcs.get(name) or self._find_decl(name)
741
+ if callee is not None:
742
+ want = self._params_of(callee)
743
+ # **类型参数当通配符**(泛型最小切片):形参类型若是被调函数的
744
+ # 类型参数(`func pick<T>(T a, ...)`),任何实参都算匹配。
745
+ # 完整做法要做统一(unification),这里只到"能写、能检查、能跑"。
746
+ _tps = {getattr(c, "name", "") for c in
747
+ next((x for x in getattr(callee, "children", [])
748
+ if getattr(x, "kind", "") == "type-params"), Node("x")).children}
749
+ if len(want) == len(args):
750
+ _bound = {} # 类型参数 → 首次绑定的类型(统一)
751
+ for (pn, pt), at in zip(want, args):
752
+ if getattr(pt, "kind", "") == "name" and pt.name in _tps:
753
+ _prev = _bound.get(pt.name)
754
+ if _prev is None:
755
+ _bound[pt.name] = at
756
+ elif not compatible(at, _prev):
757
+ # **统一失败**:`T` 不能同时是两种类型。
758
+ self._err(
759
+ "E-Type-ArgMismatch",
760
+ f"调用 {name}:类型参数 {pt.name} 同时被绑成 "
761
+ f"{_prev.render()} 和 {at.render()}", n)
762
+ continue
763
+ if not compatible(at, pt):
764
+ self._err("E-Type-ArgMismatch",
765
+ f"调用 {name}:形参 `{pn}` 是 {pt.render()},"
766
+ f"实参是 {at.render()}", n)
767
+ return self._ret_decl(name)
768
+
769
+ if k == "method-call":
770
+ recv = self._expr(n.children[0], sc) if n.children else TY_UNKNOWN
771
+ # `const Vec<u8>& text` 的类型是 ref;取元素类型要先拆引用
772
+ while recv.kind == "ref" and recv.args:
773
+ recv = recv.args[0]
774
+ name = n.name or ""
775
+ if name == "length":
776
+ return TY_U64
777
+ if name == "at":
778
+ return recv.args[0] if recv.args else TY_UNKNOWN
779
+ if name == "push":
780
+ return TY_VOID
781
+ if name == "pop":
782
+ return recv.args[0] if recv.args else TY_UNKNOWN
783
+ return TY_UNKNOWN
784
+
785
+ if k == "field":
786
+ base = self._expr(n.children[0], sc) if n.children else TY_UNKNOWN
787
+ nm = n.name if n.name is not None else str(n.value or "")
788
+ if nm.isdigit():
789
+ idx = int(nm)
790
+ if base.kind == "tuple" and idx < len(base.args):
791
+ return base.args[idx]
792
+ return TY_UNKNOWN
793
+ return TY_UNKNOWN
794
+
795
+ if k == "try":
796
+ inner = self._expr(n.children[0], sc) if n.children else TY_UNKNOWN
797
+ if inner.kind != "unknown" and not (inner.kind == "name"
798
+ and inner.name == "Result"):
799
+ self._err("E-Try-NotResult",
800
+ f"`?` 只能用于 Result,实际是 {inner.render()}", n)
801
+ return TY_UNKNOWN
802
+ return inner.args[0] if inner.args else TY_UNKNOWN
803
+
804
+ if k == "dispatch":
805
+ label = n.name or ""
806
+ for fn in self.funcs.values():
807
+ for kern in fn.children:
808
+ if kern.kind == "kernels" and kern.name == label:
809
+ return self._ret_of(kern)
810
+ return TY_UNKNOWN
811
+
812
+ if k == "cast":
813
+ return ty_of_node(n.children[1]) if len(n.children) > 1 else TY_UNKNOWN
814
+
815
+ if k == "index":
816
+ base = self._expr(n.children[0], sc) if n.children else TY_UNKNOWN
817
+ # `const Vec<u64>& xs` 的类型是 ref;取元素类型要先拆引用,
818
+ # 否则 `xs[0] = 5` 会被当成「给 Vec<u64> 赋 i64」误报 E-Type-Assign。
819
+ while base.kind == "ref" and base.args:
820
+ base = base.args[0]
821
+ return base.args[0] if base.args else TY_UNKNOWN
822
+
823
+ if k == "ref":
824
+ return self._expr(n.children[0], sc) if n.children else TY_UNKNOWN
825
+
826
+ return TY_UNKNOWN
827
+
828
+ def _find_decl(self, name: str) -> Optional[Node]:
829
+ return self.specs.get(name)
830
+
831
+ def _ret_decl(self, name: str) -> Ty:
832
+ fn = self.funcs.get(name)
833
+ if fn is not None:
834
+ t = self._ret_of(fn)
835
+ return t
836
+ sp = self._find_decl(name)
837
+ if sp is not None:
838
+ return self._ret_of(sp)
839
+ return TY_UNKNOWN
840
+
841
+
842
+ # ---------------------------------------------------------------- 便利入口
843
+
844
+ def typecheck(tu_mod: Optional[Node], ch_mod: Optional[Node]) -> List[Diag]:
845
+ return TypeChecker(tu_mod, ch_mod).check()
846
+
847
+
848
+ if __name__ == "__main__":
849
+ import stdlib
850
+ import sys
851
+ from parser import parse_source
852
+
853
+ sys.stdout.reconfigure(encoding="utf-8")
854
+ srcs = [open(p, encoding="utf-8").read() for p in sys.argv[1:]]
855
+ tu = ch = None
856
+ for p, s in zip(sys.argv[1:], srcs):
857
+ m = parse_source(s, p).module
858
+ if p.endswith(".tu"):
859
+ tu = m
860
+ else:
861
+ ch = m
862
+ diags = typecheck(tu, ch)
863
+ for d in diags:
864
+ print(f" {d.code} @{d.line}:{d.col} {d.message}")
865
+ print(f"\n{len(diags)} 条诊断")