@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.
- package/LICENSE +202 -0
- package/NOTICE +53 -0
- package/README.md +298 -2
- package/bin/elench.js +69 -0
- package/package.json +37 -4
- package/scripts/clean-pycache.js +37 -0
- package/scripts/npm_smoke.js +88 -0
- package/src/README-/345/205/274/345/256/271/345/261/202.md +26 -0
- package/src/ast_util.py +111 -0
- package/src/bench.py +376 -0
- package/src/borrow.py +282 -0
- package/src/bound.py +13 -0
- package/src/cfg.py +219 -0
- package/src/chart.py +209 -0
- package/src/check_docs.py +156 -0
- package/src/checker.py +2473 -0
- package/src/contract_metric.py +87 -0
- package/src/cost_check.py +13 -0
- package/src/cost_diff.py +533 -0
- package/src/cost_domain/__init__.py +32 -0
- package/src/cost_domain/bound.py +739 -0
- package/src/cost_domain/cost_check.py +394 -0
- package/src/cost_domain/cost_interp.py +1998 -0
- package/src/cost_domain/symbolic.py +554 -0
- package/src/cost_explain.py +503 -0
- package/src/cost_interp.py +13 -0
- package/src/cxx_map.py +184 -0
- package/src/dispatch.py +314 -0
- package/src/dsh.py +3980 -0
- package/src/dup_scan.py +180 -0
- package/src/elench.py +15 -0
- package/src/emit.py +56 -0
- package/src/ffi_c.py +70 -0
- package/src/fmt.py +115 -0
- package/src/formatter.py +596 -0
- package/src/grammar.py +272 -0
- package/src/guarantees.py +116 -0
- package/src/highlight.py +156 -0
- package/src/interp.py +2119 -0
- package/src/isolated.py +161 -0
- package/src/jsonval.py +236 -0
- package/src/kappa_vs_measured.py +347 -0
- package/src/kinds.py +122 -0
- package/src/lexer.py +559 -0
- package/src/migrate_docs.py +115 -0
- package/src/otel.py +579 -0
- package/src/otel_dashboard.py +218 -0
- package/src/otel_export.py +380 -0
- package/src/otel_local_sink.py +141 -0
- package/src/otel_view.py +156 -0
- package/src/parser.py +1909 -0
- package/src/parser.py.bak +1781 -0
- package/src/policy.py +271 -0
- package/src/rename_ch.py +81 -0
- package/src/requires.py +242 -0
- package/src/segment_plan.py +150 -0
- package/src/shape.py +130 -0
- package/src/stdlib.py +1856 -0
- package/src/stdlib.py.bak +1751 -0
- package/src/symbolic.py +13 -0
- package/src/sync_docs.py +225 -0
- package/src/test_checker.py.bak +443 -0
- package/src/test_formatter.py.bak +201 -0
- package/src/test_invalid.py.bak +342 -0
- package/src/test_parser.py.bak +423 -0
- package/src/typecheck.py +865 -0
- package/src/typecheck.py.bak +741 -0
- package/src/typenames.py +56 -0
- package/src/walk.py +197 -0
package/src/typecheck.py
ADDED
|
@@ -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)} 条诊断")
|