# 更新日志

`riantr/moonbit_static_analysis` 的逐版本发布记录。

**README 是面向用户的文档。** 本文件是发布史：每一版改了什么、改动的实测依据是什么、
以及某个结论被撤回时的更正。用法与能力请看 [README.zh.md](README.zh.md)。

英文版发布史见 [CHANGELOG.md](CHANGELOG.md)。


## 0.4.7 要点

**`.mbti` 接口审计学会了跨文件解析类型。** 生成的接口文件大量引用声明在同包其它文件
（或 extern 目录）里的类型——`&Show` 参数、`raise SnapshotError` 返回、`impl Debug for
BenchError` 的目标——此前 `@moonfiles.iface` 只看单文件，core 上 13 个真实 `.mbti`
因此被误报「未知类型」。本版为接口审计建立**模块级接口符号表**：对扫描目标的每个
`.mbti` 逐文件收集声明与 `pub using` 再导出后合并，解析顺序为本文件声明 → 内建名 →
类型参数 → 任一已扫接口（仅类型）。core 上 `.mbti` 缺陷 **13 → 0**，actionable
**49 → 36**。

顺带修掉：`pub using @pkg {type T}` 形状的再导出此前**一条也没被收集**（24 个
type + 20 个 trait 的 prelude 段因此不可见），现在进表。

实测（moonbitlang/core，1029 文件，同一台机器）：

| | 文件 | 解析 | actionable | 未定义名 |
|---|---|---|---|---|
| 0.4.6 | 1029 | 320 | 49 | 17\* |
| 0.4.7 | 1029 | **320** | **36** | **17** |

\* 勘误：0.4.6 行的未定义名发布时误记为 **0**，与该版自己的扫描产物不符——0.4.6 的
扫描里同样有这 17 条，本次核对原始产物后按实测更正；`.mbti` 修复没有触碰它们。

剩余 36 条的构成（下一层的靶子）：17 条未定义名 = 11 条跨文件函数引用（hex / base64
的 v128 bench 文件调用同包其它文件定义的 `sample_bytes` / `encode_scalar`）+ 3 条
引用子集外声明的名字（`E_MAX` / `b` / `N`）+ 3 条其余形态（`is` / `e`）；其余 19 条
是未用绑定等其它缺陷。

自检（扫本仓库自身源码）保持 **0**。测试 231 → 233。

## 0.4.11 —— 第一次扫外部代码：四个修复，全部来自实测

把扫描器指向一个它从没见过的包：

```
moonx riantr/moonbit_static_analysis@latest riantr/pyroduct@latest
```

119 个文件，解析 87，**actionable 43**。逐条分类而不是只数一遍，发现其中 30 条是
分析器自己的缺陷。四个修复，每一条都能追到具体的发现：

| 修复 | 是什么 | 条数 |
|---|---|---|
| `Repr` 进内建表 | `core/debug` 里 `Repr` 枚举的构造器，隐式可见——而**不在** `core/builtin` 接口里（表里其它名字全是从那儿抄的） | 16 |
| 插值里的 import 别名 | `@` 不是标识符字符，所以 `\{@sm.all_states()}` 记录别名时**丢了 `@`**，walk 里 `!has_prefix("@")` 那道闸根本看不见。**这是 0.4.8 自己引入的回归** | 6 |
| `extend` 是声明 | 当成语句读时，`extend` 变成了一个名字 | 8 |
| C 风格三段式 `for` | MoonBit 的另一种 `for`；把它的头部当绑定变量读，就会要求 `in` | 覆盖率 |

`Repr` 是用工具链定的，不是推断的：同一个插值里同时写 `Repr(1)` 和
`ZzNoSuchName123(2)`，`moon check` 只报了第二个。

**覆盖率 73.1% → 86.5%**（87 → 103 / 119）。真正推动覆盖率的是 `for` 修复，而且
是在修复**自身**的第二个 bug 之后：用来区分两种 `for` 的前瞻，最早那版扫描
深度 0 的 `;` 时**没有在函数体的 `{` 处停下**，于是文件后面只要出现一个 `;`，
绑定形式的 `for` 就会被误判成 C 风格，然后死在 `expected ';'` 上。它把本该
恢复 12 个文件的结果变成 4 个，**把错误搬走了而不是消掉**——15 条
`expected 'in'` 变成 14 条 `expected ';'`。现在钉住这一点的测试，就是照着
这个失败写的。

`for` 被降解成 `SBlock[SAssign, SWhile]`，而不是新增 AST 节点——因为每个 lens 都对
`SKind` 做穷尽匹配。它唯一的不精确之处（update 子句在循环后跑一次，而不是每轮
一次）是刻意的，且偏向安静那一侧：update 被保留，因为 `i = i + 1` 正是 `i` 被
**读**的地方，丢掉它会让每个循环计数器看起来都没被用过。这一点有测试钉住。

四个修复合计：**actionable 43 → 31**，其中 26 条属于同一个已知限制——调用同包
另一个文件里的**包私有**辅助函数，`.mbti` 解析看不见它。这已经是剩余问题里
占比最大的一类，**0.4.12 关掉了它**（见下节）。

测试：js 215 / wasm 285 / wasm-gc 215。自检保持 46/46、actionable=0。
五道新防护全部做过突变验证。

## 0.4.12 —— 包私有跨文件解析：剩余最大的一类被关掉

0.4.11 剩下 31 条 actionable 里的 26 条属于同一件事：调用**同包另一个文件**里的
包私有顶层名字。这不是"限制"，是分析器的缺口——MoonBit 的一个**目录就是一个包**，
同目录任何 `.mbt` 声明的顶层名字在兄弟文件里都可见，而分析器只经 `.mbti` 解析跨文件
名字，生成的接口里只有 `pub`。

先把结论量出来，再动手：

- 26 条涉及的 11 个名字（`sieve`、`ridge_fit`、`ridge_predict`、`ols_core`、
  `normal_cdf`、`fmt`、`claim_code`、`claim_of`、`phase_code`、`contains_state`、
  `has_state`）**全部**是同目录兄弟文件里的包私有顶层 `fn`——26/26，没有例外；
- 工具链确认语言确实允许：两文件包里一个文件调用另一个文件的私有 `fn`，
  `moon check` 与 `moon test` 都通过，**跨 `_test.mbt` 也一样**（`has_state`
  正是这一种）。所以这 26 条全是对分析器的误报。

做法是每个**目录**一张表：把该目录下所有 `.mbt` 的顶层声明收进来，与跨文件表求并，
只给这一目录的文件用。`@parser.collect_declared_names` 是**只读 token** 的扫描
（和 `harvest_ctors` 同一手法：`fn` / `struct` / `enum` / `trait` / `type` /
`const` / `let` / `extern` / `suberror`），不是解析——调用方只要名字，而词法是解析的
便宜那一半。

三条边界，都是刻意钉住的：

1. **只取深度 0。** 函数体、`test`、`extend`、`impl` 里的绑定都在至少一层花括号
   之下，永远不会被收进来。否则一个局部 `let` 就能让自己全包可见。
2. **名字必须是关键字后紧邻的那个 token。** `let (a, b) = ...` 后面跟的是 `(`，
   什么都收不到。
3. **`fn Foo::new` 按整体收成 `Foo::new`，不是 `Foo`**——`Foo` 未必存在。

被分析的**文件自己也在自己那张表里**：它本来就是自己包的一部分。副作用是同文件
顶层 `const` 也不再被误报（走查本身不注册 `const` 声明，这一直是个坑）——这是测出来
的，不是顺手带出来的。

`IfaceSymTab::merge` 是**原地改**接收者的，所以这里用的是新的
`IfaceSymTab::union`：合并进共享表会把一个包的私有名字发给另一个包，而符号表里每个
名字都是一次**抑制**，跨包泄漏只会让另一个包里真正未定义的名字不再上报。

**pyroduct actionable 31 → 5**，总发现数 658 → 632，正好 −26：既没有新发现冒出来，
也没有误伤被移走的条目。剩下 5 条：`paths.mbt` 两条 `OperatorMismatch`、
`algebra.mbt` 的 `_classes`、`slot.mbt` 的 `self`、`audit/mbti.mbt` 的 `_f`。

自检 46/46、actionable=0。输出多一行 `PRIVTAB packages=N names=M`——没查过的表和
查过是空的，看起来是一样的，所以它得被说出来。

测试 js 220 / wasm 292 / wasm-gc 220。七道防护做了突变验证，其中**一道是突变找出
来的测试漏洞**：把 `union` 的 types 半边改成写进 `self`，整个套件仍然全绿——因为原
测试只查了值那一半。补上类型侧之后才变红。

## 0.4.46 —— 指针分析底下的几层，以及另一个分析器替我们查出的一个假阳性

**这一版装的是什么。** 九个增量，而且它们是同一件事。0.4.44 引入的指针分析是照讲义的规则写的，
而讲义的规则是写在一张控制流图之上的——这棵树当时没有那张图。所以这一版先把底下的几层建起来，
然后修掉一次交叉验证查出来的东西。

| 增量 | 是什么 |
|---|---|
| 0550 | 指针分析的流敏感那一版读法 |
| 0551 | 基本块——讲义的规则真正写着的那张 CFG |
| 0552 | 三地址码——CFG 与求解器之间的一层 |
| 0553 | SSA——讲义页脚画的那支箭 |
| 0554 | 版本解析器：`@latest` 取的是 **0.4.45**，分析的却是 **0.4.7** |
| 0555 | 与另一个分析器的交叉验证，它查出了我们自己的一个假阳性 |
| 0556 | 同一个交叉验证，换成那个工具的新版本再跑一遍 |
| 0557 | 第三个机制的修复 |
| 0558 | 讲义自己的配置表，一格一格对照 |

### 头条：已发布的 0.4.45 在这个项目自己的源码上报三条假阳性

交叉验证让另一个 MoonBit 分析器（`riantr/LunaFlow`）扫这个仓库自己的树，然后比对两边的判定。
在 LunaFlow 0.1.4 上，它与本分析器在一类发现上不一致，而不一致的是**我们**：一个 `match` 的
arm 不会被求值，所以只在 arm 里赋过值的名字被读成「肯定没赋值」，后面那个读它的 `if` 就认定
了其中一边。

在同一个提交、同一套 harness、同一组开关下实测：

| 产物 | 模块视图 | 每函数视图 | 那几条 unreachable |
|---|---|---|---|
| 已发布的 **0.4.45** | actionable 0 | **actionable 3** | `src/sa/main.mbt:1733`、`src/sa/version.mbt:95`、`src/parser/parser.mbt:4221` |
| **0.4.46** | actionable 0 | **actionable 0** | 无 |

三条都是 `unreachable code (Unreachable) [behavior, MSA-011, high]`，三条都是**这个项目自己源码上的
假阳性**。0.4.46 一条都没有。

修复**没有**去求值 match 的 arm。它问的是一个纯语法走查能回答的问题：**一个 arm 的函数体可能
WRITE 什么？** 名字被收上来，但一个字都没跑；而且只有**已经绑定过**的名字才会被放宽——arm 引入
而别处没有绑定的名字仍然 unbound，因为 arm 并没有运行。

### 流敏感那一版读法，以及它底下的几层

那份参考讲义（Tian Tan, *Pointer Analysis*, Nanjing University, 2021）把**同一个**四语句程序打印了
两遍，并且在第二个答案旁边印了 "false positive"：

    1 c = new C();  2 c.f = "x";  3 s = c.f;  4 c.f = "y";

    p.64  流敏感       c -> {o1}   o1.f -> {"y"}      s -> {"x"}
    p.68  流不敏感     c -> {o1}   o1.f -> {"x","y"}   s -> {"x","y"}

0.4.44 建的是流**不敏感**那一版——讲义标着 "Chosen in this course" 的那一版。0.4.46 建的是流
**敏感**那一版，架在一个通用的求解器上：**基本块**（0551）、**三地址码**（0552）与 **SSA**（0553），
配一个单调的强更新传递函数，所以跑在同一个求解器上。十行测试钉住讲义自己印的表。

**这一切都没有新增发现家族。** 那些层是为了承载讲义描述的那套分析；一个对自己读到的程序说得
更多的工具，并不一定对这个程序的缺陷说得更多。所有语料的数字都没动。

### 版本解析器：它分析的是 38 个版本之前的代码

按 README 说的方式跑——对着一个 registry 坐标——打印出来的是：

    Latest version of riantr/moonbit_static_analysis is 0.4.45
    Fetching riantr/moonbit_static_analysis@0.4.45
    TARGET   riantr/moonbit_static_analysis@latest   .repos/riantr/moonbit_static_analysis/0.4.7
    SCANNED  46 files under .repos/riantr/moonbit_static_analysis/0.4.7

它取的是 0.4.45，分析的却是 **0.4.7**。原因：解析器取了 `readdir` 的**最后一项**，而 `readdir`
不排序——于是「最后一项」其实是**字典序**的最大值，而 "0.4.7" 在字典序上排在 "0.4.45" 后面，
可 7 作为数字比 45 小。现在版本按数字比，而且有一行测试钉住它。

### 记录，以及这个树唯一没有建的那一版读法

0558 把讲义自己的配置表——四个因素、八个选项——一格一格地对着这棵树印出来，并点名每一格由
哪一行测试钉住；四个「本课选择」的标记是用词框坐标**实测**的，不是照文字层顺序读的。八格里五格
已建、三格没有，而这三种「没有」不是一回事：`storeless` 在讲义里连一页都没有；context-sensitive
需要一张附件里根本没有的调用图；demand-driven 拿到了整整六页，却仍然差着一条能决定它的规则。

### 实测

这一版那棵树上的完整发布门禁：**122 行、121 True、1 False**，唯一那条红行是长期在案的
`per-function census control`（工具链的 `moon` 无法类型检查被 pin 的 core）。把计时剥掉后与上一版
的门禁日志逐行对比，两份除了 commit hash 之外完全一样。

与 `riantr/LunaFlow` **0.1.5** 在这个仓库自己树上的交叉验证：

    LunaFlow 0.1.5    dead_code 0   unreachable 0   infinite_loop 0
    本分析器          模块视图 actionable 0，每函数视图 actionable 0

而 0.1.5 自己的报告现在**披露**了它的 CFG 覆盖（「600 of 2417——文件序里的前 600 个；其余 1817 个
函数没有 CFG，也就带不了 CFG 发现」），这类局限正是交叉验证最该带回来的东西。

### 已发布

0.4.46 在两个远端都打上了 `7d0ba68`，CI 的 `gate` 与 `publish` 在那个提交上都是绿的，GitHub
Release 已发布，registry 以 `latest_version = 0.4.46` 提供它。

    published 0.4.46  wasm 53A24C3E...  660472 bytes  checksum aa43ce37...  2026-11-11T13:43:21Z

发布出去的字节按宿主契约核过了——93 个符号、工具链自带的 core 正好是契约下限——而出货的产物扫
这个项目自己的源码时，unreachable-code 发现是 **0** 条，0.4.45 是 3 条。

## 0.4.48 —— 指针分析补齐了它的图、它的调用图、它的堆和它的三种抽象；以及那个从 0.4.47 起一直是红的发布门禁

**本版包含什么。** 五个增量。其中四个补齐了课程指针分析里此前**缺失**的四格（那是对着
两份课件重读本仓库得到的结论），第五个修的是发布门禁本身。

| 增量 | 是什么 | 会走到用户的报告里吗 |
|---|---|---|
| 0579 | 指针流图——课件自己的那张图，边对边，还有它自己的追踪 | 不会——库级测量 |
| 0580 | 过程间算法，调用图边走边建 | 不会 |
| 0581 | 上下文敏感的堆——课件 p.56 的两列，逐行复现 | 不会 |
| 0582 | 三种抽象的对比，以及类型变体 | 不会 |
| 0583 | 那四道从 0570 起就是红的变异门，重新指向并实测 | 不会——但这一版之所以成立靠的是它 |

### 头条：四格缺失，现在补上了

两份课件对着本仓库重读了一遍：`9-10_PTA-FD.pdf`（153 页）和 `11-12_PTA-CS.pdf`
（178 页）。核对了 13 格，结论是**5 格已有、4 格部分、4 格缺失**。本版补的就是这缺失的四格：

| 课件里的那一格 | 现在住在哪 | 增量 |
|---|---|---|
| 指针流图，以及在它上面的差分传播 | `src/flow/pfg.mbt` | 0579 |
| 过程间算法，调用图边走边建 | `src/flow/pta_inter.mbt` | 0580 |
| 上下文敏感的堆——课件 p.56 的两列 | `src/flow/pta_heap_ctx.mbt` | 0581 |
| 类型变体，以及三种抽象之间的关系 | `src/flow/pta_variants.mbt` | 0582 |

它们都不产生发现：都是带公开 API 和自己测试行的测量，报告流水线一个也没调用。这正是
0.4.47 讲清楚的那个区分——**「建成了」和「看得见」是两个不同的主张**——这里刻意再说一次。

### 课件自己的例子是被复现的，不是被转述的

指针流图打印的是课件自己那张图：同样的边、同样的 points-to 集合，还有课件自己的追踪。
上下文敏感的堆把课件 p.56 的**两列**都逐行复现了，连三次分配塌成一个上下文这个课件
自己的测量也复现了。类型变体复现的是课件里的**关系**——类型上下文是对象上下文的一个更粗
的抽象，而调用点抽象与对象抽象不可比——并且在课件自己的**次序**没有被复现的地方照实说明，
因为那个次序是十个 Java 程序上的经验结果，而本工具分析的是 MoonBit。

**两处边界是写出来的，不是绕过去的**：一份假装比实际更强的测量，比一句「不知道」更糟。

  * 课件的 `InType(o_i)` 是**包含**分配点的那个类型，而本仓库的 AST **没有方法体**，所以
    这里的类型上下文是接收者的**声明类型**——同一类的抽象，课件自己的测量照样复现；
  * 课件的 `ProcessCall(x, o_i)` 由接收者驱动，所以对顶层函数的调用只在其调用者变得可达时
    处理一次。

### 第五个增量，才是这一版配得上这个名字的原因

发布门禁是红的，而且 87 道变异门里有四道是红的。原因不是门写坏了：**一道变异门锚在源码
某处的原文上**，而 0570 和 0571 改了那些地方却没有改锚点，于是这四道门的预检直接报
*「N pattern(s) absent. No suite was run.」*——它们什么都没测。

对着每一个发布 tag 逐锚点实测：v0.4.30 到 v0.4.46 这四道门**都是绿的**，**只有 v0.4.47 是
红的**——也就是说 0.4.47 是唯一一个在本地发布门禁为红的情况下发布的版本。门自己的最后
一行写着 *「Nothing was published and no tag should be pushed.」*，而东西还是发出去了。这一点
写在这里，是因为工具做对了，是流程没有做对。

**修法是重新指向，而不是退役**：这些变异测的代码还活着，所以每个锚点都重新指向当前代码，
而每一份替换只去掉它的变异所针对的那一样东西。0507 的锚点顺便做成了未来-proof——它现在指向
映射表的**默认分支**，没有任何新族能把它挤掉，而不是指向最后一个族 id，下一个族就会弄坏它。

四道门各自实测：0439 **7 杀 7**、0442 **5 杀 5**、0467 **杀 7、另有 1 个预期存活**、0507
**杀 14、另有 1 个预期存活**——每一次恢复都由门禁自己证明逐字节一致，另外还独立地对
`src/` 下每个受版本管理的文件在每次运行前后各做了一次哈希，四次全部一致。

### 这一版没有改什么

对别人代码的判决没有变化：四个新模块都是库级的，报告流水线一个也没调用；七个固定语料
仍然全部 MATCH 各自基线；自检仍然是 **0 actionable**。

测试：wasm 1,607 → **1,625**，js 与 wasm-gc 1,465 → **1,483**。没有新增发现族：族表仍是
17 个，也没有任何族 id 被重新编号。


### 已发布

0.4.48 已在两个远端打上 tag `cc17e1c`，CI 的 `gate` 与 `publish` 在该提交上都是绿的，GitHub
Release 已发布，注册表以 `latest_version = 0.4.48` 提供它。

    published 0.4.48  wasm 6F38F3D9...  685218 bytes  checksum 2468b30c...  2026-11-14T18:42:21Z

**已发布的字节是干净的。** 用发布坐标实测：注册表提供的产物扫自己发布的源码，**243/243**
个文件解析，`actionable=0`，且恰好需要那 93 个约定的宿主符号，没有 `moonbitlang/async`
依赖。

而**已发布的产物与 0.4.47 的恰好只差一个字节**——就是产物内嵌坐标里的版本字符。逐字节实测：
两者都是 685218 字节，唯一不同的那个字节是 `@0.4.47`→`@0.4.48` 的 `7`→`8`。

**原因就是这四个增量本身**：指针流图、过程间分析、上下文敏感的堆和类型变体**没有任何
非测试调用者**，而已发布的 wasm 是不带测试文件构建的，所以它并不携带它们。已发布的**源码树**
携带：比 0.4.47 多出八个文件，`src/` 下的 `.mbt` 从 216 增到 224。

这正是这一版该有的诚实说法，也正是 0.4.47 说过的那句：**「建成了」和「看得见」是两个不同
的主张**。装了 0.4.48 的用户会在源码里拿到这四个分析；他们跑的那个产物还是同一个分析器，
只是版本字符串变了。

## 0.4.47 —— 课程自己的那些分析，以及真正走到用户面前的两条发现

**这一版带的是什么。** 六个增量，是同一件事：一个编译原理课程要求做的那些分析，按那份课程
自己的讲义建出来。其中两个能在报告里看见，另外四个是库级的——而这一版把哪一部分是哪一部分说
清楚了。

| 增量 | 是什么 | 走到用户的报告里了吗 |
|---|---|---|
| 0571 | 符号分析——每个变量的符号——以及它换来的两条检查 | **是**——`MSA-016` 与 `MSA-017` |
| 0572 | 到达定值（may，前向） | 否——库级的一次测量 |
| 0573 | CFG 上的函数内常量传播，以及求解器的工作表读法 | 否 |
| 0574 | 调用图：整程序的，在 trait 层次上解析 | 否 |
| 0575 | 指针分析的上下文敏感读法与按需读法 | 否 |
| 0576 | storeless 堆抽象，做在讲义自己引用的那份综述上 | 否 |

### 头条：两条新发现，而编译器这两种形状都不说

`MSA-016`（`DivisionByZero`）与 `MSA-017`（`NegativeIndex`）是这一版的新东西。它们是课程
自己的「一个分析，两个应用」：判定每个变量的**符号**（`+`、`−`、`0`），从而抓住除以零和负
下标。

对着编译器实测：`moon check` 跑一份同时装着 `1 / 0`、`10 / y`、`arr[-1]`、`arr[0 - 1]` 和
`arr[0]` 的探针，退出码 0，对这两种形状一个字都不说。所以这里的一条发现**不是**编译器已经说过
的重复项——它是工具链里唯一会说这件事的东西。

回答的方向是**必然**，而这也是关于崩溃的唯一安全方向：符号未知的除数**不报**，工具只在能证明
的时候说「这次除法**就是**除以零」。两条是两个家族，因为它们是关于**不同操作数**的两条断言——
`MSA-016` 关于除数（`/` 与 `%`），`MSA-017` 关于下标——而一行可以同时带上两者。

### 另外四个是测量，而报告用「什么都不说」表达了这件事

到达定值、函数内常量传播、调用图、指针分析的上下文敏感与按需读法，以及 storeless 堆抽象，
都是**库级**的：每一个都是一次带着公开 API 和自己那几行测试的测量，没有一个会报发现。报告
流水线从数据流那包里调用五样东西，它们不在这五样里。

这个划分是刻意的，而且值得说明白，因为**建好了**和**看得见**是两句话。一个用这个工具的人，
从这六个增量里看到的是**两条新发现**，别的什么都没有；一个读源码的人看到的是课程要求的六个
分析，每一个都有自己的测试行和自己的边界。

实测：同一份文件上，已发布的产物与这一版的树给出的结果不同——已发布的 **0.4.46** 报
`actionable=0`，这一版报两条发现（`MSA-016`、`MSA-017`）。这个缺口就是这一版存在的理由。

### 这里没有什么

课程还有四讲没读，所以这一版不声称覆盖它们。

### 已发布

0.4.47 在两个远端都打上了 `bd69624`，CI 的 `gate` 与 `publish` 在那个提交上都是绿的，GitHub
Release 已发布，registry 以 `latest_version = 0.4.47` 提供它。

    published 0.4.47  wasm 5144FE0F...  685218 bytes  checksum dc340827...  2026-11-14T12:31:08Z

而**发布出去的字节真的做了这一版承诺的事**。同一份文件上实测：**0.4.46** 报 `actionable=0`，
**0.4.47** 报两条发现——`MSA-016`（除数确定为零）与 `MSA-017`（下标确定为负）。这个缺口是在
**用户拿到的字节**上补上的，不是在一个本地构建上补上的。

registry 提供的产物扫它自己出货的源码时是干净的：**235/235** 个文件解析通过、`actionable=0`，
并且它只要契约里那 93 个宿主符号，没有 `moonbitlang/async` 依赖。

## 0.4.45 —— 异步运行时搬进了工具链，依赖没有了

这一版只有一个主题和三个后果，而后果才是重点：**这个包再也不依赖 `moonbitlang/async`
了。** 运行时现在是 `moonbitlang/core/async`，属于用户工具链本来就自带的 `moonbitlang/core`
模块，所以 `moon.mod` 里没有 import 块，也没有版本需要和用户的工具链对齐。

**这不是一次表面改动。** 正是「这个包钉的版本」和「用户的工具链自带的版本」之间的分歧
让 0.4.38 坏掉了：pin 写的是 `moonbitlang/async` 0.22.6，它那三个 console job 的 extern
是自带 0.22.5 的工具链提供不出的，于是产物在分析器跑第一行之前就实例化失败了。运行时
随工具链一起走之后，构建端和宿主端来自**同一个工具链**，产物没法再向宿主要它根本不会有
的符号。

**宿主 ABI 的模块名没变，但符号集合变了。** wasm 导入的模块名来自源码里的 FFI 声明，而
`moonbitlang/core/async` 仍然用 `moonbitlang/async` 这个名字声明它的宿主 extern——在
工具链自己的源码里量过。所以宿主提供的还是同一个模块。变的是集合：**90 → 93**。

| | 符号 |
|---|---|
| 新增 | `stdio/get_stdio_handle`、`thread_pool/get_read_console_result`、`thread_pool/make_read_console_job`、`thread_pool/make_write_console_job`、`thread_pool/run_job` |
| 消失 | `io/errno_is_read_EOF/windows`、`thread_pool/errno_is_cancelled` |

**下限也跟着抬高了。** 实测：独立的 `moonbitlang/async` 0.22.5 只能覆盖 93 个里的 **89**
个。工具链自带的 `moonbitlang/core` **0.10.20+65efd5b93** 声明了 215 个 extern，93 个全覆盖。
所以 **0.4.45 需要自带 `moonbitlang/core` 0.10.20+65efd5b93（或更新）的工具链**——也就是
moon 0.1.20261104 或更新；还在自带独立模块的工具链实例化不了它。这就是那笔交易，它写在
README 和 `moon.mod` 里，而不是等一个用户去撞。

**门禁被重写了，因为旧门禁检查的那个 pin 已经不存在了。** `check_host_requirements.ps1`
仍然双向比对产物的导入面和契约，但下限改成对着**工具链自带的 core** 检查，而不是对着这个
仓库钉的某个包；同时它**拒绝 `moonbitlang/async` 依赖回来**——因为对独立模块的依赖会让
导入面重新变成「这个仓库自己选的版本」的函数，而那正是这次交换要消灭的失败。契约文件现在
写的是 `min-host-core` 和 `host-abi-module`，ABI 模块名**从契约里读**，而不是在门禁里写成
字面量。

**API 已经不是同一个 API，移植就在这一版里。** 合并后的运行时改名并改了形状：代码用到的
四样东西变了——`fs.read_file` → `fs.read_text`、`fs.write_file` → `fs.write_text`（合并后
的运行时没有返回 `Data` 的文件读取了）、`process.run` 返回 `ProcessResult`、退出码是它的一个
字段而不是返回值，还有 `process.collect_output` **没了**——`run` 把重定向当参数收
（`stdout=Collect`），输出流从 `stdout_text()` 拿回来。顺带有一个行为变化值得点名：不是
合法 UTF-8 的文件以前是**静默**跳过的，现在和其它读不出来的文件一样报 `SKIP … unreadable:`。

**`moonbitlang/core/async` 被标着 experimental**，所以用到它的三个包（`moon.pkg`、
`src/sa/moon.pkg`、`src/jsoncli/moon.pkg`）都声明了
`options("allow-experimental-packages": …)`。随工具链一起发、和还没稳定，是两件不同的
事，这个包两件都占。

**还描述旧设置的文档被扫了一遍——按实测扫，不是按替换扫。** 有六个文件还在说旧的运行时、
旧的符号数或者旧的下限。其中最要紧的是 `SKILL.md`：它写着产物「imports 90 symbols」，
还告诉读者「0.4.39 是对着 async 0.22.5 构建的，在自带 0.22.4 或 0.22.5 的工具链上都能
链上」——而那段话**就是**工具链太旧时用户撞上那个错误时读的排障说明。在 changelog 里写错
只是瑕疵；在那段话里写错，会把用户导向「升级分析器」而不是「升级工具链」，而那恰恰是
唯一帮不上他的做法。`src/sa/main.mbt` 那句更尖锐：它开头写着「文件 IO 和子进程来自
`moonbitlang/async`，**而不是 core**」，而这次交换让这句话变成了**假话**。**没动**的部分
比动掉的更重要——`EXTENSIONS.md` 提到 `moonbitlang/async` 七次，分析器自己的源码在 10 个
文件里提到 34 次，其中几乎每一处都是**出处标注**，写明某个测量是在哪个语料上做的。依赖没了，
语料还在。全局替换会把那 41 处出处改写成 41 条关于一个本仓库已不依赖的包的断言，而编译器
一句都不会报错。

**一处钉住的行号挪了位，是门禁抓到的。** `check_transfer_scope.ps1` 会把 0525 那张
TRANSFER MAP 里的每个行号对到这棵树上。这一版自己的文档清扫挪动了其中一处：
`src/sa/main.mbt` 开头就是上面引的那句话，把它从两行改成三行，等于在一个 1,287 行之下
钉着一处位置的文件里多加了一行，于是 `fn filtered_reports` 从 1,287 挪到了 1,288。地图被
重新量过并改正，而检查**没有被放松**——这里最省事的「修法」本来是改成在文件里任意位置
匹配那个 token，可那样更糟：这张地图的全部价值就在于它说的是**哪里**，不只是**什么**。
这是这张地图第三次漂移，也是第三次被门禁而不是被人抓住。

**发布前的门禁——以及这份账，因为它是两轮跑出来的。** 完整门禁报出 **117 行 stage：116 个
True，1 个 False**，那个 False 是 `published package self-scan`：它按 `moon.mod` 里的版本去
registry 取产物来扫，而这个版本还没发布，所以发布前它不可能通过。其余每一行都是 True——87 个
变异门禁、宿主契约、自扫描、README 门禁、八个结构门禁。

**但那个红行后面的行根本没跑。** `release.ps1` 用 `if ($failed.Count -eq 0)` 把最后一段守住
了，所以 published self-scan 红着的时候，语料对比和 per-function 普查是**被跳过**的——现在是
117 行，发布后是 122 行。因此它们用第二次跑测量：`-SkipMutations` 会跳过 published
self-scan，于是那段守住的代码就能跑：语料对比在**七个语料上全部 MATCH**（八棵树 19,616 条
notice），per-function 普查也**MATCH**（TOTAL 28 条 actionable，DEMOTED 21），而 per-function
普查控制是**有案可查**的那个红——`BASELINE FAILED: … abort/pkg.mbti:4`，和 0.4.44、0.4.43
记的逐字相同，原因是 moon 0.1.20261104 开始对接口文件做类型检查，而语料的 pin 比它还早一个
月。这一版既没动语料，也没动工具链。

**发布出去的字节回答了本地构建回答不了的问题。** 0.4.45 在两个远端都打上了 `752624b`，CI 的
`gate` 和 `publish` 在那个 commit 上都是绿的，GitHub release 已发布，registry 从
`2026-11-09T16:25:03Z` 开始提供它，`latest_version = 0.4.45`。published-package self-scan 按
registry 要 0.4.45，读的是**registry 真正在供的那棵树**，扫的也是那棵：203 个文件、203 解析、
actionable 0、1,679 条 notice——而最要紧的是那个数：**正好 93 个契约符号**，`moon.mod` 导入 0 条
路径，工具链自带契约里的 core，215 个 extern 覆盖全部 93 个。本地门禁读的是这个仓库自己构建的
wasm；而那一次读的是 **registry 编译并提供**的 wasm，也就是用户真正实例化的那个。包也能跑：
`moonx riantr/moonbit_static_analysis@0.4.45` 扫一个单文件目标，找出了里面没用到的绑定。
（0.4.38 的失败是产物连**实例化**都做不到；现在这在结构上就不可能，而不是靠运气。）

实测：wasm 上 1,458 个测试，js 与 wasm-gc 各 1,322 个——没变；自扫描读到 204 个文件、
1,679 条 notice、133 打印 + 1,546 汇总、actionable 0，和 0.4.44 发布的数字一样。七个固定
语料一个都没动：分析器的发现部分没有任何变化。

## 0.4.44 —— 数据流框架走向通用：CFG、活变量、死存储家族、无穷格、必然分析、边转移，以及指针分析

二十三个增量，每一件都实测过，各自在 `_verify/NARRATIVE.md` 有对应小节（§0525–§0547）。主线
是一个对象的出现和三次推广：这棵树原本没有控制流图，下面的一切都是有了它之后长出来的。

**1. 一张 CFG、一个不动点，和架在它上面的第一个分析（§0526–§0528）。** `src/flow/cfg.mbt` 是
**单个函数体**上的图：`NodeKind` 携带语句，`succ`/`pred` 是推导出来的而不是手工维护的
（`pred_of` 计算逆关系——两个可能不一致的结构终将不一致），`worklist.mbt` 是 `Lattice` 上的
worklist 求解器。活变量架在上面，然后是 `MSA-015 FDeadStore`——一条没人读它值的存储。对着
真实代码发布，第一版的两个错处都写进了 narrative。

**2. return 表达式是一次读（§0531）。** 在别人的代码上审计新家族，发现了它的 29 条语料发现里
20 条背后的一个 CFG 缺陷：`return e` 在一个没有后继的节点里求值 `e`，于是只在 `return` 里被
读过的绑定看起来没人读。这个家族自己的假阳性，找到了它所有发现所坐落的那张图上的缺陷。

**3. 无穷高的格，以及被书纠正的两个预期（§0529）。** 带加宽和收窄的区间域，钉在书自己印的数字
上而不是钉在实现上——其中两个数字纠正的是测试，不是实现。

**4. 十五个家族里只有六个开过口（§0530–§0536、§0538–§0542）。** 充分性是被数出来的，不是被声明
的：在固定语料上，十五个家族里只有六个曾在别人的代码上产出过发现。`MSA-011` 的多报修掉了
（§0537）；一次修复尝试被实测后**回退**，因为假设本身错了（§0535）；第十个家族投影按家族实际
判定过什么来填（§0539）；剩下九条 `MSA-015` 发现按类逐一读过（§0542），并因此纠正了 §0532 的
第二个类。

**5. 框架曾是 may-only，然后是 intra-only，然后绑在图上（§0544–§0547）。** 缺了三个词，各占一个
增量。必然分析（可用表达式）证明了求解器是 may-only（§0544）。求解器依赖的格定律从断言变成了
检查（§0545）。边转移把「节点转移」变成「节点转移 + 边转移」，架在 ICFG 上——这是过程间常量
传播需要的东西，也是 `(node, state) -> state` 形状的求解器连表述都做不到的东西（§0546）。指针
分析则作为这里第一个**根本不是图问题**的分析到来：流不敏感让程序成为无序语句的集合，所以 CFG
只用来取语句，里面的每一条边都被忽略（§0547）。

**框架增量不新增发现，这是有意的。** §0544–§0547 没有往报告流里接任何东西，所以任何语料的
SUMMARY 都不动：七个固定语料读到的和 0.4.43 一模一样，唯一的移动是本仓库自己的源码。「这个
指针只能指向一个对象」「这个调用的结果是常量」该不该开口，是各自带审计的独立增量。

**本版实测数字。** wasm 上 1,458 个测试，js 与 wasm-gc 各 1,322 个；15 个家族、15 个 id、三档
置信度；87 个编号门禁、504 个活变异（461 个期望被杀、384 个指名测试）；八个固定树共 **19,616**
条 notice，`NOTICES` 表把其中 **3,402** 条算作逐行打印、**16,214** 条算作汇总，且每棵树上渲染
出来的 `notice:` 行数都等于 `printed`。自己的源码：204 个文件、1,679 条 notice。把区域抑制关掉
后：**586** 条 `UnusedLocal`、**1,152** 条 `UnusedParam`，也就是发布版的抑制藏掉了 585 条局部。

**`moonbitlang/async` 的 pin 留在 0.22.5——是重新测过的，不是沿用旧话。** 注册表的最新版是
0.22.7，用它构建会把发布的 wasm 从 104 个导入（90 个来自 `moonbitlang/async`）变成 107 个
（93 个），多出三个需要宿主提供的控制台作业符号。这抬高的**最低宿主工具链版本**——工具链里
bundling 0.22.5 的用户会在实例化时看到 "function import requires a callable"——所以这是一次
需要写下来的决定，不是例行的依赖升级；`check_host_requirements.ps1` 现在会在失败信息里点名那
三个符号，让未来的升级无法悄悄落地。见 `moon.mod` 里的注释。

## 0.4.43 —— 五件事：契约、充分性、两个约束家族、可机检断言，以及一次查出假阳性的审计

本版是一组五件事，每一件都实测过，各自在 `_verify/NARRATIVE.md` 有对应小节（§0520–§0524）。

**1. 家族是一份契约，不是一个 id（§0520）。** 每个家族在严重度之外多声明三样：它断言的性质、
该性质成立所依赖的假设、以及它**不**覆盖什么。`--explain MSA-011` 打印一个家族的三部分后即停；
`--explain-all` 打印整份名单。两者都不跑扫描。`check_family_roster.ps1` 把三张表钉在枚举上，
每个家族一个分支——后来新增的家族没法带着空契约发版。

**2. 充分性作为一个数（§0521）。** `--metrics` 在 `SUMMARY` 之后追加一块：读懂了多少文件、
调用点**访问**了多少/**核对**了多少及其占比、按家族 × 严重度 × 置信度统计的发现、以及声明的作用域
限制数。`n_unchecked` 印了八个版本却没有分母：两万调用点的树上「340 个没核对」听着还好，
四百个的树上就完全是另一回事。做这块时量到两件事，也正因为它们，块里才那么写：

* 第一版数的是**访问次数**，而基本块**尾部**的调用会被类型化两次——一次当语句，一次当带返回
  hint 的尾部表达式。三个夹具实测每次都多 1：`{ f() }` 得 2，`{ f(); f() }` 得 3。现在按 span
  去重；类型化本身未改。
* `unchecked=` 保持 0507 的语义（**访问次数**），因为它的打印值被语料阶段钉住了。所以在本项目
  自己的树上 `sites − checked − unchecked` 等于 **−16**。于是块里算的是
  `not-verified = sites − checked`，并在行上明说这两个计数不可相减。

在本项目自己源码上实测：**199 个文件**，`sites=5048`、`checked=415`（**8.2%**）。这个占比是
**上界**，行上也这么写了：类型透镜不会类型化「名字根本没解析出来」的调用的实参，所以
`ignore(s.length())` 是 2 个点而不是 3 个。

**3. 两个谈「值」而不是谈「流」的家族（§0522）。** `Unreachable` 只看流；没有任何家族看值，
于是「没有任何输入能到达」的分支是隐形的——也就是 V&V 讲义里的**不可行路径**，其定义域是 `D[P]`，
空集本身就是理由。

    MSA-013  InfeasibleBranch   通往这条分支的守卫与它矛盾：D[P] = { }
    MSA-014  RedundantGuard     前面的守卫已经把这个测试的结果钉死了

刻意有界：只有当**不可变局部名与整数字面量比较**时才产生事实。矛盾、被蕴含、**未定**是三种结果；
只有前两种是发现，第三种写进了家族的 `excluded` 契约，免得沉默被读成「可达」。它自己的测试抓出
两个真 bug：循环分支把整条 `while` 语句又喂回遍历，导致无限递归（测试二进制直接崩），以及
`walk_loop` 丢掉出口状态，使循环前的事实活过循环、把一个**可达**分支报成矛盾（实测 `1 != 0`）。

**4. 一条发现就是一条可机检断言（§0523）。** JSON 的 `Finding` 现在带
`predicate: {check, params}`——稳定的 check id 加具名实参——覆盖断言对象是**名字**或**位置**的八个家族。
另有六个家族刻意**不带**：`ParseError` 是关于分析器读到了什么的陈述，五个类型家族断言的是类型关系，
下游要检查它就得重写一遍类型模型。名字型家族的消息里若丢了引号，得到的是「没有 predicate」，
而不是 `name: ""`。

**5. `MSA-011` 审计，以及它查出的假阳性（§0524）。** 讲义把三件事分开：不可达代码、
**死代码**（「执行了，但无关」）、不可行路径。`MSA-011` 覆盖第一种，`MSA-013` 覆盖第三种，
**死代码没有任何家族覆盖**——这一条现在写在它的契约里。审计还量到：

    fn f(c : Bool) -> Int { if c { return 1 } ; return 2 }   +   let x = f(true)
    -> 5:3 - warning: unreachable code                          ← 错的

`f(false)` 会返回 2。行为透镜执行 `f` 时把 `c` 绑成了**调用点**的 `true`。「前一条语句必须是源码级
终结语句」这个守卫试过，已**回退**：它让七个刻意的测试变红，因为「每个分支都终结的 `if`」之后
确实就是死的，「条件折叠成字面量的 `if`」之后也是。要把「由字面量决定」和「由这次执行看到的实参决定」
分开，就得把被调函数的形参抽象绑定——那是独立的一件事。所以这个误报保留着：写进 `excluded` 契约，
并用一个**断言错误答案**的测试钉住，测试里写明修好之后要删掉它。

**依赖未动。** `moonbitlang/async` 仍是 **0.22.5**，这是刻意的：registry 上最新是 0.22.7，
它声明 194 个 extern 并**丢掉了工件所需 90 个里的 22 个**，对着它构建会重现 0.4.38 那种
在 0.22.4/0.22.5 工具链上无法实例化的 wasm。`_verify/check_host_requirements.ps1` 把这个下限钉住。

**本版实测：** 14 个家族，id 自 `MSA-001` 连续；wasm **1367/1367**，js 与 wasm-gc **1231/1231**；
自扫 199 个文件、1721 条 notice、`actionable=0`。

## 0.4.42 —— 编译器弃用了这棵树写的那种语法，而 master 上的 CI 是红的

**分析器的行为没有变。** 发现、规则、产物的导入面，都是 0.4.41 发布的那一套。变的是源码里
每一个 trait 派生的**写法**，以及两条此前只躺在 `master` 上、从未发布的记录修正。

### 工具链动了，然后这棵树编译不过了

2026-11-06 实测：工具链是 `moon 0.1.20261104 (940aa18)`，比 0.4.40 与 0.4.41 验证时的
`0.1.20261028` 新了四天。它把行尾派生写法在 `--deny-warn` 下报成错误：

    deprecated_syntax: The syntax `derive(...)` is deprecated.
    Use `#derive(...)` before the type declaration instead.

于是 `moon check --deny-warn` 以退出码 1 失败，`src/core/core.mbt` 里有**七处**错误——那是第一个
编译的包，后面的根本没轮到。**而且这不是本机的问题：CI 在 `master` 上是红的。** `gate` 在
`08815e3` 和 `3757077` 上都失败了，报的正是同一个 `deprecated_syntax`，而 `813c0de`
（2026-11-02）是绿的。工具链一动之后的每一次推送都在失败。

**要迁移的是 8 个文件里的 34 处**，不是全树查找替换：`ast` 12、`core` 7、`jsoncli` 5、
`types` 3、`walk` 3、`interp` 2、`lexer` 1、`moonfiles` 1。此前数出的 71 是错的——那个数把生成的
`.mbti`、以及字符串和注释里的 `derive(...)` 都算了进来，而那些不是声明。

**迁移工具就是 `moon fmt`。** 在一棵本来 `fmt --check` 就干净的工作树上跑它，产出的正是那八个
文件的 diff，没有别的：`#derive(Eq)` 插到每个声明上方，行尾的 `} derive(Eq)` 去掉，文档注释
原地不动。工具链自己的格式化器认识新语法，所以既不需要手写改写脚本，也没有写。

迁移后实测：

    moon check --deny-warn                     退出码 0（原先是退出码 1、七处错误）
    moon fmt --check                           退出码 0
    moon test --target wasm                    1330/1330
    moon test --target js                      1204/1204
    moon test --target wasm-gc                 1204/1204
    moon build --target wasm                   退出码 0

三个测试数和 README 早已发布的数字一模一样，所以没有测试需要改，也没有测试移动。

**而分析器本来就认得新写法。** 在动任何东西之前，用已发布的 0.4.41 wasm 实测：声明上方的
`#derive(Eq)` 解析出**零**个缺陷、**一**条 notice（声明本身），而行尾写法会出**两**条（声明，
外加一条单独的 `derive` 声明 notice）。所以 parser 不需要新产生式，这次迁移只是**减少** notice。

### 自检的数字动了，而且是重新测量的，不是推出来的

迁移 34 处，就从这棵树自己的扫描里拿掉 34 条 `derive` 声明 notice：

| | 迁移前 | 迁移后 |
|---|---|---|
| 扫描文件 / 解析成功 | 189 / 189 | **189 / 189** |
| actionable | 0 | **0** |
| notice 总数 | 1699 | **1665** |
| —— `derive` 声明 | 54 | **20** |
| —— 逐行打印 / 汇总 | 125 / 1574 | **125 / 1540** |

`derive` 那一行没有归零，原因值得写下来：**其中二十条在未被跟踪的 `_verify/_work_*.mbt`
草稿副本里**——那些是更早源码文件的备份。扫描器走的是工作树而不是索引，所以它看得见；在一份
干净的检出上那一行会是 0。这个 pin 描述的是门禁真正跑的那棵树，这和文件数一直以来的约定一致。

### 顺带发布的两条记录修正

两条都提交在 `master` 上但从未发布，所以读者第一次拿到它们是在 0.4.42：

1. **发布出去的记录指错了产物。** 0.4.41 的叙述把 0.4.40 的产物哈希挂在“the shipped artifact”
   这个标题下，于是装了 0.4.41、又去核对自己拿到的那份字节的读者，会核出一个不一致。现在记录里
   是**每个版本一行**，行只增不改——已发布的产物不可变，所以点着某个版本的一行永远是真的。
   `_verify/check_transfer_scope.ps1` 会把每一行都重新算一遍哈希。
2. **那道门禁的“必须有行”挂在发布 tag 上**，不是挂在 `moon.mod` 上。产物的哈希在注册表编译出它
   之前不可能存在，所以“这棵树声明的版本必须有行”会让任何一次发版都发不出去。有 tag 却没行，
   仍然是失败。测试它的时候又找出并修掉两个问题：一次失败的 `git` 调用被当成了“存在 tag”的证据
   （要看退出码，不是看有没有输出），以及自检里的突变写死了版本号，版本一动它就不再生效。

### 依赖的 pin 没有动

`moonbitlang/async` 已发布的最新版本仍然是 **0.22.7**——2026-11-06 重新查过——而它早在
2026-11-02 就被实测过：194 个 extern，并且**丢掉了**宿主契约要求的 90 个里的 22 个，所以它是一个
不同的面，而不是更大的面。pin 仍然是 **0.22.5**，即实测下来宿主面能被自带 0.22.4 或 0.22.5 的
工具链满足的最新版本；`_verify/check_host_requirements.ps1` 每次发版都拿产物对着它卡一遍。

### 门禁（发布之前）

    RELEASE GATE FAILED: selfscan-published
    116 行 stage 为 True，一行 False
    那一行 False 是 `published package self-scan`

那一道 stage 会去注册表取 `moon.mod` 里那个版本并扫描它，所以在版本发布之前它**不可能**通过；
而它红着的时候，它后面的四行不会跑，这就是为什么这一次是 116 行、发布之后是 121 行。
**语料比对就是那四行之一，所以这一次它对语料一个字都没说**：挡在红灯后面的 stage 不是「通过
了」，是「没跑」。发布之后那一轮量了它——七个语料全部 **MATCH**，八棵树共 **19,602** 条
notice、逐行打印与汇总的拆分是 **3,394 / 16,208**——这就是"这次改的是**仓库**的拼写、不是分析器
的行为"的证据。

### 门禁（发布之后）：121 行，120 行 True，一行 False

    RELEASE GATE FAILED: perfunction-control
    [MATCH ] the eight trees carry 19602 notices
    SCOPE OK: the requirements document is named, its three rows are quoted, every mapped site resolves
    120 stage rows True, one False
    the False is `per-function census control`

行数正是上面预测的 121。那一行 False 是**工具链**的，不是这一版的：moon 0.1.20261104 开始
**类型检查接口文件**，而语料里唯一的 `.mbti`（`abort/pkg.mbti`，写于 2026-10-08、之后一字未动）
写着 `fn[T] abort(String) -> T`，在自举的模块里 `String` 不在作用域内——`Error: [4032] The type
String is undefined`。`abort` 是基础包，所以这一个错误就让编译器在读任何别的包之前停下：控制脚本的
十六次探针每次都只带回这一个错误，读到 **0 of 16** 个文件。同一份语料在上一版工具链下它是**通过**
的（`rel_0412a.txt`，2026-11-03，"read by moon check: 16 of 16"）。

两种修法都试过、都回退了——从副本里删掉接口文件能让基线恢复，但每次探针都返回 `errors=0`；把类型
限定成 `@builtin.String` 只是把错误挪到第 8 行。这一行**保持红色**、没有吸收掉：跑不起来的控制脚本
不等于通过的控制脚本。它需要自己的一次增量。

## 0.4.41 —— 需求文档在上一级目录，而仓库从来没有点名它

**分析器的行为没有变。** 发现、产物的导入面、每一条规则的含义，都是 0.4.40 发布的那一套。变的是
**记录**：要求那三项转移的文档现在被仓库点名了，它的三行要求被逐字引用，每一行都被映射到本仓库里
实现它的地方，而且有一道新门禁守着这张地图不让它烂掉。

**洞在记录里，不在代码里。** 从 PyCQA 的 `bandit` 转过来的三项——每个发现一条**置信度**轴、
**稳定的家族 id** 加上一个被检查的 profile、以及**`nosec`** 连同那条「抑制没压住任何东西」的警告
——都已经实现、过门禁、发过版、并且被独立审过。但它们来自的那份文档 `bandit_review.md` 住在**本仓库
的上一级目录**，而仓库里没有任何东西指着它。一个只拿到本仓库副本的人——没有网络、没有上级目录——
只能看到**做了什么**，看不到**被要求做什么**：那份审计是在拿一份自己读不到的目标作比较。

### 那三行要求，以及每一行落在哪

| 行 | 它要求什么 | 落在哪 |
|---|---|---|
| 1 | 每个发现一条**置信度**轴，与严重度并列 | `src/core/core.mbt:478`、`src/report/report.mbt:214`、`src/jsoncli/main.mbt:24` |
| 2 | **稳定的家族 id**，以及一个被检查的 profile | `src/core/core.mbt:532`、`:583`、`:617`、`src/sa/profile.mbt:64` |
| 3 | **`nosec`**，包括那条「抑制没压住任何东西」的警告 | `src/sa/profile.mbt:224`、`:296`、`:341`、`src/sa/main.mbt:1045` |

三个预测里有**两个精确到行**。评审说第 2 行落在「P1 `core.mbt:491`」，而在评审读到的那棵树
（`9763dfd^`）上实测，`src/core/core.mbt:491` **就是** `pub(all) enum Family {`。现在它在 532 行，
是因为同一个提交把 `Confidence` 枚举加在了它上面；`Lens` 枚举本来就在，当时在 455 行。

**第 3 行落在了别的地方**，而原因是分析器本身的性质，不是计划变了。评审把它放在「`parser.mbt` 的
skip 机制」里，而 parser **并不参与**：一条什么都没压住的抑制，是关于**最终**发现集合的事实——在
各个镜头跑完之后、在 profile 把读者不想要的家族拿掉之后——而 parser 层的 skip 跑在产出那个集合的
镜头**之前**。按家族压的那一半需要这条发现的家族，而家族是镜头产出的，不是 parser 产出的。于是
`nosec` 是从 `src/sa/profile.mbt` 里的原始源码行上读出来的，并应用在最终集合存在的地方。

### 评审给第 3 行自己钉的 pin，被 0507 反转了，而且 settle 自己写着这件事

评审指出，第 3 行的状态「由 `_verify/settle_0505_finding_quality.ps1` 的 C3 行钉住，那行断言
`// nosec` 注释**什么都压不住**」。在 `db08dec` 上实测，那行写的是「THERE IS NO USER-FACING
SUPPRESSION」。现在它写的是「0507 INVERTED THIS ROW'S CLAIM … the DEFAULT is the row」，钉的是
**默认关闭**，而不是「没有抑制这回事」。

**评审那份状态栏在写它的时候是真的。** 它读的是 **2026-10-27** 的工作树；三项转移落在 **2026-10-28**
的 `9763dfd`。它那句「planned, not built」在那一天是对的，而它给第 1 行的证据——发现记录仍然只有
`line, col, severity, message, family, lenses, vst`，而 `src/` 里根本没有 `confidence`——正好就是
`9763dfd^` 里的样子。一份有日期的阅读不是一份过期的阅读。

### 新门禁，以及它**不是**什么

`_verify/check_transfer_scope.ps1` 是一道发版门禁的 stage。它点名那份文档、逐字引用那三行、把地图上
每个 `file:line` 对着这棵树解析一遍——文件在，而且那一行还带着那个符号——检查第 3 行的偏离是被
**解释**过而不只是被记下来、检查被反转的那个 pin、检查两个测量用的 settle 是发版门禁的 stage、
在本地有注册表副本时重新给已发布产物算一次哈希、并检查两份 README 都够得到那份文档和那些文件。
它的 `-SelfTest` 会为「这道门禁可能不再守住的每一种方式」注入一种缺陷，并要求每一种都被抓到：
**注入九种缺陷，九种全部抓到**，而且没动过的一份副本仍然跑绿。

**那份文档没有被改。** 它是需求，而一份被改成迎合实现的需求文档，就不再是需求了。
`bandit_review.md` 的第 4–8 行——identity 排除行号、`bandit-baseline`、SARIF、把双轴直方图当作
测试判据、把跳过的文件当成报出来的事实——是评审自己更进一步的想法，它们**没有被做**。那是一份
清单，不是一个缺口。

### 依赖的 pin 没有动，而原因是实测

`moonbitlang/async` 已发布的最新版本仍然是 **0.22.7**，而它在 2026-11-02 就已经被实测过：它声明
194 个 extern，并且**丢掉了**宿主契约要求的 90 个里的 22 个——所以它不是一个更大的面，而是一个
**不同的**面，对着它构建会向宿主要一套自带 0.22.4 或 0.22.5 的工具链提供不出的东西。pin 仍然是
**0.22.5**——实测下来宿主面能被那些工具链满足的最新版本——`_verify/host_requirements.txt` 里仍然
写着 `min-host-async: 0.22.5`。`_verify/check_host_requirements.ps1` 每次发版都拿产物对着那份契约
卡一遍。「依赖先取最新」是规矩；「最新的、同时是**合法宿主**的依赖」才是能护住一个工具链根本实例化不了
产物的用户的规矩。

### 门禁

在带着这个版本的那棵树上跑完整发版门禁：**121 行 stage，全部 True，0 行 False**，exit 0，stderr 为空。
这里要紧的几行：那三项转移 **19 行**、置信度降级 **12 行**、发现质量 **17 行**，以及新的
transfer-scope stage。CI 不是这道门禁——`gate.yml` 负责编译和测试，这道门禁负责测量。

## 0.4.40 —— 发布出去的文档写错了，而只修在仓库里的修复，谁也收不到

**分析器的行为没有变。** 发现、产物的导入面、每一条规则的含义，都是 0.4.39 发布的那一套。变的有
两处：**跟包一起发布的那几份文档**，以及**五处对工具链已经弃用的核心 API 的调用**。除此之外，
`src/` 的差别是**一段注释**：数字 23,331 被换成了一句每次发版都会被门禁重新测量的断言。

### 跟着包发布出去的 README 里有两句话是错的，而两句都要读者付出代价

**一、README 让读者等一个其实已经发布了的版本。** 用户在分析器实例化失败时会落到的那一段写着：
「今天先用 **0.4.37**，或者升级你的 MoonBit 工具链，等 0.4.39 发布后再换过去。」0.4.39 是
2026-10-30 发布的。所以一个**已经在** 0.4.39 上的读者没法照这句话做——他手里的版本，正是这句话
在等的那个版本。现在这句话写的是 0.4.39**已经发布**。

**二、「最新的 async」这句话是断言出来的，不是测出来的，而它已经被追上了。** 四处地方说 0.22.5 是
能覆盖宿主契约里那 90 个符号的**最新** `moonbitlang/async`：`README.md`、`README.zh.md`、
`moon.mod` 的注释，以及 `_verify/host_requirements.txt` 的文件头。2026-11-02 实测，办法是把包抓到
仓库**外面**的一个临时目录里——仓库里的 `.repos` 正是语料阶段要测的树，它不能动：

| `moonbitlang/async` | 声明了多少 extern | 对那 90 个契约符号 |
|---|---|---|
| 0.22.5 | 223 | 全覆盖 |
| 0.22.6 | 那 223 个**再加三个** console job | 要宿主**多给**三个 |
| 0.22.7 | **194** | **丢掉 90 个里的 22 个**——`event_bus/*` 和 `io/*` 那些——又加上同样那三个 |

所以更新的两个版本**坏法不一样**：0.22.6 是要宿主多给三个符号，0.22.7 是要另一套符号。两个都不是
超集，所以对着它们任何一个构建产物，都会改变这个产物对宿主的要求。那四处地方现在写的是**测到了
什么**和**什么时候测的**，并且写明更新的两个版本不行、坏法各是什么——一个正在用 0.22.6 或 0.22.7
的读者需要知道：只升级这个包，解决不了他的工具链问题。

**依赖仍然钉在 0.22.5。** `_verify/check_host_requirements.ps1` **双向**把这个产物卡在那 90 个契约
符号上，所以对着 0.22.7 构建会导入 22 个契约里没有的符号，门禁会直接拒掉。

### 而构建在这里是绿的，在 runner 上是红的

发版门禁在切它的那台机器上是绿的——在某个工具链上。CI 每次运行都装**最新**的 MoonBit 工具链，
而 2026-11-02 的最新是 **moon 0.1.20261029**，比本地门禁刚跑过的那个工具链新一天。新的 core 弃用了
`String::view`，而 `moon check --deny-warn` 会把弃用当成错误：

```
Error Warning (deprecated): Use `clamped_view(start~, end~)` or `exact_view(start~, end~)` instead
```

于是 publish 在 Gate 这一步挂了，报 `src/moonfiles/moonfiles.mbt` 里的 **5 个错误**——而这次发版
根本没碰过那个文件——并且**什么都没发布出去**。修复就是那五处调用：`String::view` →
`String::exact_view`。

**为什么是 `exact_view` 而不是 `clamped_view`。** 旧的 `view` 在区间非法时是**中止**的——core 里
`guard start_offset >= 0 && start_offset <= end_offset && end_offset <= self.length()` 否则
`abort`——而 `exact_view` 在同样的条件下也是中止，`clamped_view` 却是静默截断。静默截断是另一种
行为换了个名字而已。而且这五处根本不可能有差别：每个区间都是整个字符串，而 `after_n` 用的是
**clamping** 运算符切片，所以结果开头永远不会是一个被劈开的代理对——而 `exact_view` 比 `view` 多查
的就只有这一条。

### 而产出这次发版的门禁变严了

| 改动 | 它挡住了什么 |
|---|---|
| `_verify/check_notice_labels.ps1` 现在数**全部 19 个** `FParse` 构造点 | 一个数得比断言小的门禁没法跟断言分歧——它回答的是另一个问题 |
| `dir2_behavior_reach.ps1` 和 `census_perfunction.ps1` 现在带 `--no-auto-fetch-deps`，并**断言这次扫描什么也没抓** | 一个要测量语料的阶段不能有权改写语料 |
| 发版门禁自己的结论记进了 `_verify/NARRATIVE.md` §0510，带上它属于哪个提交，以及**它那些数字里哪些是离线读者能重新测的** | 只有产出它的工具能看到的结论，谁也核对不了的结论 |
| 源码里不再引用 `23,331`，改成陈述那句**被门禁卡住的**断言——那个计数必须是 0 | 测过一次的数字是记忆，不是数字 |

**用户该做什么。** 用 0.4.40：什么都不用做，除非你的工具链带的 async 比 0.22.4 还老。发现、产物的
导入面、分析器的行为，都是 0.4.39 的那些。

## 0.4.39 —— 发布出去的 wasm 是对着**你的**工具链链接的，现在有门禁盯着这件事

**0.4.38 发布了一个用户根本跑不起来的产物。** 报告写得很准确：

```
Error: failed to instantiate `C:\Users\hp\.moon\registry\cache\assets\riantr\moonbit_static_analysis\0.4.38\moonbit_static_analysis.wasm`

Caused by:
    LinkError: WebAssembly.Instance(): Import #5 "moonbitlang/async" "thread_pool/make_write_console_job": function import requires a callable
```

分析器一行都没跑。模块连**实例化**都过不去。

**为什么。** 发布出去的 wasm 不是自包含的：它从 `moonbitlang/async` 导入符号，实例化时
**宿主**必须把这些符号全都提供出来。`moonx` 提供的是**用户**工具链自带的那个 async——不是
这个包自己 `moon.mod` 里钉住的那个版本。0.4.38 那一轮把 `moonbitlang/async` 从 0.22.5 升到了
0.22.6，而 0.22.6 比 0.22.5 多声明了三个必须由宿主提供的 extern：

| 符号 | 谁把它声明成宿主 extern |
|---|---|
| `thread_pool/make_write_console_job` | async 0.22.6 及以后 |
| `thread_pool/make_read_console_job` | async 0.22.6 及以后 |
| `thread_pool/get_read_console_result` | async 0.22.6 及以后 |

0.22.4 和 0.22.5 三个都没声明，而且产物需要的另外 90 个它们都声明了。于是这个产物的宿主要求
从*自带 async ≤ 0.22.5 的工具链*变成了*自带 async ≥ 0.22.6 的工具链*——而造成这件事的，是一次
没有任何测试能看见的例行依赖升级。

**是量出来的，不是猜出来的。** 两个已发布产物的导入面，直接从 wasm 二进制里读出来：

| 产物 | 导入总数 | 来自 `moonbitlang/async` | 那三个 console 符号 |
|---|---|---|---|
| 0.4.37（async 0.22.5） | 104 | 90 | 没有 |
| 0.4.38（async 0.22.6） | 107 | 93 | 有 |

**修法。** `moonbitlang/async` 回到 **0.22.5**——自带 async 0.22.4 或 0.22.5 的工具链能满足的
最新 async——重建之后产物的导入面和 0.4.37 的**完全一样**：104 个导入、90 个来自 async、
不多一个也不少一个。它能在 0.4.37 能链接的那些工具链上链接起来。

**而且现在有门禁看得见它了。** 产物的宿主要求是它**字节**的属性，而这个仓库里的每一道门禁都是
**从源码**跑分析器的——发布出去的字节从来没跟宿主链接过，这正是没人看见的原因。所以：

- `_verify/host_requirements.txt`——**清单**：产物允许要的 90 个符号，以及 `min-host-async`
  这条下限（0.22.5）。
- `_verify/check_host_requirements.ps1`——**门禁**：它直接读 wasm 的 import 段（脚本里自带一个
  小 wasm 读取器，不依赖额外工具链），**双向**比较产物的 `moonbitlang/async` 导入和这份清单，
  检查 `moon.mod` 里的钉版和清单里的下限是不是同一个事实，还检查被钉住的那个依赖真的把清单上
  每个符号都声明成了宿主 extern。一次把宿主要求变宽的依赖升级，现在会让这道门变红，而不是悄悄
  把用户甩掉。
- 同一份检查也在 `_verify/selfscan_published.ps1` 里对**发布出去的产物**跑一遍——本地构建和
  发布的字节是两个文件，而只有后者是用户真正下载到的那个。

这道门有三种方式被证明会红：它自己的自测（一份没允许产物所需要的符号的清单，和一份列了产物
并不需要的符号的清单），以及——真正的那个——拿真的 0.4.38 产物去跑，它会红，并且把三个肇事的
符号一个一个点出来。

**用户该怎么做。** 在 0.4.38 上：改用 **0.4.37**，或者升级 MoonBit 工具链。在 0.4.39 上：什么都不
用做——除非你的工具链自带的 async 比 0.22.4 还老。

## 0.4.38 —— 分析器站不住脚的发现被降级为 notice，而且**没有被藏起来**

**置信度这一根轴曾经只是一列。** 0.4.37 给每条发现一个置信度——`high`、`low` 或
`undecided`——渲染在方括号里，JSON 记录里也有。但没有任何东西拿它做决定：`actionable`
的计数和这根轴从来不存在时一模一样。那份移植计划里还开着的那一条，正是 bandit 用两个轴
过滤时实现的那一条——一条问题同时带着严重度和置信度，过滤要**两个都**过阈值。这一版就是
那个过滤。

**规则就一行。** 分析器站不住脚的发现就是 notice：

    Report::is_notice()  =  is_declared_scope_limit()  ||  confidence() == Low

而这两个问题是**按机制**分开的，不是按置信度：范围限制是家族**加上**那个标记，低置信度
家族单看家族。`confidence()` 问的是范围限制那个问题，从不问 `is_notice`——一对互相递归的
判定，是一对可能一起错、而没有任何东西会发现的判定。

**这是降级，不是藏起来。** 发现保留它的家族、稳定 id、置信度，还有读者屏幕上属于它自己的
那一行。变的是**标签**（`notice:`）和**桶**（计入 `notices`，而不是 `actionable`）。

| | 之前 | 之后 |
|---|---|---|
| 一条低置信度的发现 | `error:`，且算 actionable | `notice:`，且算 notice |
| 分析器站得住脚的发现 | `error:` / `warning:` | 不变 |
| 一条声明过的范围限制 | `notice:` | 不变 |

**第一版实现把发现藏了起来，三道 settle 变红。** 决定哪些 notice 占一行的那个划分当时用
`!r.is_notice()`，于是被降级的那条被和范围限制一起汇总掉了——而 0505 和 0507 两道 settle
里「分析器会报出一个未定义的名字」那些行红了。那些行是这个家自己留下的「分析器说什么」的
记录，而一次改变了它所说内容的降级不是降级。现在那个划分问的是范围限制那个问题：范围限制
是**形状**，按形状汇总；低置信度的发现是**具体的**——一个名字，在某一行——所以逐行打印。

在七个固定语料上实测，逐函数视图：

    actionable    50 -> 29
    demoted        0 -> 21   (moonbit_core 19, proton 2)

而 `moonbit_core` 的逐文件视图：

    actionable    28 -> 10
    notices    10096 -> 10114   (+18)
    printed     1144 -> 1162    (+18——被降级的那些，它们是打印的)
    aggregated  8952 -> 8952    (不变——被降级的发现永远不会被汇总)

逐函数普查现在把降级的那一组单列一张表、单列一个总数，就放在 actionable 那一张旁边：一组
离开普查的发现，就是一组可能悄悄消失的发现。这 21 条全都带着 `low` 置信度，而且全都落在
一个有名有姓的家族里——正是假阳性追踪早就认识的四个（A、B、F 和 L）。

**检查它的门禁先红了，然后被修好。** 语料那一级把「渲染出来的 `ParseError` 行数」和
`NOTICES` 表的 `printed` 对账，而这个等式**就是**「这个家族没有真缺陷」的证明——这个家族
的真缺陷会渲染成 `error:`，而同一个匹配器也会数到它。降级按构造打破了这个等式：被降级的
发现渲染成 `notice:`、带着自己的家族，于是两个数变成了两个不同的集合，那一级在
`moonbit_core` 上红了：`rendered 1144 ParseError lines, the table says 1162 were printed`。
现在数的是**渲染出来的 notice 行**——范围限制和被降级的发现加在一起，这正是 `printed` 现在的
意思——而 `ParseError` 家族在对账旁边保留**它自己**的检查：这个家族的真缺陷渲染成 `error:`，
这一类的计数必须是零。期望值是零的门禁需要对照，因为「一个什么都数不到的计数器」也产出零：
新增的一级拿**一个真的**坏掉的接口文件跑同一个计数器，并要求它看见那条缺陷。

**这次发布运行本身，就倒在一道根本没跑起来的门禁上。** 0470 号门禁在它的**基线**那里中断，
报的是「测试套件编译不过」，而它的 transcript 显示 `moon test` 什么都没打印——没有汇总行、
没有编译诊断，两条流上都没有输出。这正是一次**没有发生的运行**的样子，而套件本身是好的：
同一次运行里其他每道门禁都是 1330/1330，0470 单独跑在同一棵树上也是 5 个变异全被杀。harness
对**变异运行**早就有这条规则——没有汇总行也没有编译诊断就是一次失败的测量，重试一次，重试
再没有就仍然判失败——而**基线**在同一个文件里往前一步，却没有。现在它有了：基线在同样的条件
下重试一次，编译诊断仍然是关于这棵树的判、且不重试，而重试永远造不出一次通过。

**两个视图数到的不是同一批名字，而两个数字都在发布的地方写清楚了。** 普查数到 21 条被降级
的发现，模块视图数到 18 条，而这个差别不是四舍五入：在 `moonbit_core` 里逐函数视图报 19 条、
模块视图报 18 条，其中只有 **15** 条是同一个位置。它们是两次分析——这个视图把每个函数都
当成入口，模块视图拿的是整个模块——这和普查早就发布着的 29 对 10 是同一回事。

**阳性对照也跟着动了。** 对照会往每个带 actionable 发现的文件里（副本上）追加一个故意的
类型错误，并要求错误原样回来：**16 / 16**，而不是 20 / 20——降级把四个文件挪出了 actionable
那一份。

**依赖也动了。** `moonbitlang/async` 0.22.5 → 0.22.6，是 registry 上的最新版本。上面每一个
语料数字都是在新依赖下量的，而它们一个都没动。

| | 文件 | 解析 | actionable | notices | unchecked |
|---|---:|---:|---:|---:|---:|
| 0.4.36 | 1029 | 984 | 28 | 10096 | — |
| 0.4.37 | 1029 | **984** | **28** | **10096** | **7867** |
| 0.4.38 | 1029 | **984** | **10** | **10114** | **7867** |

测试 js 1204 / wasm 1330 / wasm-gc 1204。门禁：**87** 道编号变异门、504 个存活变异，
每一次还原都按字节一致。

## 0.4.37 —— 一条发现现在会说清**检查了多少**，而没被检查的调用也被数了出来

**从 `bandit` 移植了三件事，而它们的移植计划在上一版就被写下来并实测过了**
（0.4.35 的「移植计划」一节，NARRATIVE.md §0505）。那份计划点了三件事，并且留下一个
没答的问题：*分析器拿一个它没法检查的调用怎么办？* 这一版回答了它。

**置信度这一根轴。** 严重度说的是一条发现**如果是真的**有多糟；置信度说的是分析器有多
确定它是真的——两者互相独立。三个值，对应透镜可能处的三种境地：

| 置信度 | 透镜…… | 家族 |
|---|---|---|
| `high` | 手边就有声明、签名或类型 | 其余全部 |
| `low` | 只在**名字**上推理 | `UndefinedName` |
| `undecided` | 根本没法判断 | 一条声明出来的范围限制 |

它渲染在原本放透镜标签的那个方括号里，JSON 记录里也在 `severity` 旁边：

```
12:3 - error: no visible binding for 'cmd' (UndefinedName) [structural, MSA-002, low]
```

**稳定的家族 id。** 家族的公开*名字*是第二套要手工维护的词汇——原先十一个名字里有五个不是
标签去掉 `F`——所以一个把 `"family": "ArgTypeMismatch"` 写进消费方的用户，在名字被改的
时候**收不到任何提醒**。而 **id** 只分配一次、**永不重编号**：`MSA-001` … `MSA-012`。
这些 id 是**手工**分配的，并且 `_verify/check_family_roster.ps1` 会检查这张表：每个家族
一个 id、没有 id 被用两次、id 是从 `MSA-001` 起连着的一段，反向表与正向表严格互逆。

**profile。** `--families <ids>` 与 `--exclude-families <ids>` 按 id 选家族，而且这个
profile 在扫描开始前就被**检查过**：这个版本不认识的 id 只是一条 `WARNING`，扫描照跑
（后来版本才加的家族不该让老分析器的 profile 用不了），而一个既被包含又被排除的 id 是
`ERROR`，扫描根本不跑。

**`nosec`。** `// nosec` 压掉那一行上的全部发现；`// nosec MSA-007` 只压掉那一行上的
那一个家族。它**默认关闭**——一个会因为被分析源码里一句注释就不再报某条发现的工具，它
的输出就得先读一遍源码才敢信。一条**什么都没压掉**的 `// nosec` 会被当成一条自己的发现
报出来（`StaleNosec`，`MSA-012`），因为过期的抑制是源码里的事实。

**而那些没被检查的调用，现在被数了出来。** 类型透镜只有在读到了被调用方的签名时才检查
实参个数和类型：`.mbti` 给的是名字，从来不给参数表，方法的签名根本不在源码里，而 `..`
链式调用就是换了写法的方法调用。在此之前工具对这三种情况一声不吭，于是「我没法检查这个」
和「这里没什么可报」是同一份输出——一个既没有发现、又有四百次没检查的调用的文件，打印
出来和一个干净文件一模一样。这个数出现在文件自己的判定行（`unchecked=N`）和 `SUMMARY`
上，并且**故意不参与**那个和式。

在七个固定语料上实测：

| | 文件 | 解析 | actionable | notices | unchecked |
|---|---:|---:|---:|---:|---:|
| 0.4.36 | 1029 | 984 | 28 | 10096 | — |
| 0.4.37 | 1029 | **984** | **28** | **10096** | **7867** |

**别的什么都没动，而这正是重点。** 七个语料上的 `actionable`、`notices`、`unreliable`、
`withheld`、`total` 全部不变。这三件移植改的是分析器**怎么说**一条发现，不是它**报哪些**
发现；一件会动到发现数量的移植，那是改分析本身，理由和门禁都该是另一套。

确实变了的两个数字，是两个不同的量，差别恰好就该是这么大。0505 那份计划量的是**16,250**
次「只按名字知道签名」的包级调用。分析器自己的计数更大，因为它把**方法调用**和
**`..` 链式调用**也算上了——另外两种它同样没读过签名的调用。0505 那个数仍然是真的；
它一直就只是在说一种调用。

测试 js 1196 / wasm 1316 / wasm-gc 1196。门禁：**86** 道编号变异门、495 个存活变异，
每一次还原都按字节一致。

## 0.4.36 — 一条 notice 只有在可能藏住一条发现时才值得占一行，而这是由它的**位置**决定的

**这个抱怨是关于体积的，而它是对的。** 在固定的核心语料（`moonbitlang/core`
0.1.20260920+7d59c7ec9，1029 个文件）上实测，只改这一件事，别的都不动，用默认的每文件
打印上限：

| | 输出行数 | 渲染出来的 notice | 发现 |
|---|---:|---:|---:|
| 之前 | 9128 | 7971 | 28 |
| 之后 | 2279 | 1133 | 28 |

这里的输出行数是**有内容**的行数。渲染器在每条发现后面会空一行，所以 `wc -l`
数同一份输出会得到 17,128 和 3,441；而把每文件上限撤掉——10096 条 notice 每条
各占一行——则是 11,223。

那 28 条发现是**同样的** 28 条。洪水是为了说 28 件事而印了 7971 行；语料里的 10096 条 notice 中有
66.5%——6148 条 `test declaration` 和 566 条 `block starts with 'test'`——说的是这个项目自己的
测试套件。

**NOTICE 的总数没有动。** SUMMARY 仍然写着 `notices=10096`；七个语料基线逐字节相同；
`actionable=28` 不变。动的是有多少条 notice 值得占读者屏幕上一行。

**哪一条 notice 值得占一行，由它的位置决定，而不是由它的措辞决定。** 只有当一条 notice
所在的区域落在某个函数体的范围内——也就是它可能藏住一条发现——它才会被逐行打印；而这正是
分析器本来就在用的几何：它靠这个判断哪些区域在某个函数的洞列表里。最锋利的对照是**同一条
消息在两个位置**：

```
fn g() -> Int { let d = if true { 1 } else { 2 } d }   -- 在函数体内部
let d = if true { 1 } else { 2 }                        -- 在模块顶层
```

两条渲染出来都是 "if expression is outside the analyzed subset"，而只有第一条能藏住发现。
所以归类用的是**分析器自己的范围**，从 walk 一路带到渲染器；而区域的归属判定比较的是
**整个 span**：同一行上的两处排除是两个不同的区域。

**代替它的那两个代理在两个方向上都是错的。** 有两个脚本靠自己的一份消息形状清单来划分；
在核心语料上它们把 1023 条 notice 划进表达式级、9073 条划进另一类，而几何给出的是
1144 和 8952。几何多算了 132 条代理清单里根本没提的表达式级 notice（`loop expression`、
`lexmatch expression`、``descending range direction`、`inclusive range end`），也少算了
11 条代理叫作表达式级、几何叫作藏不住东西的顶层表达式。两个脚本现在都**读**分析器的划分，
不再自己猜。

**现在的输出长什么样。** 藏不住东西的 notice 按形状汇总，在整棵树的末尾只印一次：

```
NOTICES	TOTAL	notices=10096	printed=1144	aggregated=8952	1144 of them can hide a finding; the other 8952 cannot, and are counted by shape below
NOTICES	count=6148	test declaration is outside the analyzed subset; its body was not analyzed
```

`--show-notices` 把完整的逐行列表恢复回来——和之前的渲染一模一样——而且它不改动任何计数。

**三个数互相核对得上。** `notices` == `printed` + `aggregated` == SUMMARY 的 `notices`，
每一行加起来等于 `aggregated`，而渲染出来的 `ParseError` 行数正好等于 `printed`——最后
这一条就是「树里没有任何 `ParseError` 家族的真缺陷」的证明，因为那样的缺陷会渲染成
`error:`，把这个等式打破。

**`test` 块的排除还在。** 语料里 66.5% 的 notice 说的是测试代码，这一版**汇总**它们而不是
逐条打印；它并不去分析它们。

在 `moonbitlang/core` 上实测（1029 个文件，同一台机器）：

| | files | parsed | actionable | notices |
|---|---|---|---|---|
| 0.4.35 | 1029 | 984 | 28 | 10096 |
| 0.4.36 | 1029 | **984** | **28** | **10096** |

语料上一个数字都没动，而这正是重点：这一版改的是工具**打印**什么，不是工具**找到**什么。

自身源码自扫 183/183，actionable=0。测试 1184 js / 1286 wasm / 1184 wasm-gc。变异门现在
是 85 个：480 个存活变异，440 个预期被杀，其中 363 个点名了必须变红的是哪个测试。

这一版发现的一个解析器缺口已经量过，但**不在这一版里修**——`moon fmt` 会把过长的 `for`
头拆成多行，而前端读不了那个形状，`moon check` 却接受它——写在 `_verify/NARRATIVE.md`
的第 0506 节里。

## 0.4.35 — 返回标注可以写 `raise?`，而推导式的条件曾经被直接扔掉

两个增量，第二个之所以存在，是因为第一个让更多代码变得可读。

**0503 — `-> Int raise?` 是合法的 MoonBit，而解析器拒绝它。** 解析器在**函数类型**的位置读了
raise 子句上的 `?` 标记，却在**返回**位置没读，于是 `fn f() -> Int raise? { 1 }` —— 一个
工具链接受的程序 —— 在 `?` 上死了。覆盖面是 31 个文件里的 162 个返回位置，**全部**在
`moonbitlang/core` 0.1.20260920+7d59c7ec9，另外六个语料里零个，本分析器自己的源码里也零个。
三个真实的 core 文件 —— `array.mbt`、`option.mbt`、`result.mbt` —— 单独扫出来是
`PARSED 0/3 files understood (0.0%)`。

**这条规则是编译器的，而第一版 settle 弄错了。** 问题不是「分析器读不读 `?`」，而是「**哪个**
`?` 是合法的」，而答案比「任何 raise 子句之后」更窄：

| | |
|---|---|
| `-> Int raise?` | 接受 —— 裸 raise，标成可选 |
| `-> Int raise MyErr?` | 拒绝 4032 + 3002 —— 带类型的 raise 没有可选形式 |
| `-> Int noraise?` | 拒绝 —— 给「不会 raise」加可选标记没有意义 |
| `-> Int nocancel?` | 拒绝 |
| `-> Int! ?` | 拒绝 —— 短形式没有可选形式 |

**=> `?` 属于裸 `raise`，且只属于裸 `raise`。** 一个在任何子句之后都接受它的读者，会去读
工具链拒绝的程序。

**而函数类型位置上的 `?` 干两件事**，这正是这个增量的第一版草案弄坏了十四个既有测试的原因：
`(Int) -> Int raise?` 是可选 raise 标记，而 `((Int) -> Int)?` 是**括号组**上的可空标记 ——
后者前面根本没有子句。所以规则问的是**子句**，不是 `?`。

**0504 — 多出来的那点可读性，暴露了一个假阳性。** 多读了 27 个 core 文件之后，
`hashset/hashset.mbt:382` 报出了 `undefined variable 'key'`：

```
[ for entry in self.entries if entry is Some({ key, .. }) => key ]
```

编译器接受这一行 —— core 是能编译的已发布包 —— 所以这条发现是**假阳性**，而原因在**解析器**
里：`parse_comprehension` 读了推导式的 `if` 条件，然后**把它扔掉**了
（`ignore(self.parse_or())`），于是条件引入的 `is` 绑定从来没进过 AST，函数体里对它的读取
也就无处可解析。

**条件是真实的代码，编译器就是这么说的。** `_verify/settle_0504_comp_guard.ps1` 用工具链当
裁判，18 行 —— 16 行用 `moon check`，2 行用 `moon test`，因为 `moon check` 没法回答一个条件
**是否被求值**：

- 条件是**被编译的** —— 里面一个未定义的名字就是错误；
- 条件**会过滤** —— 它对每个元素求值一次（那两行运行时用例）；
- 它引入的 `is` 绑定在**函数体**里在作用域内，别的任何地方都不在；
- 条件可以读循环变量。

**=> 条件被带进 AST，而顺序就是作用域。** `EComp` 现在是
`EComp(vars, sources, cond, body)` —— 条件夹在被迭代对象和函数体之间，因为它在源码里
就在那个位置，也因为它要读循环变量，而它自己的绑定必须在读函数体时已经活着。三个透镜都按
「先 sources，再条件，最后函数体」的顺序走。

**而那半边一直还潜伏着的缺陷，也一起修掉了。** 条件的**读取**跟条件本身一起丢了，所以一个
**只**在条件里被读的名字会被报成从未使用。这就是 `ECast`/`EComp` 教训的第三种形态：
**没被遍历的那一半，就是会消失的那一半。**

**门禁在自己的两个洞上说了话。** `mutate_0504.ps1` 有 8 个变异，8 个全被杀，但其中两个在第一
轮跑完之后必须**重写** —— 因为第一轮说出的话和注释说的不是一回事：

1. 「条件干脆不解析」这个变异出来是 **COMPILE-ERR** 而不是被杀 —— 赋值一去掉，`cond` 就从来
   没被改过，而 MoonBit 直接拒绝那个多余的 `mut`。编译器自己就能抓住这个回归，这值得知道，
   但它让这个变异**什么都证明不了**（关于分析器），所以这个槽位换成了一个编译器抓不到的规则；
2. 「条件在外层环境里求值」这个变异杀红的是一个和它名字差一步的用例，因为同一行上的两个
   未定义名字会被**合并**成一条发现，于是条件自己那个 `nosuchfn` 不再是活下来的那条消息。
   钉住**机制**的那个用例是那之后写的，它钉的是循环变量的作用域，而不是症状。

在 `moonbitlang/core` 上的实测（1029 个文件，同一台机器）：

| | 文件 | 解析 | actionable |
|---|---|---|---|
| 0.4.34 | 1029 | 957 | 28 |
| 0.4.35 | 1029 | **984** | **28** |

actionable 仍然是 28 条，而这正是第二个增量的意义：0503 多出来的那点可读性暴露出来的假阳性
没有了，别的什么都没动。多读懂的那 27 个文件贡献的是 notice，不是发现。

自身源码自扫 181/181，actionable=0。测试 1176 js / 1262 wasm / 1176 wasm-gc。变异门现在是
84 道：464 个存活变异，其中 425 个预期被杀，348 个点名了必须变红的是哪个测试。

**有一个公开数字此前谁都没在检查，现在被钉住了。** README 公开了自身源码的文件数 ——
「Measured on this project's own source (178 files)」—— 而发版门禁把它量出来却没跟任何东西
比较，README 门禁则是拿**写在门禁自己里面**的字面量 `178` 去比 README。写在「检查 README
的门禁」里的字面量，是一个只可能跟自己一致的数字 —— 而这个数字动了两次：178 → 179（0503 的
测试文件），179 → 181（0504 的两个），一路没有任何东西提出异议。现在它是 `release.ps1` 里的
一个钉，而 README 门禁从那个钉推出它要写的字符串。
## 0.4.34 —— `match` 的 arm 就是普通代码，读了它们找出十三个假阳性

在这一版之前，`match` 的 arm 被 `skip_braces` 整块吞掉——那是一块前端**故意**不分析的
区域——而那块区域在包含它的函数框架上开了一个洞。0.4.31 已经确立：洞会把整个函数的
「未使用局部变量」「未使用参数」结论全部关掉，这正是七个固定语料里有六个测出**零**条
可执行发现的原因。

0.4.34 读 arm：模式里的名字被解析并绑定，guard 被遍历，`with` 约束被读取，arm 的函数体
被遍历。

**实测，而且不是标题暗示的那个数字。** 把抑制关掉、用最朴素的方式探，得到 1,098 条发现
——那是洞的代价。而 arm **真的**被读懂之后剩下来的是 14 条，而且「真的读懂」不是一行
改动：arm 会引入模式绑定，只读函数体而不引入它们，就会在正确代码上造出
`no visible binding for 'x'`。这 14 条里，**十三条**是假阳性，来自六个不同的机制，
恰好**一条**是真的。

**六个机制**，每一个都在一个语料点上量过，每一个都在 `moon check` 接受的代码上：

1. `as` 可以**另起一行**——后缀循环在换行处断了，`as` 于是被当成了一个名字。
   async `src/fs/watch.mbt:216,222,233`
2. 解构 `let` 的**初始值**被收集器丢掉了。core `rechar_set.mbt:202,214`
3. 同包类型的**方法**被不带限定地调用（`Vector::makei`）。core
   `immut/vector/invariants_wbtest.mbt:354,363,366`
4. 结构体字面量的**字段值**没有被收集。moui `views/text/text_input_apply.mbt:166`
5. 一个**赋值**在嵌套的局部 `fn` 里造出了遮蔽绑定。async `src/process/windows.mbt:105`
6. `with` 约束的**右侧**被当成了模式绑定。core `builtin/option.mbt:50`、
   `builtin/result.mbt:92`、`builtin/arrayview.mbt:282,329`、`builtin/help_render.mbt:320`

它们没有一条是 0.4.34 的缺陷：六条都是更早就有的洞，被「读 arm」**暴露**出来而已；其中
两条——换行上的 `as` 和解构初始值——在根本没有 `match` 的普通代码上就能碰到。

**唯一那条真发现。** moonbit_labeler 0.2.13 `app_moui/rasterizer.mbt:489`，
`local variable 'd_off' assigned but may not be used`——在 489 行算出来，从没被读。
这是本工具在 moonbit_labeler 上发布的第一条可执行发现，而在 `match` 的洞还在时它是看不见的。

**它买到了什么。** 七个固定语料上少了 1,832 条 match 通知（moui -768、labeler -93、
image -32、async -182、proton -332、contract -5、core -420）；13 个 `moonbit_core` 文件
从 FOUND 变成 CLEAN；5 条早就存在的假阳性被清掉——`invariants_wbtest.mbt` 里三个
`makei`，以及 `diff.mbt` 里的 `i1`/`i2` 遮蔽，后者是机制 5 的第二个独立实例。

**README 发布过四个数字，而它们都是陈旧的，现在被重新测量并钉住了。** 渲染出来的
`ParseError` 行数原本是 23,331，现在是 **19,215**。自己源码上的通知表原本是在每份文件
40 条的打印上限下数的，所以它数的是 1,584 条里的 1,499 条；现在数的是全集：1,318 条
`test` 声明、103 条 `if` 表达式、60 条 `struct` 声明、53 条 `derive` 声明、24 条 `enum`
声明、17 条匿名函数字面量、6 条 `const` 声明、2 条短 lambda、1 条 `try` 表达式——
其中 123 条是表达式级、1,461 条是声明级。而「抑制藏起来了多少」那一对，是在抑制被收窄成
按绑定之前测的：把区域抑制**关掉**，工具现在在七个固定语料和本项目自己的源码上产出
**537** 条 `UnusedLocal` 和 **1,094** 条 `UnusedParam`，而发布版只产出其中**一条**。

这四个数字现在都由发布门**实测**，并且钉在**一个**地方，README 门从那张表**推导**自己的
期望——这正是 0.4.33 带给语料数字的同一套纪律，用在了那些描述分析器自身保守程度的数字上。

**那些门。** `_verify/check_match_arms.ps1` 是新的发布阶段：17 个夹具加一个在真实扫描器上
跑的包目录——输出契约、**反向**方向、fallback 精确、六个机制、同包方法，以及每个夹具
确实被读到。它被证明会**红两次**：往分析器自己的源码里注入一个缺陷、重新构建、跑它——
arm 的函数体没被遍历 -> 12 条检查失败（反向方向也在里面）；`with` 约束没被识别 ->
2 条检查失败，点名 `m6_with_constraint`。两棵树都按字节还原（SHA256 校验过），每次还原
之后门都是绿的。

`_verify/mutate_0502.ps1` 是新的编号门：12 个变异，12/12 被杀，每个点名的测试都确认变红，
每次还原都字节一致，每个锚点都唯一。

`_verify/measure_suppression_off.ps1` 是新的阶段，它把区域抑制**关掉**（`Walker::holes_in`
里的一行）来量被藏起来的量——重新构建分析器、扫八棵树、还原源码，用 SHA256 证明还原。
它在发现源码**已经**被打过补丁时**拒绝启动**，所以一次被打断的运行不可能被当成干净的树。

**这一版打破的三道门，以及每道门的处理。** mutate_0432 和 mutate_0469 被重新锚到当前的
文本上，仍然能杀掉它们点名的测试。mutate_0492 的 M1 现在**存活**，而这一条不是重新锚：
一次 A/B——把旧的形状放回去，看什么会变红——证明它钉住的那个形状是唯一会把一个名字
放进绑定表**两次**的形状，而这一版把它去掉了。重新绑定这件事由 0502 门的 M11 和
`pipeline_0502b_test.mbt` 的两行钉住，M1 被**声明**为存活并附上这个论证，而不是被悄悄
丢掉。

**而且发布门抓到了它自己新加的阶段在读一个空的钉。** 上面那四个钉写在 `release.ps1` 的
底部、挨着别的钉表，而读它们的阶段在文件里更靠前——PowerShell 自上而下执行脚本，于是它们
每一个读到的都是空字符串。门第一次跑就栽在这上面，而且失败信息直接说出了原因：
`pinned :` 后面什么都没有，而紧挨着它的量出来的 `expression-level 123 / declaration-level
1461` 是完全正确的。钉被**搬**到了读它们的阶段上方，而不是抄一份；现在这六个钉里只要有
一个为空，这个文件就拒绝运行。

## 0.4.33 —— 逐句检查 README，以及六句不成立的话

这一版**不改变分析器的任何行为**。它的内容是一次更正：README 被逐句拿来对着当前的树
核对，其中六句话是不成立的。

### 那个「402 条发现的文件」是 1022 条

mermaid 那一节说，`moonbitlang/core` 上原始发现最多的文件是「一个 402 条发现的测试
文件，那 402 条全是 notice、零缺陷」。

2026-10-22 实测，在固定语料和当前 wasm 上、**两个视图都测**：原始发现最多的文件是
`builtin/int64_test.mbt`，**1022** 条发现——全是 notice，没有一条是缺陷。第二名是
`builtin/extends.mbt`，394 条。这句话的**形状**是对的，**数字**是错的。

### 「约 90 条内建告警」是一个谁也量不出来的数

覆盖范围那一节说 `moon check`「有真正的解析器和约 90 条内建告警，覆盖率恒为
100%」。工具链不发布诊断目录，所以这个目录的大小在这里根本量不出来，而这句话从
0.4.13 时代的 `LOOP.md` 起就一个字没改地被带着走。

现在换成**能量出来的**那个：同一棵语料、同一条命令，`moon check --target all` 在
`moonbitlang/core` 上报**一条**错误和两种共 251 条告警。这句话的**意思**没变——编译器
读整个语言，本工具读的是子集——而它现在靠的是一个可以重测的数。

### 发布门禁做的事比 README 说的多，也比它说的少

两处，都已更正。

README 列了 `_verify/release.ps1` 会跑什么，而那份清单漏掉了两个**已经存在**的阶段：
**这份 README 自己的链接、锚点、版本与计数**，以及**变异门名册**及其自测。名册这一项
重要：它是一份手工维护的清单，而一个在磁盘上存在、却不在清单里的变异门**永远不会跑**
——不会跑的变异门和跑绿了的变异门长得一模一样。README 里「79 个全在门列表里」这句话
当时是真的，但靠手工维持；现在它**被检查**了，双向检查，并且有一个自测会注入六种缺陷、
要求每一种都被抓到。

而「参与开发」那一节说每一道变异门都「要求一个具名测试变红」。在 426 个存活变异上实测：
389 个预期被杀，其中 **312** 个还点名了必须变红的是哪个测试。门禁一直要求「有测试变红」；
它在 389 个里给 312 个点了名。

### 形式验证没在跑，而且没人跑它

这一条不是措辞问题。

`moon prove src/core --why3-config .why3.conf` **是失败的**。README 写的是「**21/21 个
目标 VALID**（unsat）……每一个都用 cvc5 机器验证过」，而那个测量的日期是 2026-10-03。

**两处独立的断裂，日期不同：**

- **2026-10-09** —— 两处 `#proof_pure` 标注是**假的**：`path_tail` 和 `unqualified` 的
  函数体会构造 `StringBuilder`，证明器不认（错误 4207）。**一处**假标注就让整个文件
  停止证明，于是这个包一个目标都没产出。
- **2026-10-08** —— `src/core` 多了一个 `IfaceSymTab`，它的字段是 `Map[String, Bool]`。
  工具链的证明前导库**没有 `Map` 理论**，于是生成的 Why3 文件里出现 `map int bool`，
  `moon prove` 和 `why3` 都加载不了它。19 条引理从来没碰过 `IfaceSymTab`：被证明的是
  **整个包**，而包里有这个类型。

第一处在这里修掉：那两处标注被移除，剩下的六处**正是** skill 里记着的那六个——`pos`、
`span_at`、`zero_span`、`Lens::rank`、`Lens::lower`、`Family::severity`。

第二处**没有**修，因为它的修法会改本包的公开 API（`@core.IfaceSymTab` 是导出的），
那是版本线上的决定，不是一个补丁的事。README 现在就地写明了这一点，连原因和日期一起。

**没有发现这些的，是发布门禁从来没跑过 `moon prove`。** 一条没人跑的命令就是一句注释，
而这一条已经连着两个版本在失败了。`_verify/check_prove_contracts.ps1` 现在在门禁里跑它，
并且对「假标注」这一类**失败**——这一类在这里是能修的——同时把 `map` 那个已知限制**报出来**
而不是藏起来。它已经被证明会变红：加回一处假标注，会得到 25 个 4207 错误和一次失败的门禁。

### README 的版本现在是读出来的，不是钉死的——而匹配器得用包自己的名字来搭

`_verify/check_readme_links.ps1` 过去要求两个 README **字面**写 `0.4.32`。于是一次发版
既得改门禁又得改 README，而漏改一处，要么用错的原因卡住发版，要么放一个写着旧版本的
README 过去。现在版本从 `moon.mod`（注册表读的那份文件）里读，失败信息会直接说 README
本该写哪个版本。变异门数量早先已经按同样的理由改成从磁盘算了。

把版本从 `moon.mod` 里读出来解决的是**会不会烂**；它没有解决**怎么匹配**，而第一个用到
它的发版就撞上了：

    FAIL: README.md must name 0.4.33 and nothing older; also found: 0.4.32

这里的 `0.4.32` 是那句 `> (This note said **116 → 2** until 0.4.32, ...)`——一句关于
「某次更正发生在 0.4.32」的**真话**，而且此后每个版本里它都还是真的。**规则**是对的
（读者被告知去装的版本必须是当前版本），**匹配器**是错的：它匹配的是「任何长得像版本号
的东西」，而不是「指向**这个包**的引用」。所以匹配器现在用包自己的名字来搭：

    moonbit_static_analysis@<v>       读者会装的东西
    moonbit_static_analysis_<v>_      读者会拿到的东西

**散文里的**版本号不是引用；**紧跟在包名后面**的版本号才是。`CHANGELOG.md` 被有意排除：
每一节的发布说明都写着自己的版本号，那些按构造就是历史。

### 而且这道检查只看三份会发出去的文档里的两份

`SKILL.md` 是跟着包一起发到注册表的（实测：已发布的 0.4.32 那棵树顶层就有它），而它让
读者运行：

    moonx riantr/moonbit_static_analysis@0.4.32 riantr/moonbit_doubleML

这一行**每个版本都在维护**——0.4.30、0.4.31、0.4.32——而版本门只看两个 README。于是一次
发版可以同步完 README、把 `SKILL.md` 留在原地，然后带着一份绿门禁发布一条指向上一版的
安装指令。现在门禁读全部三份，并且逐份检查各自的安装行：两个 README 用 `moon add`，
`SKILL.md` 用 `moonx`。

两条新规则都已被证明会变红：

| 注入的缺陷 | 门禁说了什么 |
|---|---|
| 把 `SKILL.md` 的安装行改成 `0.4.31` | `FAIL: SKILL.md tells the reader to install 0.4.31; the released version is 0.4.33.` |
| 把 `README.md` 的产物名改成 `0.4.31` | `FAIL: README.md must name 0.4.33 wherever it names THIS package; also found: 0.4.31` |

而那句历史上的 `until 0.4.32` 仍然是 FOUND，两条都没被它绊倒。

### 改完之后的数字

```
    moonbitlang/core 上原始发现最多的文件      builtin/int64_test.mbt，1022 条
    同一棵树上 moon check --target all          1 条错误，251 条告警，2 种
    存活变异                                    426
    ...其中预期被杀                             389
    ...其中点名了必须变红的测试                   312
    src/core 里的 #proof_pure 契约               6
    ...其中是假的                               0   （原本 2）
    自身源码自扫                                170 个文件，actionable 0
    语料固定基线                                7 个全部 MATCH
    逐函数普查                                  TOTAL 58 MATCH
    普查对照                                    24 / 24
    发布门禁                                    96 个阶段，全绿
```

## 0.4.32 —— 数的是 UTF-16 码元的转义、词法匹配，以及那份只量了六个语料的普查

### 字符字面量的转义：整套语法，以及它底下的**崩溃**

这条积压的常备说明写的是「转义读取器最多取四个十六进制位，那正好是 BMP」。
**观察是对的，解释是错的**，而错的解释才是危险的那一半：照那条说明去修，会把位数
限住，然后**照样拒绝 `'\u{10000}'`**。

机制是实测的：`"\u{1F600}".to_string().length()` 是 **2**——UTF-16 码元；而
`.to_array().length()` 是 **1**——码点。读取器把能吃到的十六进制位都吃掉，然后检查
`s.length() != 1`，那是一个 **UTF-16 计数**。问题从来不是转义形式，而是那个**计数**。

于是读取器现在实现工具链的整套转义语法（29 种形式，每一种都对着 `moon check` 定过），
并且数的是**字符**。`\xNN` 恰好两位；`\u{...}` 一到六位，值不超过 U+10FFFF 且不含
代理区；`\uXXXX` 恰好四位；字节形式根本不吃 `\u`。超限的位被吃掉但不累加，第七位
判为字面量不合法。

**这一切底下藏着一个崩溃。** `'\u{110000}'` 走到 `v.unsafe_to_char()`，抛出
`RuntimeError: unreachable`，把**整个扫描**带崩——后面每个文件都没被读到，而扫描照样
打出了 SUMMARY 行，于是这个故障看起来像一个「发现恰好少一点的语料」。那个边界不是转义
规则的细化；它是「会回答的扫描器」和「会停下来的扫描器」的区别。

**字符计数同时放开了直接写出来的星平面字面量。** 不只是转义形式：
`builtin/string_methods.mbt:117` 是 `c == '😂'`，正是它把那个文件卡在 117 行。只修
转义形式的读取器会把半个语料留在身后。

### `lexmatch` 是一个构造，不是一个名字

这条积压的具名项是带标签的捕获 `(re"..." as t, after=next)`。范围是**重新推**出来的：
`after=` 在语料里出现在 22 个文件的 283 行上，逐条分类后，真正的构造是**一个语料里
五个文件上的 84 处**，其余六个语料里**一处也没有**。常备说明写的是「3 个 PINNED core
文件里的 18 处」；18 正好只是那两个 `diff` 测试文件，所以处数和文件数都错了。

`lexmatch` 之前被读成普通名字，于是解析器在四个语料点上报 `undefined name 'lexmatch'`——
而那些代码是 `moon check` 能过的。现在它被读成构造：主语、可选的 `with longest`，以及
被整体跳过的各个分支。这个表达式被记为「在分析子集之外」，并复用 `@ast.EMatch`——形状
完全相同，另开一个变体只会让 walk/types/infer/interp 和 `.mbti` 白白震荡一场，却不带来
任何新信息。

### 插值里的 lambda 形参是**绑定**，不是读取

修好 `lexmatch` 之后，`builtin/autoloc.mbt` 越过了它原来的解析边界，然后这个文件在
83:5 报 `no visible binding for 'sb'`——`sb` 是插值里一个 lambda 的形参：

```
$|{"filename":\{sb => self.filename.escape_to(sb)},...}
```

收集器在第一个非标识符字符处就把名字冲掉了，而在 `sb => sb` 里，那个字符是**空格**。
两种写法都处理了（`sb=>sb` 和 `sb => sb`）。而且「挖出来的」不是回归：这个发现原先被
解析边界挡在后面，所以它在这次增量里被**修掉**，而不是被钉成 `actionable=1`。

### 那份普查只量了六个语料，第七个从来没被数过

上面的 `--per-function` 方框被重写了，理由值得一读：量出 0.4.31 那个「116 → 2」的
普查只覆盖**六个**语料，`moonbit_core` 不在其中。在七个上量，0.4.31 的数字是 **66**。
两个 wasm 打同一份语料，方向不含糊：

```
                        0496 之前（be21ecd）      0496
    files                     1029                 1029      不变
    parsed                     935                  957      +22
    actionable                  64                   56       -8
```

两个发现集合正好差 **8** 条，**没有一条新的**：八条全是 `undefined variable 'lexmatch'`。
所以这次增量把普查**变好了**；那个往上走的数字，是一个从来没被数过的数字。

这 58 条被一份**进版本库**的普查脚本归成**十二类**，遇到归不了类的发现就失败，发版
门禁**逐语料钉住**数字。它们没有一条是被分析代码的缺陷，而这个结论是量出来的：`
moon check --target all` 在 `moonbitlang/core` 上恰好报一条错误，在
`json/README.mbt.md`，而它不在带发现的二十四个文件之列。没有诊断的文件和没人打开过
的文件长得一模一样，所以还有一道**正向对照**：往这些文件里（**副本上**）各追加一个
故意的类型错误，并要求错误原样回来——**24 / 24**。若换成 `--target js`，其中五个什么
都不会报，因为 MoonBit 的逐文件 `targets` 选项在那个 target 上根本不编译它们：没有
target 编译的文件，是检查器从没见过面的文件。

### 之后的数字

```
    测试套件                     1163 通过，0 失败   （0496 之前 1136；+27）
    逐函数普查                   七个语料 66 -> 58   （core 64 -> 56；proton 2 -> 2）
    这 58 条                     12 个家族，没有一条是被分析代码的缺陷
    带它们的文件                 24 个，moon check 读到了 24 / 24
    这份普查                     进版本库、被门禁钉住、归不了类就失败
    模块视图语料 pin             moonbit_core 33（0496 之前 37）；其余六个逐字节一致
    变异门                       发版门禁里 79 个（0496 之前 78）
    0496 自己的门                14 个变异：13 个 KILLED，1 个带证明的声明存活
    重新锚定的门                 6 个（0459 M4、0480 M1-M3、0488 M5-M6）
```

## 0.4.31 —— 那 116 条发现是透镜的一份清单，而清单被清空了

0.4.30 时 `--per-function` 视图在 `moui` 0.1.12 上报 7 条 `actionable`，分属「四类更小的」
透镜缺陷。那是把顺序搞反了：数字小只是因为这个视图只被指向了一个语料，而**类**才是真正的
内容。这一版在固定语料上量这个视图——**116 条 actionable**——把它们归成**八类**，一类一类
修掉，每类都配一条必须仍然报出来的对照。

| 家族 | 条数 | 透镜当时主张什么 | 怎么修的 |
|---|---:|---|---|
| A | 61 | 解构出来的名字绑定的是**整个元组** | 绑的是元素——类型透镜本来就答「Unknown」 |
| B | 25 | 带值的 `continue`/`break` 是 unreachable code | 带走的值是终结符**自己的载荷**，不是旁边的语句 |
| C | 8 | 循环体总是终止的循环之后的语句是死代码 | 「循环可能被 break 出去」是与合并流**分开**的信号 |
| D | 10 | `extern`/FFI 调用、可省形参被当成位置槽、同一个名字声明了**两次**、以及没有函数体的函数 | **一个名字下的四个缺陷**，每一个都先单独隔离出来 |
| E | 5 | trait 的方法不是值 | `.mbti` 读取器把 trait 的方法收成 `Trait::method` |
| F | 4 | 整数 `/` 被定型成 `float` | `div_type`，以及它旁边的常量折叠 |
| G | 2 | 被 `is` 模式的 `as` 绑定绑出来的名字没有绑上 | `as` 绑定在**任何**深度都被收上来 |
| H | 1 | 推导式没有绑定自己的模式 | 名字绑在环境的副本里 |

**那 116 条没有一条是被分析代码的缺陷。** 每一条都在 `moon check` 能过的文件里，都在已发布、
已上架的包里。它们是透镜的**一份清单**，现在清单空了，只剩两条「已记录的边界」——跨包的
`#doc(hidden)` 函数没法从依赖的**源码**索引，只能从它的 `.mbti`；要回答它们就得把这个分析器
长成源码索引器，那是另一个项目。

### 模块视图没动——只有一个语料动了，而且是往下动

七个固定语料里六个的模块视图数字逐字节相同，这正是两个视图分开的意义。第七个
`moonbit_core` 从 **48 条 actionable 变成 37 条**，而**怎么**动的才是值得读的部分：建了
两个 wasm，一个是 0495 之前的树，一个是这棵，**同一个**语料两边各扫一遍。

```
    actionable  48 -> 37
    notices     9988 -> 9988   不变
    unreliable  2956 -> 2956   不变
    withheld    552 -> 552     不变
    parsed      935 -> 935     不变
    files       1029 -> 1029   不变
```

**发现集合**恰好差 11 条，**新的一条没有**：十条 `undefined name 'rl'` / `'lr'`
（`is` 模式 `(Node(..) as rl)`）和一条 `no visible binding for 'Arbitrary::arbitrary'`
（把 trait 的方法当值读）。每个文件的 `defects=` 头（不截断）显示，有发现的 680 个文件里
**只有 2 个**变了，别的文件计数完全一样。光看计数分不出「修好 11 条」和「修好 11 条、
又换来 11 条新的」；集合分得出，而它说的是前者。

### 这次改动自己弄坏的五个变异门

完整发布门第一次跑是红的，挂在五个门上，原因就是这次改动本身：0495 把这几个门锚定的文本
挪了位置。锚点挪位不是拼写错误要改掉——它要重新锚到**当前**文本、**同一个**变异，然后
**量**它是否还能杀掉。这五个门的 31 个锚点现在全部存在且唯一。

**然后其中三个失败的原因跟锚点毫无关系**，这部分才值得读，因为一次以绿灯收尾的重新锚定，
可能藏住一个已经不再守任何东西的门。

- **0425 的 M7 存活了，而这次存活是对的。** 0495 把 `falls` 标志换成了流的列表加一个合并，
  缺 `else` 的那一支从**赋值**一个「落到下面」变成了**贡献**一个——于是只要有哪个分支落到
  下面，它就变得多余，而 0.4.25 的样例恰好就坐在那个位置。这一行仍然管着一件没有样例管过
  的事：没有 `else`、而**每个**分支都终止的链。在 0495 之前的树上量过：那个变异恰好杀掉
  一条测试；在这棵树上它一条都杀不掉。所以修法是补一条**样例**，而不是重新锚一次锚——M7
  又被杀掉了。
- **0472 的 M5 写不出来了。** `continue` 带走的值现在是终结符自己的载荷 `Array[Expr]`，
  而赋值是 `Stmt` 种类——这个变异根本写不出来，编译器会这么说。它守着的那个主张现在由
  **类型**保证，比一行代码更强；于是它带着这个理由退役，而**另加**一个变异，在主张如今
  真正待着的地方守住它的另一半（「值被读到了」）。
- **0493 的 M3 点名的测试不再是该点的那个。** 别处的一次修复——可省形参不是位置槽——让它
  点名的行不再能区分两种机制。现在由仍然能区分的那行（callee 没有的那个 label）来点名，
  并且把理由写下来，而不是假设。

### 为了数而加的旗标

`--findings-shown-per-file N`——每个文件的打印上限本来是 40，而要数 116 条得全看见。默认值
不变。

### 之后的数字

```
    逐函数 actionable 发现            116 -> 2   （那 2 条是已记录的 #doc(hidden) 边界）
                                       ^^ 0.4.32 就地更正——那次普查只覆盖了**六个**语料
    模块视图语料 pin                   六个语料不变；moonbit_core 48 -> 37
    moon test --deny-warn              wasm 1136/1136；js 与 wasm-gc 1056/1056
    moon check --deny-warn             exit 0
    自身源码自扫                       167/167 解析，actionable=0
    变异门                             78 个门全绿；一个变异带着理由退役
```

**那个「2」是六个语料的普查，第七个从来没被数过。** 量出它的普查覆盖 `moui`、
`moonbit_labeler`、`moonbit_image`、`async`、`proton`、`proton_contract`——`moonbit_core`
不在其中，而 `moonbit_core` 的发现数比其余六个加起来还多。在**七个**语料上量，0.4.31
那个数字是 **66**，不是 2。这一版宣称清空的那份清单，并没有清空。

修法不是把句子写得更好听，而是把普查变成：**进版本库**（第七个不会再被漏掉）、
**写明**它覆盖哪些语料、遇到**归不了类**的发现就**失败**，并且被发版门禁**钉住**。
0.4.32 补上了两样：`_verify/census_perfunction.ps1` 与
`_verify/control_perfunction_census.ps1`。

## 0.4.30 —— 最后 89 条发现归零，而行为透镜发现自己一直是错的

0.4.29 时六个语料一共背着 **89 条 actionable**：async 19 条、proton 68 条、
proton_contract 2 条，另外三个语料是 0。这一版把它们变成**六个全是 0**——而且是在
**同样的 1081 个 `.mbt` 文件**上（moui 551、labeler 35、image 17、async 362、proton
114、contract 2，这一版重新数过，没变）。自检读的文件从 68 个变成 **161** 个，
`actionable` 始终是 0，测试从 **514 个 wasm 变成 1067 个**。

### 前端又读懂了十九种语法形式

这一轮的工作大部分是前端做的。读不懂的形式会留下一个**可证不完整**的模块帧，
于是里面每个名字看起来都没绑定、每个运算符看起来都不匹配——这正是 0.4.7 那条
「干净的 0 有可能是靠不看换来的」教训的反面。每种形式在写之前都对着工具链定案；
凡是编译器对规则有话说的，历史里都在对应的 increment 之前留了一个 `settle` 提交。

| 形式 | increment |
|---|---|
| C 风格 `for` 的初始化子句是一个**声明** | 0470 |
| 匿名 `fn` 的 `)` 与 `{` 之间的尾部 | 0471 |
| `for` 头是**一种**文法，不是两种 | 0473 |
| 处于**表达式**位置的循环被送进了错误的读取器 | 0474 |
| 只带一个声明的 binder 头 | 0475 |
| binder 头初始化子句之后的那一步 | 0476 |
| `let` 等号左边的构造子模式 | 0477 |
| `<?` payload，`expr <? { "k": v, .. }` | 0478 |
| UTF-8 BOM 被跳过，而不是被拒绝 | 0479 |
| 无大括号的转义，`'\uXXXX'` | 0480 |
| 嵌套的可选类型 | 0481 |
| 被换行分开的 `for` 头 | 0482 |
| 带包限定的持有者，`@pkg.Type::method` | 0483 |
| 接收者是引用的 trait 方法 | 0484 |
| `is` 位置上的大括号结构体模式 | 0485 |
| `+` 连接的效果子句 | 0486–0487 |
| 跨行的 `<+`、`$|` 模板串 | 0488 |

0481 关掉了 proton 最后一个读不完的文件，0482 关掉了 moonbit_image 最后一个，
0483 关掉了当时 async 剩下的那几个。**async 还有 4 个文件读不完**，就是那份常备
积压：`re"..."` 正则字面量、`let { .. } = x` rest 解构、带非空更新子句的 `for` 头，
以及 `>..` 配 `break <value>`。

### `--per-function`：让行为透镜在每个函数上入口

0.4.29 在真实代码上量了行为透镜，那个数字很难看：六个语料 **1081 个 `.mbt` 文件**
上，它全部可读贡献只有 **3 条 actionable**，占那 89 条的 3.4%；而它自己的三个 family
——`Unreachable`、`NonBooleanCond`、`MethodError`——数出来是 **0 / 0 / 0**。机制本身
不是缺陷：透镜在**模块**上入口，函数体只有被顶层语句调用才执行，而库模块不会在
顶层调用自己的函数。

`--per-function` 给了它第二个入口：每个函数都当作程序入口来分析，形参绑定到按
**声明类型**新造的抽象值——对入口点来说这是唯一站得住的选择，因为运行期值未知。
默认视图不动，两个视图**分开而不是相加**。

而新视图立刻显示这个透镜是**错的**，不只是安静。在 moui 0.1.12 上它报 **265 条
actionable**，而模块视图报 0——那是透镜自己缺陷的清单，全都落在 `moon check` 接受的
代码上。0490 修了列表值撞列表形参、元数规则必须变成一个**区间**、函数体是 `if`
的函数、字符串拼接、字符串比较，以及一个从没记录 `omittable` 的解析器；0491 修了
最后一类——**读**路径从来没查过跨文件符号表，而结构透镜和这个透镜自己的**调用**路径
从 0.4.3 起就查了。

| 语料 | 0489 | 0490 | 0491 |
|---|---:|---:|---:|
| moui | 265 | 58 | **7** |
| proton | 136 | 92 | **5** |
| moonbit_image | 94 | 68 | **44** |
| moonbit_labeler | 95 | 48 | **40** |

moui 上剩下 7 条，分属四个有名有姓的类：一个被 `is` 模式绑定的名字、一个 `None`
接收者、跨文件构造子的元数，以及 unreachable 代码。

### 工具链给两个无后缀整数类型改了名，而表没跟上

0.1.20261012 改了 `Int`/`UInt` 的**规范拼写**，变成 `Int32`/`UInt32`。类型本身没被
改名——`Int` 仍然是可用的别名——但 `moon fmt` 会重写成带宽度的新写法，而分析器的
ambient 类型表和方法表还带着旧拼写：本仓库自己生成的接口文件上就是 **37 条发现**，
而且是在**默认视图**里，所以新工具链上的每个用户都会拿到它们。

修法是**并集**，不是镜像：builtin 方法表是当前接口声明的、intrinsic 补的，**加上**
上一版表里已有的。新接口丢掉的 102 个名字被带了过去；每个名字一个探针，定案
33 个已死、69 个仍可调用，丢掉那 69 个会把合法的调用变成 `undefined function`。

### 两处就地更正

0490 在七个文件里写错了工具链版本号，又在同一个提交的第八处写了对的，而仓库早在
0.4.22 就有三处写对了。更正是后续提交，不是改写历史。

还有一次 `Get-Content -Raw` 往返在这台 CP936 机器上把 `—` 写成 `鈥?`，**并且吞掉
了后面的换行**，在两处把两行注释并成一行。五个文件里 19 处，每一处修好的行都对着
引入损坏那个提交的**父提交**核过字节。故意留着的两处不动——两份 README 是**故意**
把乱码摆在那儿，作为缺陷的记录。

### 依赖动了

`moonbitlang/async` 0.22.4 → **0.22.5**，切这一版之前整套门禁在新依赖下重跑过一遍。
「wasm-gc 想要一个 async 没有导出的 `run_async_main`」这个说法对着新版本重新核过，
仍然成立：`integration.mbt` 用 `#cfg(target="native")` 和 `#cfg(target="js")` 守着它，
另一半是 `integration.wasm.mbt`——只给 `wasm` 目标，不是 `wasm-gc`。

## 0.4.29 —— `expr as &Trait` 是运算符，而解析器里根本没有它的产生式

`as` **早就在词法器的关键字表里**。但**表达式**文法里没有任何东西消费它。postfix 循环在它
上面断开，语句读取器把剩下的 `as` 当成下一个表达式的开头，绑定遍历再把它当成普通标识符
解析出来：

```
69:38 - error: undefined name 'as' (UndefinedName) [structural+type]
```

**一个从来没存在过的名字**，被当成 actionable 报出来——而那个程序 `moon check` 零错误接受。
这是同一形状的第三次出现：`guard`（0.4.21）、`raise`（0.4.23）、现在是 `as`。词法器认识、
解析器不认识的关键字。

### 对着编译器定案，不是假设

`_verify/settle_0428_cast.ps1` 编译三种形式，并要求两个反例必须被拒：

| 程序 | `moon check` |
|---|---|
| `b as &Sink` | **ACCEPTED** |
| `Box::{ n: 2 } as &Sink` | **ACCEPTED** |
| `Box::{ ..o, n: 9 } as &Sink` | **ACCEPTED** |
| `b as`（没有目标） | REJECTED |
| `b as Box`（不是 trait object） | REJECTED |

`moon check` 把规则原话说出来了：*「`Int` is not a trait object type, it cannot be used on the
right hand side of `as`」*。所以 `as` 是解析器**必须接受**的运算符，被约束的只有它的右侧。
这个 settle 的前两稿**什么都没定下来**：一稿把 `fn() => 1` 当 lambda（MoonBit 的 lambda 用
大括号，`fn() => 1` 是 3002），另一稿拿 `as Int` 当目标，于是每个用例都死在 trait-object
规则上，压根没问到 `as` 本身。

### 修法，以及这个节点**故意不**带的东西

`ECast(Expr)`——只带操作数——外加 `parse_postfix_from` 里的 `as` 分支。目标类型由现成的
`type_annotation` 读掉，然后**丢弃**。

这看起来像错过了一个机会：`as` 要求 trait object，所以类型看着可查。**它不可查。**
`IfaceSymTab` 不区分 trait 和 struct——`using @pkg { type View }`、`trait` 声明、`struct`
声明，全都落进同一个 `types` 集合。基于那张表的检查会把**每一个**转成 struct 类型的 cast 都
报出来。带着这个字段却不读它，是一个没有透镜能查的字段——那比不写它更糟。这就是 0.4.26
`()`→TNone 那条教训的反面：**前置条件表里根本不成立的检查，是假阳性发生器**，而「不查」
才是诚实的答案。

**span 取 `as` 那个 token**，不是操作数的。那个循环里其他所有扩展都保留 base span，但那些节点
把 base 压平成了名字、不这样做就会丢掉位置；而这里操作数作为子节点还活着，它的位置仍能通过
`ECast` 取到，**`as` 自己的位置则别处无处可记**。

### 三个透镜，以及这个修复**本来可能引入**的假阳性

`walk` **必须**遍历操作数。`fn to_sink(b : Box) -> &Sink { b as &Sink }` 里只有这一处读 `b`
——一个不遍历就返回的 arm 会把参数报成未读，**用一个假阳性换另一个**。这就是 `EComp` 教训的
原样形态：**没被遍历的那一半，就是会消失的那一半**。它有专属测试，M2 杀它。

`infer` 对操作数定型（所以里面的错名字、错实参类型照样找得到），结果给 `TUnknown`。
`interp` 求值操作数并给 `AAny`，保持路径活着，而不是像 `1 as &Trait` 那样折叠掉。

### 实测

人口是**用工具自己的输出**数的，不是用匹配器——分析器本来就每个出现发一条发现，而发现里写着
那个 token，所以这个数继承不到匹配器的盲区。`undefined name 'as'`，六个语料：**恰好 1 处**，
在 `wzzc-dev/moui runtime/view_tree.mbt:69:38`。

一处很少。但它同时是 **moui 全部的 actionable**。

| 语料 | actionable 前 | 后 | |
|---|---:|---:|---|
| moui | 1 | **0** | 那条 `as` 假阳性 |
| moonbit_labeler | 0 | 0 | 逐字节一致 |
| moonbit_image | 0 | 0 | 逐字节一致 |
| async | 19 | 19 | 逐字节一致 |
| proton | 68 | 68 | 逐字节一致 |
| proton_contract | 2 | 2 | 逐字节一致 |

自检 68/68 解析（100%），**actionable = 0**。

**这个数要连着它的覆盖面一起读。** 823 条通知里，**429 条是「test 声明在已分析子集之外」**——
`test` 和 `impl`、`trait` 走同一个大括号跳過器，于是 **429 个测试体从未被遍历**。这是自检里
**最大的一项排除**。

完整清单由 `_verify/backlog.ps1` 实测得出（**这份清单以前是手攒的，而且漏项**）：

| # | 通知 | 计数 |
|---:|---|---:|
| 1 | test 声明 | **429** |
| 2 | match 表达式 | **155** |
| 3 | **if 表达式** | **45** |
| 4 | struct 声明 | 36 |
| 5 | derive 声明 | 31 |
| 6 | enum 声明 | 14 |
| 7 | 匿名函数字面量 | 10 |
| 8 | const 声明 | 6 |
| 9 | 短 lambda | 2 |
| 10 | try 表达式 | 1 |

合计 729 条**已打印**通知；另有 **94 条**落在每文件的显示上限之后（823 − 729）。
所以上表是下界，不是全部。**每一行都是一段「读过去了但没分析」的跨度**——里面的东西对三个
lens 都不可见，读丢了，绑定也丢了。少掉任何一行都需要为那个形式加一个 AST 节点，
所以它们是**功能**，不是可以改写的通知文案。

`actionable = 0` 说的是**被分析了的那部分声明体**，不是那 823 个被排除的体；这个 0 有一部分
是**靠不看换来的**——而且看的正是最大的一组。这正是 0.4.10 的形状：「一个干净的 0，有一部分
是靠不看得到的」，只是这次对准的是项目自己的测试套件。

### 还有**第二条**「靠不看」的路，而且是整函数粒度的

上面对的是**哪些声明体没被遍历**。还有一条它没提，而它可能更安静：

`Walker::audit_suppressed`（`walk.mbt:354`）把**任何与函数行范围重叠的排除区**当成
「这个函数里我没法下结论」，于是那个函数的 `UnusedLocal` / `UnusedParam` / `ParamChanged`
**整体关掉**（`walk.mbt:707`、`walk.mbt:1011`）。

`_verify/match_read_discriminator.ps1` 实测，正对照带上了：

| 用例 | 本地量从未被读 | 结果 |
|---|---|---|
| 函数里**没有**未分析区 | 是 | **报 unused** |
| 函数里**有**一个 `match` | 是 | **不报** |

同一个局部、同一个函数，只因为函数里多了一个 `match`，unused 检查就整个不说话了。
所以「a local read only inside a match arm 没有报 unused」**并不是**「arm 里的读被记录了」——
我第一版探针就是这么写的，**那是错的**；真相是抑制。

后果有两条，都是真的：

1. `match`(155)、`if` 表达式(45)、匿名函数字面量(10)、短 lambda(2)、`try`(1) 这
   **213 处表达式级**排除落在函数体内时，会关掉**整个函数**的 unused 检查。
   声明级排除（`test` 429 / `struct` 36 / `derive` 31 / `enum` 14 / `const` 6，共 **516** 处）
   在函数范围之外，**不触发**这条抑制（`walk.mbt:349-351` 写明了这一点）。
   这个划分由 `_verify/backlog.ps1` 按类别打印，不是我手分的。
2. 因此 **`actionable = 0` 有一部分是绿的、绿在「没在看」上**——和上面那条测试体排除是
   同一种形状，只不过这一条之前没人写下来。

抑制点有**两处**，不止一处：顶层函数在 `walk.mbt:1010`，**局部函数**（`SLocalFunc`）在
`walk.mbt:710`——两处的理由写在代码注释里：「`sp` 是局部函数的整个范围，所以它体内的
`match` 同样会抑制它的 frame audit」。

**没有测的是**：这个项目里到底有多少个函数因此被关掉了。213 是**上界**；要拿到准确函数数
需要每个 `fn` 的行范围，而分析器并不导出它。与其手写一个花括号扫描然后给出一个可能错的
数字，不如把上界摆出来。

测试 js 442（新增 12）/ wasm 514 / wasm-gc 442。五个突变，四个被杀，一个预期存活，
每次还原都按 SHA256 逐字节核对。

### 行为 lens 在真实语料上到底贡献了多少

`src/interp` 是整个模块里最大的一块：一个抽象解释器，带格、调用缓存和虚拟栈。它到底
有没有挣到自己的位置，README 说了不算——量。

`_verify/lens_audit.ps1` 做两件事。**相位一**数：每条渲染出来的发现都带 lens 标签
（`report.mbt:50`），所以 lens 的占比直接从扫描输出里读。**相位二**是差分，也是真正下结论的
那一步：把 `analyze_module` 改成返回空，重新构建，**在同一棵语料树上**逐字节 diff。

| 语料 | `.mbt` | actionable 开 | 关 | 差 |
|---|---:|---:|---:|---:|
| moui | 551 | 0 | 0 | **0（逐字节一致）** |
| moonbit_labeler | 35 | 0 | 0 | 0 |
| moonbit_image | 17 | 0 | 0 | 0 |
| async | 362 | 19 | 18 | **1** |
| proton | 114 | 68 | 66 | **2** |
| proton_contract | 2 | 2 | 2 | 0 |
| **六个合计** | **1081** | **89** | **86** | **3** |

**行为 lens 不是死代码——但它的全部可读贡献是六个语料、1081 个 `.mbt` 里的 3 条 actionable
（占 89 条的 3.4%）。** 三条全是 `undefined function`，全部落在**限定名**的跨包构造器调用上：
async 的 `Set::from_array`，proton 的 `@async.CondVar::Cond` ×2。最大的语料 moui
（551 个文件、3288 条打印发现）把它整个关掉，输出**逐字节一致**。

更值得说的是**它自己那几个族**。interp 是 `Unreachable`、`NonBooleanCond`、`MethodError`
三个族的**唯一**产生者，而这三个族在 89 条 actionable 里的计数是 **0 / 0 / 0**——不是「少」，
是零。一个专门用来查「`return` 之后的代码不可达」的 lens，在 1081 个真实文件上没有报过一次
不可达。原因 README 早就写过（见 0.4.16 那一节）：interp 只在**函数体被顶层语句触达**时才
分析它，而真实代码里绝大多数函数没人从顶层调用。

**这里不声称那三个族是死代码。** 我造了合成探针（`_verify/lens_matrix.ps1`，七个形状），
**它一个都没触发**——连已知能触发的那个形状（把 proton 的 `facade_notification.mbt` 原样
单文件扫一遍）也复现不出来，因为探针没有语料的包上下文，符号表解析不到 `@async`。这正是
0.4.16 那个探针缺陷的同一个形状：**探针量的是探针，不是 lens。** 所以探针的零不支持任何结论，
差分才是证据。

### 那个存活者，以及它暴露出的门禁 bug

**M4**（interp 不再求值 cast 的操作数）存活了。为了确认它是**理直气壮**地存活、而不是
因为少写一个测试，花了三版夹具加一个测量脚本：

1. 操作数里的 `MethodError`——**根本不存在**。`1.nomethod()` 什么都不报；我探针数到的
   那一条是**警告**（`UnusedParam`），被我 grep `error:` 过滤掉了。
2. 同一个想法放进一个从不被调用的函数。`Interp::run_top` 直接跳过 `SFunc`（`interp.mbt:389`）。
3. 同一个想法放进 `fn main`——它**也是** `SFunc`，同样被跳过。

随后 `_verify/probe_0429_m4.ps1` 上这个突变、重新构建、diff 分析器的真实输出，跑了五个程序。
**五个全部逐字节一致**，两条实测理由：cast 操作数里的未绑定名字是**walk** 以 `undefined name`
报的，而 interp 的 `undefined variable` 与它**同族同 span**，`merge_findings` 只显示一个、
藏起另一个；`FMethodError` 和 `FOpMismatch` 共用 `"arg-type"` 组（`core.mbt:380`），操作数里的
运算符错配同样会被折叠掉。

**这里记的是「我造不出能观测到它的夹具」，不是「已在整个输入空间证明等价」。** 这是两句不同的
话，只有第一句有支撑。保留这个 `eval`，是因为每个兄弟 arm（`EField`、`ETupleField`、`EStruct`、
`EComp`、`EMethodCall`）都求值自己的操作数——一致性是理由，不是证明。

**而门禁自己先是错的。** 早先一次运行报「M4 KILLED, 2 of 442 red」，但**杀死它的两个测试
在干净代码上就是红的**——它们断言了一条分析器从不产生的 `MethodError`。此后每个突变都同样报
那两条红，于是门禁看起来健康，而唯一没被钉住的突变被报成钉住了。
`_verify/mutate_0429.ps1` 现在**先跑一遍未突变的套件，不是全绿就中止**，因为突变计数只有
在基线是绿的时候才有意义。

## 0.4.28 —— `derive` 没有函数体：一条 ParseError 在说一件不成立的事

`derive(Debug, Eq, Clone)` 是**带括号的 trait 列表，没有大括号**。但顶层分派把它送进了
`skip_decl_braced`——那是 `struct` / `enum` / `trait` / `impl` / `extend` / `test` 用的跳過器。
两个后果，**只有一个是看得见的**：

**一、消息是假的。** `skip` 的文案由一个 `braced` 标志决定，于是每条 derive 通知都写着
「its body was not analyzed」——**而 derive 根本没有 body 可分析**。六个语料里生产代码共 570 条。

**二、它会吃掉邻居。** `skip_decl_braced` 向前扫找 `{`，只在遇到 `fn` 时停下。所以

```moonbit
derive(Debug, Eq)
struct Box { n : Int }
```

里，**struct 的大括号被 derive 当成自己的 body 吞掉了**，struct 自己那条排除通知从来没被发出来。
文件声称只做了一次刻意的排除，实际做了两次，而丢掉的那一条正是这条通知存在的意义。

### 我自己犯的那个错，和 0.4.27 是同一族

我量过「`derive` 后面紧跟一个大括号声明」在 moui 0.1.12 里的出现次数：**0**。于是我写下了
「这是潜伏缺陷，对语料零影响」。

**度量是对的，推论是错的。** 跳過器不是在下一行停下——它扫到**任何** `{` 才停，可能隔着很多行。
它一直在吞，只是吞的不是我量的那种紧邻形状。

| 通知 | 修之前 | 修之后 | 差 |
|---|---:|---:|---:|
| `derive`（旧文案） | 575 | 0 | −575 |
| `derive`（正确文案） | 0 | 547 | +547 |
| **struct** | 572 | **829** | **+257** |
| **enum** | 155 | **246** | **+91** |
| **extend** | 238 | **308** | **+70** |
| 合计 | **5,026** | **5,399** | **+373** |

**+418 条此前不可见的排除声明。** 修正之后 notice 数字**上升**——这不是退步，是那 418 条
一直在被悄悄吞掉。

**六个语料的 actionable 全部不变**（moui 1 / labeler 0 / image 0 / async 19 / proton 68 /
proton_contract 2），没有新增误报。

### 这一版没有做什么

通知**保留**。分析器确实没有建模 derive 生成的实现，所以读者有权被告知；被去掉的只是那句
关于「函数体」的假话。**这不是靠少报来好看。**

测试 js 430（新增 5）/ wasm 502 / wasm-gc 430。四道突变全部被杀，每轮 restore 都用 SHA256
证明逐字节一致。M1（退回 braced）与 M2（消息重新声称有 body）是**故意分开**的——只有 M1 被杀
的话，测试锁住的是分派而不是行为，一个声称存在函数体的消息照样能过。

## 0.4.27 —— 返回位置带括号的函数类型，不再被当成元组

返回位置上的函数类型有两种写法，原来只认一种：

```moonbit
-> (Int) -> String     箭头在右括号之后
-> (() -> Int)         箭头在括号之内
```

第二种掉进了 `return_annotation` 的元组分支。那个分支一路吃到**第一个前面没有逗号的
`)`**，而在 `(() -> Int)` 里，这个 `)` 正是**空参数列表**的右括号——于是标注在 `()` 处就结束
了，`-> Int)` 留在 token 流里。`parse_block` 接着去找 `{`，看到 `->`，报 `expected '{'`；
之后整个文件就死了。**一处标注带走整个文件，而且报错指的那个大括号根本不是问题所在。**

修法：判据是「这些括号**关联**的箭头在哪」，而它只可能在两个地方——括号**之内**，或者紧跟
匹配到的 `)` **之后**。一次带嵌套计数的扫描同时回答两者，条件变成 `arrow_inside || is_fn`。

所有受影响的写法都先 settle 过，`moon check` 零错误：带括号式、带参数式、结果本身是元组的
嵌套式、可选式 `-> (() -> Unit)?`、带 `raise` 的式子、以及**多行签名 + 泛型 + 限定名**的式子。

### 语料效果：同一棵树上两个 build 的 A/B

**先说一个差点上当的数字。** proton 的 actionable 在这棵树上读作 **68**，而旧笔记记的是
**100**。差 32 条看着像大胜，但那是**语料树换了**：旧基线取自 TEMP 兄弟树，而
`--extern-iface-dir` 会把兄弟树的接口表喂进这一轮运行。**跨两棵树比数字，量的是树，不是改动。**
同一棵树、两个 build 的 A/B 才是能归因的证据。

A/B 的结论：只有 moui 动，**三个文件从 PARTIAL 变成完整解析**——
`services/service_task.mbt`、`core/program_subscription.mbt`、
`backend/common/services/service_async_queue.mbt`；`unexpected token` 从 113 个文件降到 110。
另外五个语料**逐字节一致**。

### 我的度量脚本两次报了假零

这是这一版真正的收获，比修复本身更值得记。

**其一，是上面那个 A/B。**

**其二，是「这个构型在语料里出现多少次」。** 度量脚本先后两次报「六个语料 0 处」。
第一次的匹配式 `\([^()]*\)` 根本匹配不了嵌套括号——它对一个**按构造就含嵌套括号**的形状报
「未找到」。换成平衡括号扫描之后，**还是 0**。这次括号逻辑是对的，错在前缀：

```regex
\bfn\s+[A-Za-z_]\w*\s*\([^()]*\)\s*->\s*\(
```

每一个子句对普通 MoonBit 都是错的：`fn` 后面紧跟 `[`（`fn[T]`）就匹配不上；`[A-Za-z_]\w*`
匹配不了 `ServiceTask::start`；`\([^()]*\)` 既跨不了多行参数列表，也容不下参数里自带的括号。
而它漏掉的正是语料里**最常见**的那个形状：

```moonbit
pub fn[T] ServiceTask::start(
  self : ServiceTask[T],
  complete : (ServiceTaskResult[T]) -> Unit,
) -> (() -> Unit)? {          ← `-> (`，而且箭头在里面
```

**真实数量是 24 处、9 个 moui 文件**，而不是 0。

**判据：匹配器太窄不会报「未找到」，它报「我没看」。而这两件事在屏幕上长得一模一样。**
匹配一个真实签名是**解析**问题，用正则做是**赌**。所以现在的版本根本不去认签名——它找每一个
`->` token，问紧跟其后的括号组里有没有箭头；这样它不会因为「不认识签名长什么样」而漏看。
而且它的对照不是合成文件，是 A/B：它**必须**找出 A/B 说改动的那三个文件，否则门禁直接中止。

### settle 必须先证明自己在测量

写这一版的夹具时，`settle` 脚本报了**十五个「clean」，而它什么都没查**。因为用例的 key
**没有 `.mbt` 后缀**：清理用的 `-Filter '*.mbt'` 匹配不到任何文件（旧用例全部堆积），而
`moon check` 根本不编译无扩展名的文件，它拿到的是 44 字节的
`Finished. moon: ran 2 tasks, now up to date`。

十五个全绿。**唯一的证据是那个本该变红的负控制，它也读了「clean」。**

现在三道闸各自封死上面那种失效的一半：G1 断言 `src` 里恰好一个 `.mbt`；G2 断言
`moon check` 真的干了活（输出非空、且不是「无事可做」横幅）；G3 断言负控制**必须变红**，
否则整轮结果作废。

另外两处 MoonBit 事实也是这么查出来的：**lambda 用花括号**（`fn() { 1 }`；`fn() => 1` 是
`unexpected token '=>'` 报错），以及**顶层大写名是类型**（`fn G() -> Int` 报
`unexpected token '(', you may expect '::'`）。

### 突变门禁：四杀一等价

五道突变，四道被杀。**M4 存活，而它是等价突变——这一点是证明出来的，不是假设的**：

- 元组分支返回 `""`（`parser.mbt:1272`）
- 函数类型分支返回 `"(Int)"`（`fn_type_annotation:1016`，其后没有 `->`，`out` 保持括号组）
- `ann_to_ty("")` == `TUnknown`（`types.mbt:140`）
- `ann_to_ty("(Int)")` **也是** `TUnknown`——没有任何分支会剥掉那对括号

标注字符串**只有一个消费者** `declared_ret`，而 M4 改道的每一种输入喂给它的都是
`TUnknown`。所以在**整个输入空间上** M4 不可能改变任何可观测量。**硬造一个夹具去杀它
是表演**：这个突变没有行为可杀。

我第一次尝试杀它时断言的是 `ann_to_ty("(Int)")` 会得到 `TInt`——**错的**，所以那道夹具没有
改变任何结论。夹具留下了（那条声明返回路径本来就该有夹具），但注释现在写的是它**建立了
什么、没有建立什么**。

测试 js 425（新增 13）。每一个夹具都同时过 `moon check` **和**分析器两边。

## 0.4.26 —— 尾表达式就是返回值：一次由读代码而不是由语料 delta 找到的修复

**先更正我自己。** 这条待办上一版写的是「声明返回类型在尾表达式函数体上渲染成 `None`
——**可能比 `raise` 本身还大**」。**实测之后这句话是错的**：`raise` 六个语料共 1213 处，
而尾表达式函数**只有 305 个**（moui 108 / moonbit_labeler 64 / async 69 / proton 40 /
moonbit_image 24）。大约是四分之一，不是更大。

**语料 delta 是零。** 六个语料、12,428 个文件，**逐字节与 0.4.25 一致**。这一版是**一次
正确的修复**（有复现器），不是清理。

### 缺陷：尾表达式的值被丢掉了

尾表达式被解析成 `SExpr`，而 `SExpr` 明确丢弃自己的值：

```moonbit
Interp::exec_stmt   SExpr(e) => { let _ = self.eval(e, env) }
Interp::analyze_fn  let ret = join_vals(self.ret_vals)
join_vals           if vals.length() == 0 { return AType("None") }
```

于是 `ret_vals` 永远是空的，`join_vals` 答 `None`，这个 `None` 进入**调用缓存**，**调用者
继承它**：

```moonbit
fn f() -> Int {
  1
}
fn g() -> Int {
  f() + 1        // 报 no method matching +(None, int)
}
```

一个关于**能编译的代码**的、语气笃定的假阳性。`return 1` 版本的控制夹具是干净的，
而且错误值能穿过两层调用者——因为它是被**存下来**的，不是被返回的。

顺带一件同样重要的事：**分析器自己对这份文件说的是 `f() -> None`**。签名行是它对「我读懂了
什么」的陈述，读错了就是缺陷，哪怕没有 finding。

### 修法：新节点 `STail`，加一个 `fn_body` 标志

`STail` 只在**函数体**里产生——这就是 `fn_body : Bool` 存在的理由：同一个块解析器还要读循环
体、`if` 分支和裸块，在那些位置上尾表达式是一条**被丢弃的普通表达式语句**
（`fn f() -> Int { while c { 1 } }` 不返回任何东西）。

三个透镜各自不同：walk 与 `SExpr` 完全一致；类型透镜把它的类型 **join 进推断返回类型**
（`scan_returns` 之前对它一无所知）；行为透镜**记录它的值**，而且**不动 flow**——尾表达式
后面本来就没有东西了。在行为透镜里它**必须被求值**，这与 `raise` 的操作数正相反：终止符
之后的值是死的，所以那里刻意不求值。

### settle：我自己的第一版是空的，而且空了两处

第一版 settle 报了 12 个形状全部「0 错误」，**包括一个 MoonBit 明确拒绝的反例**。两处独立的
bug，而且都是那种不报错的：

1. **`moon check` 只检查从 `fn main` 可达的函数体。** 没有 `main` 就没有任何类型检查。
2. **脚本自己删掉了 `src/moon.pkg`**（`Get-ChildItem src -File | Remove-Item`），于是从第一
   个用例起就没有包可检查，`moon check` 什么都不输出。再加上 PowerShell 会把 native 命令写
   stderr 变成 `NativeCommandError`，合并后的字符串是空的——**两次独立的失败叠在一起，
   让一个 settle 对编译器拒绝的程序开出健康证明。**

修好之后加了**两个负控制**：`fn f() -> Int { "a" }` 报 4014，`fn f() { 1 }` 报 4074。**只有
负控制会红，settle 才算在测量东西。**

它顺带查出两件关于**语言**的事实：
- `while s == "a" { "b" }` 是 **4139**——循环体的尾表达式被丢弃，而只有 Unit 可以静默丢弃。
  我第一版的循环夹具就是这么写的，**一个编译器拒绝的夹具不是夹具**。
- **尾表达式必须有声明的返回类型**（4074）。这正好说明潜在面为什么正好是 305：受影响的函数
  集合，就是编译器已经逼你标注的那个集合。

### 自找的回归，而且是靠六语料逐字节 diff 抓到的

类型透镜里我也把 `()` 教成 Unit 去配行为透镜。`TNone` 是**具体类型**，于是空元组和任何东西
比较都会报——moui `backend/macos/macos_backend.mbt:204` 多出一条
`unsupported operand types for '>': 'int' and 'None'`。那个文件的解析停止行、notice 数、
actionable 数在那一刻全都和前一版一模一样，**只有六语料 diff 看见了它**。

类型透镜那一步已经回退（行为透镜那一步保留——签名行里的值来自那里）。**M5 和 M6 现在是
这道门禁里的一对永久对照**：M5 复现我犯的那个错，M6 是它的反面（「所有元组都是 Unit」）。

### 突变门禁：7 道，第一轮全绿

七道，覆盖四个文件里的四个决定：解析器的 `fn_body`（M3）、位置（M4）、标志是否传到函数体
（M7）、行为透镜是否记录（M1）、记录的是什么（M2）、`()` 是不是 Unit（M5）、真元组是不是
还是元组（M6）。**7 杀 0 存活**，每个 restore 都用 SHA256 证明逐字节一致。

0.4.25 加的 pre-flight 立刻就回本了：本门禁第一版有两个模式串写的是 `moon fmt` 会折成
**一行的三行臂**，pre-flight 在毫秒级中止并打出它要找的那行——**而不是浪费一整轮
`moon test`**。

测试 js 412 / wasm 484 / wasm-gc 412（此前 398 / 470 / 398）。自检 63 文件、**actionable 0**。

## 0.4.25 —— 行为透镜的 if 分支 flow 泄漏，和一个测不出来的东西

**这一版没有语料 delta，而这是量出来的，不是推出来的。** 六个语料、12,428 个文件，
改前改后**逐字节一致**；改前 `Unreachable` 是 0 条，改后也是 0 条。所以它是**一个带
复现器的正确性修复**，不是「清理掉了什么」——把 0 说成成果，正是这个项目一直在拒绝
的那种话。

### 缺陷：分支之间没有 join

`Interp` 在**同一个实例**里依次探索条件未知的 `if` 的各个分支，于是 flow 状态直接在
分支之间传递：一个分支终止了，**下一个**分支的第一条语句就看起来不可达；而整个 `if`
之后活下来的，是**最后一个**分支留下的状态。

最短的复现器里**没有 `raise`**：

```moonbit
fn f(g : Int?) -> Int {
  guard g is Some(v) else {
    return 0
  }
  return v
}
```

报 `return v` 是 `unreachable code`。else 终止、then 不终止，而 else 的 flow 赢了接力。
`guard` 被建模成 then-branch 为**空**的 `SIf`，所以 then 永远不终止——缺陷因此在每一处
`guard ... else { ... }` 上都是活的。这个形状就是 proton 0.3.4
`facade_app_metadata.mbt:81-82` 的形状，只是那里 else 里写的是 `raise`。

### 修法：逐分支重置 + fall-through join

每个分支执行前 `self.flow = FNormal`，分支结束后 `falls = self.flow == FNormal`；
**缺 else 恒为 `falls = true`**（没有分支被取，控制就继续）；末尾
`self.flow = if falls { FNormal } else { FReturn }`。`exec_alt` 从 `Unit` 改成返回
`Bool`，它自己的 `ABool(false)` 臂也做同一个 join。

两个 MoonBit 细节记在源码里：

- **枚举默认不实现 `Eq`**，`self.flow == FNormal` 报 `Type Flow does not implement trait
  Eq`，所以 `priv enum Flow` 加了 `derive(Eq)`；
- `for j in (idx + 1)..elseifs.length()` 会解析成 `(idx+1)..elseifs` 再 `.length()`
  （报 `type Int has no method arr`），遍历剩余 else-if 必须用 `while`。

`ABottom` 条件保持原语义（不终止、falls through）——「bottom 条件该不该压制下游」是另一
个问题，这一版不回答，两个方向都没改。

### 突变门禁：8 道，三轮才全绿

| 轮次 | 结果 | 说明 |
|---|---|---|
| 第一轮 | **1 杀 / 3 存活 / 3 空转** | 3 个模式串根本没匹配上源码 |
| 第二轮 | **6 杀 / 1 存活（M6）** | 模式串修好了，M6 暴露的是夹具覆盖问题 |
| 第三轮 | **8 杀 / 0 存活** | 补 2 个夹具 + M8 |

两道活下来的原因都不是「测试没写够」，而是更蠢的东西，记在这里因为它们会再发生：

**一、夹具必须真的走到它声称在测的那段代码。** `f(1)` 会让 `n` 绑成 `AInt(1)`，
`binop` 把 `n > 0` 折叠成 `ABool(true)`，于是 then-branch 单独跑，**join 所在的臂压根
没进**。而 `f(g())`（`g` 未定义）让调用返回 `ABottom`，整个函数体静默——「没有发现」和
「通过」长得一模一样。第一版有 4 道死在这上面。

真正能走到的形状是 `s == "a"`：`binop` 的 `OpEq | OpNe` 臂无条件返回 `AType("bool")`，
**根本没有字符串臂可折叠**。另外两条备选也实测过：`f(@core.nothing)`（`AAny` 被吸收成
`AType("bool")`）和 `x is Some(v)`（`EIs` 故意返回 `AAny`——**所有真实代码里的 `guard`
本来就走 join**）。

配套的对照很重要：**同形状、相反的期望值**。折叠夹具（`f(1)`，无 else，then 返回）
期望 **1**，不折叠夹具（`f("a")`，同形状）期望 **0**。这个反转就是「它们真的走了不同
的臂」的证据；第一版两个都用 `f(1)`，于是那条「对照」只是在重测常量折叠。

**二、空转变异只有跑完全套件才会报出来。** M5/M6 的缩进按 10 空格写而文件里是 8/6，
M7 的模式串写成 `None => true` 而源码是 `None => falls = true`——三道各白跑一次
`moon test`。所以现在**先做 pre-flight**：任何模式串在原文里找不到就在毫秒级中止并打出
它要找的那一行。第四轮修 M8 时它立刻抓到了我自己的一个错（M8 的 Find 串误抄了 M6 的
**替换后**文本）。

**三、M6 的存活是夹具覆盖问题，不是模式串问题。** `exec_alt` 的**终止** `match els`
只有在**没有剩余 else-if** 时才执行，而当时每一个链式夹具都带 else-if。没有夹具到得了
那段代码，怎么调模式串都杀不掉它。补夹具时顺手发现 **M8**——M6 背后那条
「缺 else 恒 falls through」的**终止版**同样没人测过，于是加了一道。现在 M6/M8 改的是
**同一个 8 行块里的一行**，两个方向互为对照：一个让终止版没法说「终止」，一个让它没法
说「落空」。两句话都说不了的那块代码是没有用的。

测试 js 398 / wasm 470 / wasm-gc 398。扫描脚本 `_verify/scan_0425.ps1` 连比两个基线
（0.4.24 与本次之前的那次 0.4.25 扫描），写新文件名而不是覆盖——`scan_0423.ps1` 里那句
「两次扫描写同一个文件名，就是让基线悄悄变成它自己的对照」在这里又用了一次。

## 0.4.24 —— `raise` 作为表达式：一条子句的第三个位置

**这一版是被一个测量改道的。** 0.4.23 结束时 actionable 涨了，我把每一个 `UndefinedName`
拉出来分类，结论是「`enum`/`suberror`/`derive` 的构造子在分析子集之外」——这是我上一版
自己写的判断。分类之后发现**最大的桶根本不是构造子**：大约 70 条 `UndefinedName` 里，
**65 条是字面量 `raise`** 这个名字（proton 一个语料就占 56 条）。构造子只有 7 条上下。

`raise E` 作为**语句**从来没被实现过。0.4.23 做的是同一条子句在**函数**上的两个位置
（签名标注、函数类型返回标注），而真正执行 raise 的那条语句是第三个位置。它被当成普通
标识符读了，于是每一条 raise 语句都报 `undefined name 'raise'`——一个关于**能编译的
代码**的、语气笃定的假阳性。

出处是 proton 0.3.4 `facade_app_metadata.mbt:82`：

```moonbit
guard config.package_config() is Some(package_config) else {
  raise MissingPackageMetadata
}
```

规模（排除 vendored `.mooncakes`）：**proton 585 处 / 54 文件、async 427 处 / 90 文件、
moonbit_image 180 处 / 16 文件、moonbit_labeler 15 处 / 9 文件、proton_contract 6 处 / 1 文件。**

settle 过了，五种带 payload 的形式 `moon check` 全 0 错误；另外**不带 payload 的裸 `raise`
本身也是合法 MoonBit**，三个位置（独占函数体、函数体末尾、闭合嵌套块且无分号）同样 0 错误。

### 新节点 `SRaise`，而不是 `SReturn`

这是刻意的。三个透镜都会把 raise 读错成 return：

- `Infer::scan_returns` 的 `SReturn(Some(e)) => acc = ty_join(acc, self.ty_of(e, TUnknown))`
  会把**错误构造子的类型** join 进函数返回类型；
- `Interp` 的 `SReturn` 会把 payload `eval` 出来 `push` 进 `ret_vals`，**凭空造一个
  `raise` 根本不产生的返回值**；
- 只有「会终止」这一件事是两者共有的，而那正是 `SRaise` 保留的全部。

payload **照常被 walk 和类型检查**（`raise E(nosuchfunction())` 里的 `nosuchfunction` 照样
报），但**不被求值**——终止符之后的一切都是死代码，求值一个结果会被丢弃的表达式只会扰动
抽象值栈。两个透镜各有一个测试钉住这一点。

### 结果：只减不增

| 语料 | 0.4.23 | 0.4.24 | 发现级 |
|---|---|---|---|
| `wzzc-dev/moui` 0.1.12 | parsed 483 / actionable 1 | **parsed 483 / actionable 1** | 逐条一致 |
| `moonbitlang/async` 0.22.4 | parsed 216 / actionable 22 | **parsed 216 / actionable 19** | −8 条，**0 条新增** |
| `moonbit-community/proton` 0.3.4 | parsed 95 / actionable 103 | **parsed 95 / actionable 100** | −6 条，**0 条新增** |
| `riantr/moonbit_image` 0.3.7 | parsed 2 / actionable 3 | **parsed 2 / actionable 0** | −3 条，**0 条新增** |
| `proton_contract` 0.3.4 | parsed 4 / actionable 3 | **parsed 4 / actionable 3** | 逐条一致 |
| `riantr/moonbit_labeler` 0.2.13 | parsed 25 / actionable 0 | **parsed 25 / actionable 0** | 逐条一致 |

65 条 `undefined name 'raise'` **全部归零**，而且**没有任何 family 的新增**——
`Unreachable` 也是 0 → 0。这在「多读一个语法就多一批 finding」的项目里不常见，值得说清楚
为什么：我在改之前**先查了它会不会引入假的 `unreachable code`**。

### 先量「会不会变吵」，再动手

把 `SRaise` 接上之后我立刻去量 `Unreachable`，因为行为透镜的 `if` 各分支是**在同一个
`Interp` 里顺序执行**的，分支之间的 flow 状态会串：一个终止的分支会把后面所有语句判成死代码。
如果这是真的，这一版就是拿 56 条假阳性换一批新的假阳性。

实测：12,428 个文件里 `Unreachable` 从 0 变 0。**但缺陷是真的，而且能独立复现**，
不需要 `raise`：

```moonbit
fn f(g : Int?) -> Int {
  guard g is Some(v) else { return 0 }
  return v            // 被报成 unreachable —— 这是假阳性
}
```

else 分支终止，then 分支（`guard` 建模成空 then）不终止，**else 的 flow 赢了**。
⇒ **如实记账，这一版不修**：它在这六个语料上 0 次触发，改的是行为透镜的分支合并语义，
和 raise 是两件事。⇒ 另记一条：`enum_ctors` 的构造子采集**只接了 `enum`**，没接
`suberror`/`derive`；而且 proton 的 `OperationFailed` 这类**跨文件** `.mbti` 里的构造子名字
根本进不了 `IfaceSymTab`——那是剩余那 7 条的来源。

### 突变门禁：7 道，**第一版 4 杀 3 存活，最后 7 杀 0 存活**

三道存活各自有一个共同的原因，值得写下来：**payload 不被解析时它不会消失，它变成下一条语句。**
`raise E(nosuchfunction())` 于是被读成 `SRaise(None)` 后面跟一条表达式语句
`E(nosuchfunction())`，同样两个未定义名字、同样在同一行、同样合并成一条——**所有计数型断言
两种实现都通过**。

- **M2**：先试「行为透镜不求值 payload」来分辨，没成——被孤立的 payload 紧跟在一个终止的
  `SRaise(None)` 后面，行为透镜同样不会执行它，它被报成 unreachable 了。最后用**锚点行号**
  分开：payload 挂上去时死掉的是第 6 行的 `return 1`，被孤立时死掉的是第 5 行的 payload 本身。
  **同样的条数、同样的 family、同样的透镜，不同的行号**——而行号正好就是「payload 属于这条
  raise」这句话本身。
- **M4**：第二个原因。此前的 payload 全是对**未知名字**的调用，而对未知函数的调用没有签名
  可查实参，`ty_of` 提前返回，payload 其实根本没被看。换成类型透镜自己会查的表达式：
  `raise 1 + "a"`（settled 合法，`int + str` 是 `OperatorMismatch`）——二元运算符不像名字查找
  那样会因为缺签名而跳过。
- **M7**：文件里**根本没有裸 `raise` 的夹具**。叫 `bare` 的那个函数写的是 `raise E`，
  有 payload。补上真正无 payload 的形式（三个位置）就红了。

测试 js 386 / wasm 458 / wasm-gc 386（新增 12 道）。
## 0.4.23 —— `raise` 效应标注，以及一个被它照出来的假阳性

**先更正我自己的一个数。** 这一版开工时我说「moui 608 个文件里 149 个（24.5%）带
`-> T raise E`，全部完全不可解析」。**那个 grep 把 vendored 的 `.mooncakes` 一起数了**，
而扫描器根本不扫 vendored 目录。排除之后 moui 只有 **2 个**文件。同一把尺子量六个语料
（排除 `.mooncakes`）：

| 语料 | 文件 | 签名位 `-> T raise` | 类型位 `() -> T raise` |
|---|---|---|---|
| `moonbitlang/async` 0.22.4 | 409 | **72** | **10** |
| `moonbit-community/proton` 0.3.4 | 136 | **70** | **33** |
| `riantr/moonbit_image` 0.3.7 | 17 | **14** | 0 |
| `proton_contract` 0.3.4 | 3 | 2 | 0 |
| `riantr/moonbit_labeler` 0.2.13 | 35 | 2 | 1 |
| `wzzc-dev/moui` 0.1.12 | 607 | 2 | 0 |

修复是真的（`moonbit_image/bmp.mbt:26` 的 `-> Image raise Failure` 现在干净解析，
`decoded_bmp` 之前死在 `expected '{'`），但**规模我之前报大了一个数量级**。可读文件总数
**787 → 825**，不是 149 个文件的量级。

### 一条子句，两个位置

`parse_fn_signature` 读完 `-> T` 之后直接期待 `{`，不认 `raise`。settle 过了，四种形式
（`-> T raise` / `-> T raise E` / `-> T!` / `-> Unit raise E`）`moon check` **0 错误**。
裸形出自 `moonbitlang/core/error/error_test.mbt`，所以它不是这里发明的形状。

**写完签名位才发现漏了类型位。** 函数类型自己也可以带效应标注——`fn f(g : () -> Int raise)`
在 settle 里同样是 0 错误，但解析器报 `expected ')'` 并且丢掉文件后半段。只修签名位会留下
一个「签名位置认、类型位置不认」的半截修复：proton 33 个文件、async 10 个正好是这个形状，
每一个都会死。两个调用点现在共用 `Parser::parse_raise_effect`。

裸形「必须停在这里」的判据写成了**「下一个 token 能不能开一个类型」**（`TName` / `TLParen`
/ `TAmp`），不是「哪些 token 终结」。因为两个方向不对称：**多读一个 token 是静默误解析**
（函数体被吞进类型标注，什么都不报）；**少读一个 token 是响亮的 `expected '{'`**。

### 顺带照出来的假阳性：`guard!`

`parse_guard` 读完 `guard` 就去读条件，于是 `guard! cond` 的 `!` 掉进表达式读取器，变成对条件
取反。报出来是 `operand of '!' must be bool, got '[int]'`——**一个关于能编译的代码的、语气
笃定的假阳性**：

```moonbit
// moonbitlang/async 0.22.4 src/internal/fd_util/pipe.mbt:31
guard! fds is [r, w]
```

这个缺陷一直在，只是被「文件压根没解析」挡着。**raise 修复只是不再替它遮丑。**

于是 `TBang` 这一个 token 在同一个文件里有三个主人：`raise` 短式、`guard!`、以及真正的布尔
非。三道对照测试各钉一个——`!` 短式、裸 `guard`、`!` 仍然是非运算符。任何一处改成扫 token
而不是按位置判定，这三条里必有一条会红。

### 代价：actionable 涨了，而且涨的全是 `UndefinedName`

可读文件变多，**每多一个可读文件就多一批 finding**，其中一部分是假的。这必须说清楚：

| 语料 | 0.4.22 parsed / actionable | 0.4.23 parsed / actionable | 发现级 |
|---|---|---|---|
| `wzzc-dev/moui` 0.1.12 | parsed 481 / actionable **1** | **parsed 483 / actionable 1** | 0 条新增 |
| `moonbitlang/async` 0.22.4 | parsed 206 / actionable 17 | **parsed 216 / actionable 22** | +5 `UndefinedName` |
| `moonbit-community/proton` 0.3.4 | parsed 72 / actionable 43 | **parsed 95 / actionable 103** | +60 `UndefinedName` |
| `riantr/moonbit_image` 0.3.7 | parsed 1 / actionable 0 | **parsed 2 / actionable 3** | +3 `UndefinedName` |
| `proton_contract` 0.3.4 | parsed 3 / actionable 1 | **parsed 4 / actionable 3** | +2 `UndefinedName` |
| `riantr/moonbit_labeler` 0.2.13 | parsed 24 / actionable 0 | **parsed 25 / actionable 0** | 0 条新增 |

按 family 数过：**新增的 actionable 一条 `UndefinedName` 都不例外**，`UnusedParam` 不变，
`OperatorMismatch` 因为 `guard!` 修好反而**减少**（2 → 0）。抽查确认是假阳性：

```moonbit
// proton facade_error.mbt:6
OperationFailed(action~, status=..., detail=...)
// 报: no visible binding for 'OperationFailed'
```

`OperationFailed` 是 `WindowSessionError` 的构造子，全语料有四处真的这么用。它的声明
（`enum` / `suberror` / `derive`）**在分析子集之外**，body 没被分析，名字就永远进不了符号表。
**根因是既有的子集边界，不是这一版的解析改动**——这一版只是让这些文件第一次能被读，于是
第一次能看见这个洞。它现在是 actionable 噪声的第一大来源，比 raise 本身更值得下一版处理。

### 突变门禁：9 道，**9 杀 0 存活**（`_verify/mutate_0423.ps1`）

比 0.4.22 的 6 杀 2 存活干净。几道值得记：

- **M7 / M8 是同一个守卫的两个方向。** 守卫放行一切 → 裸 `raise` 吞掉函数体的 `{` 或闭合的
  `)`，**静默误解析**，4 条测试变红；守卫什么都不放行 → 每个具名效应都不再被消费，6 条变红。
  只测一个方向，会把「过严」误当成「正确」。
- **M5 杀掉的不是 `skip_indexed()`，而是 `raise` 关键字自己。** 第一版我把
  `skip_indexed()` 去掉当 M5，结果 **371/371 全绿——它是个等价突变**：`type_annotation` 自己
  就调 `indexed_suffix()`，`raise E[Int]` 不靠那行也能整块吃掉。这行死代码**删掉了**，理由写在
  调用点：留着会让下一个人以为它在管一个它其实没管的用例，而删掉它的人没有任何证据说明有东西
  在查。
- **M2 第一次报的是 COMPILE-ERR，那是门禁自己的 bug 不是结果。** 我的 Find 串以换行开头，
  替换后代码被并进了上一行注释里，突变**根本没运行**。判据只有一个：**`Total tests:` 行不存在**
  才算 COMPILE-ERR，绝不 grep。

### 两个新记下来的缺口（这一版量到，没修）

- **返回类型在尾表达式函数体上渲染成 `None`。** `fn f() -> Int { 1 }` → `f() -> None`，
  而 `fn f() -> Int { return 1 }` → `f() -> int`。**跟 `raise` 无关**：四种 raise 形式配上/不配上
  显式 `return` 全部一致。真实 MoonBit 大量用尾表达式，所以这个的语料影响大概率远大于 raise 本身。
  0.4.23 的测试因此**刻意用显式 `return`**——不然这条断言会因为一个和效应标注毫无关系的理由变红。
- **返回位置的带括号函数类型被当成元组。** `fn f() -> (() -> Int) {` 报 `expected '{'`，
  **没有 `raise` 也一样**（`return_annotation` 的元组分支停在第一个 `)` 而非配对的那个）。
  真实的 `-> (Int, String)` 正常。语料影响小：moui 6 个文件，其余语料 0。下一版处理。

测试 js 374 / wasm 446 / wasm-gc 374（新增 14 道）。

## 0.4.22 —— 具名实参按**名字**匹配，以及 `Int32` 读作 `Int`

可读文件数不变（**481**），但 moui 的 actionable **8 → 1**。消失的 7 条全是同一个形状
`argument 4 ... has incompatible type 'str'; expected 'bool'`，从
`core/gesture.mbt:754` 开始：

```moonbit
// core/pkg.generated.mbti:92 的声明顺序
ActionCommand::new(intent~, label?, shortcut?, enabled?, group?, description?)
// core/gesture.mbt:754 的调用顺序
ActionCommand::new(intent=..., label=..., group=..., description=..., shortcut=...)
```

MoonBit 允许具名实参任意重排（`moon check` 确认），所以**实参的下标不等于形参的下标**。
旧代码比较 `args[3]` 和 `params[3]`，于是 `description`（String）落到 `enabled`（Bool）
上。现在每个具名实参按**标签**找形参，只有没有标签、或标签谁也不匹配时才退回按位置。

`~` 简写（`f(x~)`）同样是一个标签，从 token 流里把名字读回来（`Parser::name_at`），
所以它也能重排。

| | 形状 | 结果 |
|---|---|---|
| A | 具名实参重排（`moui core/gesture.mbt:754`） | actionable 8 → **1** |
| B | `ann_to_ty` 少一个 `"Int32"` 分支 | **修掉格式化器给自己源码造的 87 个静音点** |

**反向对照是这一版最要紧的东西。** A 的断言是 0 条，而"把检查整个关掉"同样会得到 0 条
——所以必须有一条断言 **1 条** 的测试才让它有意义。九条测试成对写：具名错类型、位置错
类型、标签谁也不匹配退回位置、`~` 简写重排对与错、位置元数、`?` 可选参数省略、
`Int32` 同义与不同义。

**突变门禁抓到了三条当时看不见的东西**（`_verify/mutate_0422.ps1`，8 道 6 杀 2 存活）：

- **夹具里多一行 `let r = build()` 会让三条突变全部存活。** 实参类型不符时行为透镜会把
  同一个调用报成 `MethodError`，和类型透镜的 `ArgTypeMismatch` 合并（`merge_findings`
  按 `(merge family, 行号)` 分组），于是 `count_family("ArgTypeMismatch")` 恒为 0。
  **把 `param_index` 改成永不匹配，432 个测试照样全绿。** 零计数断言只有在它数的那个
  finding 真的以那个 family 到达时才可能失败。
- **两行同线会塌成一条。** 同上，`merge_key` 是 `(merge_group, line)`；两个错实参写在
  一行只回来一条，所以期望 2 的用例必须拆行。
- **`parse_call_args` 有四个 push 点。** 「不以名字开头的实参」那一个不是「以名字开头」
  那一个；少 push 一次不会报错，只会让 `labels` 比 `args` 短，缺口之后的每个实参读到的
  是**后面某个实参的标签**。补的夹具是 `g(1, b=true)`——顺带settle出一条语义：
  `?` 可选形参**根本不能按位置传**（`moon check` 报 "requires 0 positional arguments"），
  `~` 必填标签的也不能，只有裸的 `a : Int` 才行。这也正是具名实参在真实 MoonBit 里
  到处都是、而按位置匹配误报那么多的原因。

**两道存活的突变，如实记账而不是补测试把它做绿**：

- **M7 `all_positional` 门（具名调用不查元数）。** 没有任何测试能看见它，因为**没有任何
  合法 MoonBit** 会用具名实参传超过形参个数——settle 过了：标签重复是 4084，标签匹配不
  到形参是 4085，都是 `moon check` 已经报出来的编译错误。它的代价是量过的：六个语料
  12,428 个文件里，它只影响 **1 条** finding（`moui backend/web/web_host.mbt`，且在该文件
  的可靠区边界之后，落进 `unreliable` 桶、从不作为结果显示），而那条无法确认是真阳性。
  写一条钉住「无合法程序会表现出的行为」的测试会让门禁变绿、让套件变弱。
- **M8 方法调用标签。** `EMethodCall` 现在带标签，但 infer 直接丢弃
  （`EMethodCall(base, _, args, _)`），因为本模型里方法实参**根本没有类型检查**——没有
  接收者签名可查。这是真缺口，不是设计上的宽容：要杀掉它得先有方法接收者签名，比这一版大。

**`Int64` / `UInt` 故意不并到 `TInt`。** `moon check` 确认 `UInt` 传给 `Int` 形参是
`Expr Type Mismatch`，反过来也是，`Int64` 对两者都是。并进去不是无害的加宽，而是**精准
静音 `moon check` 恰好会报的那些不匹配**——正是 0.4.5 的失败模式（前置条件永不满足的
检查）符号反转。它们读作 Unknown，等各自的 `Ty` 变体和可赋值规则。给后续的人一个规模：
proton + async + moui 一共 **122 处 `: Int64`、23 处 `: UInt`**。

测试 js 360 / wasm 432 / wasm-gc 360（新增 17 道）。自检 59/59、`actionable=0`、
`unreliable=0`、`withheld=0`。

| 语料 | 0.4.21 | 0.4.22 | 发现级 |
|---|---|---|---|
| `wzzc-dev/moui` 0.1.12 | parsed 481 / actionable 8 | **parsed 481 / actionable 1** | 7 条假阳性消失，**0 条新增** |
| `riantr/moonbit_labeler` 0.2.13 | parsed 24 / actionable 0 | **逐字节一致** | — |
| `moonbitlang/async` 0.22.4 | parsed 206 / actionable 17 | **逐字节一致** | — |
| `moonbit-community/proton` 0.3.4 | parsed 72 / actionable 43 | **逐字节一致** | — |
| `riantr/moonbit_image` 0.3.7 | parsed 1 / actionable 0 | **逐字节一致** | — |
| `proton_contract` 0.3.4 | parsed 3 / actionable 1 | **逐字节一致** | — |

## 0.4.21 —— 436 → 481：`guard`、具名实参的 lambda、跨行的 `is`，和一个只绑第一个名字的 `is`

可读文件 436 → **481（71.7% → 79.1%）**，withheld 1078 → **242**，unreliable 3025
→ **1711**，`unexpected token` 163 → **113**，moui 的 actionable 10 → **8**。
`embedded_runtime_backend.mbt` 上那 7 条（3× `image_state`、4× `host_bridge`）
全部消失。

四个独立形状，都是先量后断言：

| | 形状 | 语料处 |
|---|---|---|
| A | `guard COND else { ... }` 被当成标识符 | 550 处 / 126 文件 |
| B | 具名实参的值是 lambda，参数列表在那里断掉 | 解析 436 → **481** |
| C | `is` 不跨行续接，**文件照样解析成功** | `embedded_runtime_backend.mbt:227` |
| D | `is` 只绑第一个名字，而且只在 depth 1 | 7 条 + 全语料 13 处 |

### C 是这个项目里最难查的一种坏：解析成功，树是错的

```moonbit
guard (self.frame, self.image, self.host_bridge)
  is (Some(frame_state), Some(image_state), Some(host_bridge)) &&
  !self.disposed else {
```

换行结束表达式，`is` 被读成普通标识符，然后**文件解析成功**，只是那个点之后
每个名字都是错的——15 条发现，而且因为什么都没失败，**一条都没被标成
unreliable**。所以这道门禁不断言 `n_parse == 0`（它两种情况都绿），断言的是
**续接之后的那些名字能解析**。

续接只跳 `TNewline`，**不能**用 `skip_seps`——它也吃 `;`，而分号在 C 风格
`for` 里是**结构性的**。写成 `skip_seps` 时是既有测试把它抓红的，这条以
`0421: a C-style for body is still analyzed (control)` 钉住。

### D：先 settle 再动手，结果和我的判断不一样

我以为 `Some(Os(error))` 里的 `error` 本来就绑着，只是没人用。**先跑
`moon check`**：

```
fn f(x : Int) -> Int {
  guard try_os(x) is Some(Os(error)) else { return 0 }
  error + 1
}
```

`moon check` 接受，**`error` 确实是绑定**。原来的读取器只读 depth 1，于是 `Os`
成了绑定名、`error` 掉了下去，它的每一次使用都报 `undefined variable`。depth 3
的 `Some(DragLeft(Some(event_position)))` 同理。

规则收敛成一个判定，**两个分支共用同一个读取器**（0.4.18 和 0.4.20 各栽在
"第二个名字读取器会和第一个漂移"上一次，这次写成带下标的谓词，让它没法漂）：

- 不是 `_`，不是关键字
- 后面不是 `(`——那是嵌套构造器，不是绑定
- 左右邻居都不是 `.`——`@core.Role::Checkbox` 是限定路径，语料里 18 处
- 第一个 `:` 收尾——后面是类型标注，`Int` 不是绑定；`::` 正好走到这条

### 差分**抓出了我自己引入的回归**

`proton internal/bridge_admission_test/main.mbt:93`：

```moonbit
runtime.prepare_bridge_request(request, window) is (Gone | PageUnavailable)
```

那个 `(` 是**分组括号**，不是构造器载荷，于是 `Gone` 和 `PageUnavailable`
被当成局部绑定，报出两个**并不存在**的未使用局部。其中**一个是我这次新引入的**
——旧读取器只取第一个名字，所以从来只绑过 `Gone`。元组分支因此改成
`depth >= 2`（真正的元组绑定在 `Some(` 里，深一层）。这条不是推理出来的，是
六语料逐条发现级差分跑出来的，加了 M8 钉住。

### 差分

| 语料 | 0.4.20 | 0.4.21 | 发现级 |
|---|---|---|---|
| `wzzc-dev/moui` 0.1.12 | parsed 436 / actionable 10 | **parsed 481 / actionable 8** | 多 45 个文件变可读 |
| `riantr/moonbit_labeler` 0.2.13 | parsed 23 / actionable 3 | **parsed 24 / actionable 0** | 3 条 `undefined function '@core.X::new'` 消失 |
| `moonbitlang/async` 0.22.4 | parsed 206 / actionable 29 | **parsed 206 / actionable 17** | 12 条 `undefined name 'guard'` 消失，**0 条新增** |
| `moonbit-community/proton` 0.3.4 | parsed 71 / actionable 44 | **parsed 72 / actionable 43** | 2 条 `guard` 消失，1 条新增见下 |
| `riantr/moonbit_image` 0.3.7 | parsed 1 / actionable 0 | **逐字节一致** | — |
| `proton_contract` 0.3.4 | parsed 3 / actionable 1 | **逐字节一致** | — |

proton 唯一那条新增是 `internal/bridge_admission_test/main.mbt` 里的
`undefined name 'nobreak'`——**一个刚变可读的新文件**，`nobreak` 是本前端
还没实现的循环修饰符。不是这次改动造出来的假阳性，是新文件暴露出的真实缺口。

### 突变 8 道全杀，两个方向都有

M1 `guard` 不解析、M2 **丢掉 `guard` 的 else 块**（控制测试才抓得住：条件里的
名字照样解析，不丢 else 的话两边一模一样）、M3 具名实参 lambda 头关掉、M4 跨行
续接去掉、M5 只绑第一个名字、M6 限定路径规则去掉、M7 嵌套构造器规则去掉、
M8 or-pattern 深度规则去掉。8/8，每一处还原都按 SHA256 验证过逐字节一致。

### 没修的，如实记账

moui 剩 8 条 actionable，全部落在两个已知项上：`navigation_routing.mbt` 1 条
和 `gesture.mbt` 6 条是**具名实参按位置比对**（`TFunc` 不带形参名，要改整条签名
流水线）；`view_tree.mbt` 1 条是 `expr as Type`，AST 里没有 `ECast`。

另外两条**量出来但没动**的已知限制，因为它们不在这一轮的形状家族里：

- **调用函数类型的参数会报 `undefined function`**：`let f = inc` 然后 `f(1)`
  就报，文件里**根本没有 lambda**。这是 0.4.19 加函数类型注解带出来的既有假阳性。
  我的门禁夹具一开始踩到了它，才写进测试文件头的告诫里。
- **`is Some(x : Int)` 的类型标注**：全语料 0 处（18 处 `is X(...)` 里带冒号的
  全是 `@core.Role::Checked` 这种限定路径）。规则里留了 `:` 收尾，但**没有语料
  验证过**，不据此宣称已覆盖。

### 工具链在这次发布当天动了，CI 一开始是红的

`v0.4.21` 的 tag 一推上去，`gate` 就**红在 `moon fmt --check`**，而
`moon check` 是绿的。两个 workflow 都从
`curl .../install/unix.sh | bash` 装 moon——**不钉版本**，装的是 `latest`。

**先量，再决定怎么修**：

1. 本地 `moon fmt --check` 是绿的，所以不是我这棵树的问题。
2. 把已发布的 **v0.4.20 tag** 检出，用同一个新 moon 跑 `moon fmt --check`——
   **也红**。所以这是**早就存在的环境问题**，跟任何一次改动无关：上游一改
   格式化器，不钉版本的 gate 就会在任何 commit（包括 revert）上变红。
3. 新 moon 是 `0.1.20261012`（当天发布），本地是 `0.1.20260920`。差异不是
   空白：它把 `src/core/moon.pkg` 的 `options("proof-enabled": true,)` 改成
   `proof_enabled = true`，**全树 19 个文件**要重排，其中还有
   `Int` → `Int32` 的类型改写。
4. 先试**钉版本**——最省事。`MOONBIT_INSTALL_VERSION=0.1.20260920` 装到
   CI 上，**`Install moon` 这一步直接失败**：CDN 上已经没有这个版本的 Linux
   二进制。**钉版本这条路是死的**，因为旧的会被删。
5. 所以只剩一条：接受新工具链的格式化。

接受之前先量它到底改不改行为：新 moon 跑**未重排**的 0.4.21 源码，
`moon check` 退出 0、`moon test` 415/415 全过——说明 `Int` → `Int32` 只是
格式化器的规范形式，不是编译要求。重排之后再量一遍：check 0、三目标
343/415/343 全过、自检 59/59 `actionable=0`、**六个语料的 SUMMARY 逐字节
一致**。所以这 19 个文件的改动**一个可测量的数都没动**，`Int` → `Int32` 也
不是新要求。

### 顺带发现：突变脚本会**静默失配**

重排把 `.mbt` 从 LF 变成 CRLF，而 `mutate_0421.ps1` 自己还是 LF（它不是
MoonBit 源码，格式化器不管它）。于是**每一道跨行 pattern 都匹配不上**，八道
突变里有六道报 NO-OP。

门禁是**响亮地失败**的（NO-OP 计作失败，这正是它该有的行为），但一个会静默
失配的门禁离「装饰品」只差一次编辑。所以改成**两边归一化换行再比对**，写回时
沿用文件原有的风格——改完之后八道全杀，而且每次还原的 SHA256 仍然逐字节一致，
这反过来也证明了归一化的往返是对的。

### 测试

415 道（js 343 / wasm 415 / wasm-gc 343）。自检 59/59，`actionable=0`、
`unreliable=0`、`withheld=0`。

## 0.4.20 —— 一个方法被当成了顶层函数

`impl T for U with fn m(...) { ... }`。可读文件 432 → **436**，withheld 176 → 172，
unreliable 3193 → **3025**，moui 的 actionable **14 → 10**：四条
`undefined name 'self'` 消失。

### 我第一版的测试是**空的**，突变抓出来了

第一版只断言「`self` 没被报未定义」。把修复回退掉，整个套件**照样全绿**。
原因不在直觉里，在 `Parser::skip`：它只记一条 note，**一个 token 都不消费**。
所以修复前 cursor 停在 `fn` 上，顶层循环把 `with fn identity(self) { ... }`
当成一个**普通顶层函数**重新读了一遍——`self` 一直都绑定着，语料那条告警
从来就不是「缺绑定」。

真正变掉的是**收割**（harvest）：`collect_declared_names` 看到的是 depth 0 的
`fn`，于是把方法名 `identity` 记成了包级 value，包里任何地方调用 `identity`
都会解析成「已定义」。

### 改了**两个**地方，因为有两个独立的读取器

1. `skip_decl_braced`：`fn` 哨兵是给 `pub impl Eq for T`（无体，形参在另一个
   块里）准备的，`with` 只出现在有体的那种写法里，所以拿 `with` 当区分。
2. `collect_declared_names`：**完全独立的第二个名字读取器**，根本不经过
   `skip_decl_braced`。不给它自己加护栏，幽灵方法名原样回来。

（这已经是 0.4.18 的同一个教训第二次出现了：泛型函数名进不了 sibling 表，
也是因为这个。）

语料上量过：1224 个 `impl ... with` 头（221 个文件），其中 **1047 个写
`with fn`**，另外 177 个**省略 `fn`**（`pub impl ToJson for Affine with
to_json(self : Affine)`）。那 177 个从来没碰到哨兵、一直是对的；1047 个全错。
1047 个头里**没有一个**带多于一个 `fn`，所以停在第一个 body 之后不会留下悬空。

### `trait` 自己的名字必须留着

第一版把整个 holder 挡掉了，于是 `trait Marker { ... }` 的 `Marker` 也收割不到，
把 pyroduct 那个既有测试弄红了。`trait` 声明的类型是包级的，要留；
`impl Eq for T` 和 `extend` 声明**任何东西**都不声明——`Eq` 是被实现的 trait，
声明在别处——所以只让 `trait` 贡献名字。这条单独用 M4 钉住。

### 收割那道修复在 moui 上**看不到收益**，这是预期

语料数字和只改 parser 时一模一样（436 / 10）。因为它修的是**造出来的绑定**
——一个假的阴性，不是少报一条可见的发现。它防的是「包里调用一个方法名，
被解析成已定义」。moui 里没有这种调用，所以量不出来。它的门是
`0420: an impl method is not harvested as a top-level function`，
只测收割器本身。

### 差分

| 语料 | 0.4.19 | 0.4.20 |
|---|---|---|
| `riantr/moonbit_image` 0.3.7 | parsed 1 / actionable 0 | **六项指标逐字节一致** |
| `riantr/moonbit_labeler` 0.2.13 | parsed 23 / actionable 3 | **parsed 23 / actionable 3** |
| `moonbitlang/async` 0.22.4 | parsed 196 / actionable 30 | **parsed 206 / actionable 29** |
| `wzzc-dev/moui` 0.1.12 | parsed 432 / actionable 14 | **parsed 436 / actionable 10** |

自检 56/56，`actionable=0`、`unreliable=0`、`withheld=0`。

### 突变 4 道全杀，而且是两个方向

M1 拿掉 `with` 例外（修复消失）、M2 把哨兵整个关掉（**控制测试**才抓得住：
无体 impl 会一路吞掉后面整个文件）、M3 拿掉收割护栏、M4 不收 `trait` 名字。
M2 是这个门禁存在的理由——只测「修复没了」是不够的。

## 0.4.19 —— 389 → 432：一个字面量被当成绑定名，和一个把文件读废的类型注解

接着用 `wzzc-dev/moui` 0.1.12。读得懂的文件 389 → **432**（71.1%），withheld
219 → 176，unreliable 4388 → **3193**。

### `if x is Some(true)` 把 `true` 当成了绑定名

`core/view_node_test.mbt` 一带报了 `local variable 'true' assigned but may not be
used`。`parse_is_pattern` 把 payload 里**任何**名字都当成绑定——而绑定的前提是
「这个名字引入一个变量」，关键字不引入。

判据用 `@lexer.is_moonbit_keyword`，**不**在 parser 里另抄一份。那张表本来就含
`true`/`false`，而且里面有一段长注释专门说明为什么 `self` **不在**表里；另抄一份
正是两边漂移的开始。`self` 因此照样能绑定（`if x is Some(self)` 就是这个意思），
这条也进了测试当反向对照。

### 函数类型注解：845 处 / 171 个文件

`on_input~ : ((String) -> Msg)?`、`key : (T) -> String`、`emit : (Msg) -> Unit`。
`(` 原来直接撞上 `expect_name`，报 "expected type name"，文件到此为止。

注解的元素由 `type_annotation` **自己**读，所以嵌套自然成立——`((String) -> Msg)?`
是「返回函数类型的函数类型」。渲染是**如实**渲染的，不是拍平，所以交给类型镜头的
字符串还是原来那句话；`ann_to_ty` 对 `(` 开头的注解没有分支，返回 `TUnknown`，
这是诚实的答案：镜头不建模函数类型，而 unknown 才能让上面任何操作保持安静。

返回位置多一个坑：`return_annotation` 的元组分支接受**任何** `(`。第一版用
「三个 token `(`, `)`, `->`」去认函数类型——那只匹配 `() -> T`，因为
`(Int) -> String` 的括号**中间**有个 `Int`。是那个夹具（4 个 parse error）把
这条抓出来的。改成**扫描到配对的 `)` 再看后面是不是 `->`**。

### 诚实记账：这一版 actionable 从 4 涨到 14

多读 43 个文件，必然多出 9 条新发现。**其中 7 条是假阳性**，来自三个这轮只是
「变得可见」的类别，都已量过、已写进 SKILL：

| 类别 | 条数 | 语料规模 | 根因 |
|---|---|---|---|
| 具名实参按位置比对 | 5 | `ActionCommand::new(...)` ×5 | 调用**省略了有默认值的参数**并按名字传剩下的，镜头丢标签按位置比，于是 `description`(String) 对上了第 4 个形参 `enabled`(Bool) |
| `impl ... with fn name(self)` 的 `self` | 4 | 1047 处 / 204 文件 | `skip_decl_braced` 的哨兵放弃 impl 体，形参没有绑定 |
| `expr as Type` 转换 | 1 | 29 处 / 21 文件 | `as` 没有处理，当成裸名字 |

前两类都需要**改 AST**（`ECall` 的实参要带标签；`Param` 要记有没有默认值），
不是一处几行的改动。这轮不做，写下来当下一轮的账。

行首 `is` matcher 那个（`f(x)` 换行后接 `is Some(_)`）这轮**没有 settle 掉**：
最小探针复现不出合法形态，所以没有据此写修复，仍然是已知缺口。

### 差分

| 语料 | 0.4.18 | 0.4.19 |
|---|---|---|
| `riantr/moonbit_labeler` 0.2.13 | parsed 22 / actionable 3 | **parsed 23 / actionable 3** |
| `riantr/moonbit_image` 0.3.7 | parsed 1 / actionable 0 | **六项指标逐字节一致** |
| `wzzc-dev/moui` 0.1.12 | parsed 389 / actionable 4 | **parsed 432 / actionable 14** |

labeler 的 unreliable 360 → 352，actionable 一条没动。自检 55/55，
`actionable=0`、`unreliable=0`、`withheld=0`。

### 突变：一道杀不掉，而且**应该**杀不掉

4 道突变 3 杀。第 4 道把「每个 `(` 开头的返回都当函数类型」，**活了下来**——
原因是诚实的：对镜头读得懂的任何注解，元组分支和函数类型分支消耗的
**token 完全相同**，没有 `->` 时 `fn_type_annotation` 渲染完就返回，`ann_to_ty`
两边都得到 unknown。所以 `n_parse` 分辨不了它们，这道突变**本质上不可分辨**。
元组那条测试仍然留着——它不是给这道突变当击杀的，是防将来把元组解析改坏的。

还有一处工具选错了：`is_moonbit_keyword` 的 `.mbti` 导出**没有**突变覆盖——
`moon test` 从**源码**编译，而只有**自检**读被跟踪的 `.mbti` 接口文件；把那行
删掉，391 个测试照样全绿。这个洞是真的（0.4.18 已经踩过一次 `TTilde`），
所以发布检查里跑自检并要求 `actionable=0`。

## 0.4.18 —— 换一个语料：608 个文件里 193 → 389，actionable 588 → 6

前十七版的语料都是本项目熟悉的东西。这轮换了一个**从未扫过**的包：
`wzzc-dev/moui` 0.1.12（608 文件）。选它的理由只有一条——`moon check` 能跑通，
所以凡是它报出来的问题，要么是解析器读不懂的**合法 MoonBit**，要么就是真缺陷。
没有第三种可能。

结果：193/608（31.7%）读得懂，六处修复后 389/608（63.9%）；actionable 从
**588 降到 6**。

### 先 settle，再动手

六处里有一处的**根因是错的**，而且是我自己以为对了的那种。`data : &RuntimeViewNode`
里的 `&` 我一直当「引用类型」。`moon check` 说不是：

```
Error [4100] x : &Node
  ╰── The type Node is not a trait
Error [4091] x.n
  ╰── @moonbitlang/core/ref.Ref[Node] has no field n
```

`&T` 是 `Ref[T]`，而且 `T` 必须是 **trait**——moui 只在 trait 上写它
（`&RuntimeViewNode`），那才是能过编译的形状。修法因此不是「加个引用类型」，
而是在 `type_annotation` 里把 `&` 收掉、折进类型名，让 `ann_to_ty` 老老实实
返回 `TUnknown`（和 `Map[K,V]` 同一个答案）。

`~` 也是先 settle 才知道有两个面：编译器原话是
`The labels f~ are required by this function`（声明侧）与
`This function has no parameter with label x~`（调用侧）。

### 六处修复，各自的账

| 修复 | 形状 | 语料里的量 |
|---|---|---|
| `&T` | `Ref[T]` 注解 | 31 处 / 13 文件 |
| `~` | `label~ : T` / `x~` | 594 文件 |
| `fn[T]` | 类型参数 | 1563 处 / 266 文件 |
| `b"..."` | 字节串字面量 | 878 处 / 134 文件 |
| `{ ..base }` | struct update | 370 处 / 88 文件 |
| `.m(...)` | 行首点号续链 | 1124 行 / 131 文件 |

可读文件数逐条：193 →(`&`)195 →(`~`)313 →(`fn[T]`)342 →(`{..}`)373 →(`.`)389。

### 三条「读到了但丢掉」，不是三条规则

`b"..."`、`{ ..base }`、行首 `.m(...)` 链，这三处如果只把 token 吃掉，
会各自造出一个**新的假阳性**：链和 spread 里的实参是真实表达式，丢掉就等于
把「只在链里用过的参数」报成 unused。所以三处都保留了读：

- spread 的 base 以**空名**压进字段表——`walk`/`infer`/`interp` 三家都写成
  `let (_, v) = f`，只看值不看名，所以空名对它们不可见，而表达式活着，
  `self` 就还是被读到的；
- 行首链复用**真正的 postfix 构造器**（把 `parse_postfix` 拆出一个
  `parse_postfix_from`），链段于是成为 `EMethodCall`，实参自然在树里。

### 一处如实记账：`b"..."` 没有换来可读文件

改了之后 moui 的 parsed 数**一个没动**（342 → 342）。因为 `b"` 在 moui 里从来
不是任何文件的**第一个**错误，前面总有别的构造先挡住。这是个真的解析器缺陷
（突变验证证明：不修就会 `undefined variable 'b'` + `expected ')'`），只是
这一版语料上**测不出收益**。留着，账照实记。

### 突变验证里，脚本自己抓到了自己的错

12 道突变，11 道被杀。第 12 道（链的 rewind）**故意标成 SURVIVED**：把
`self.p = save` 去掉之后，cursor 停在分隔符之后——但外层语句循环本来就会再调
`skip_seps`，所以结果完全一样。那行是**防御性的**，没有任何测试或语料能区分它。
留着它（让循环自洽，而不是靠调用方兜底），但不假装它被覆盖了。

更值得记的是脚本自己出的错：第一版用 `Parse error` 判断 COMPILE-ERR，
结果它匹配上了我自己那条**名字里带 "parse error"** 的测试，把一道杀了 2 条
的突变报成「build 坏了，不算证据」。改成**用 `Total tests:` 行是否存在**来判断，
脆弱的探测器会把一个真修复挡在发布外面，这比没有探测器更糟。

`Buffer` 那道也先写了错版本：只让它出现在**类型注解**里，而 `.mbt` 前端对
未知类型名根本不开火——测试恒绿，突变 M12 活了。语料里真正的形状是
`Buffer(size_hint=12)`，**构造函数调用**。按语料改完才杀掉。

### 差分

| 语料 | 0.4.17 | 0.4.18 |
|---|---|---|
| `riantr/moonbit_labeler` 0.2.13 | parsed 18 / actionable 3 | **parsed 22 / actionable 3** |
| `riantr/moonbit_image` 0.3.7 | parsed 1 / actionable 0 | **parsed 1 / actionable 0（逐字节一致）** |
| `moonbit-community/proton` 0.3.4 | — | parsed 70 / actionable 45 |
| `moonbit-community/proton_contract` 0.3.4 | — | parsed 3 / actionable 1 |
| `moonbitlang/async` 0.22.4 | — | parsed 196 / actionable 30 |
| `wzzc-dev/moui` 0.1.12 | parsed 193 / actionable 588 | **parsed 389 / actionable 6** |

labeler 的 unreliable 从 612 降到 360，withheld 从 179 降到 146，actionable
一条没动——**只读得更多，没有新增判定**。moonbit_image 六项指标全部相同。

自检：54/54 文件读懂，`actionable=0`、`unreliable=0`、`withheld=0`。

（中途这里也出过一次真问题：加了 `TTilde` 之后自检冒出 2 条
`undefined name 'TTilde'`。不是代码错，是 `src/lexer/pkg.generated.mbti`
这个**被 git 跟踪的生成文件**没跟着更新——`moon update` / `moon doc` 都不会
重新写它。补进去之后自检回到 0。）

### 还没修的（都是 parser，行为上有意不改）

- `is` 打头的表达式（`f(x)` 换行后接 `is Some(_)`）会被读成裸名字 `is`，
  报 `undefined name 'is'`；`if x is Some(true)` 会把字面量 `true` 当成绑定名，
  报 `local variable 'true'`。两处共 3 条 actionable，都在
  `core/view_node_test.mbt` 一带。
- `impl ... with fn layout(self, context)` 里未标注类型的 `self` 报未定义，
  1 条。
- ~~三处 parser 补完之后 219 个文件仍读不到全文，主因还是 `unexpected token`。~~
  **已被实测取代（0.4.30）。** 这条一直没法落地，因为 `unexpected token` 什么
  都没说：它是 `parse_atom` 的兜底分支，消息里没有 token；而扫描器是**按原因
  消息**给读不动的文件分类的，于是 wzzc-dev/moui 0.1.12 的 122 个读不动的文件
  里有 110 个挤在同一个匿名行里。现在 `tok_desc` 会报出 token 本身（46 个 `Tok`
  变体全覆盖），同一次扫描变成 13 行分布，其余 SUMMARY 数字逐字节不变。
- **`a..<=b` 闭区间**：lexer 里原本有一条注释写着「`..=` 没有建模：当初加这个 token
  的时候没在受影响的语料里量到」。**写的时候是真的，再读的时候已经过期**，代价是
  moui 的 4 个文件。对着工具链逐个量（每个一个独立 package，旁边一个坏 canary）：
  `0..n` 被**拒绝**——"Missing `=` after `..` in range expression. Hint: use
  `a..<=b` for inclusive range or `a..<b` for exclusive"，`0..<=n` 通过，`0..=<n`
  被拒绝。所以闭区间写法是 `..<=`，而且裸 `..` 保持两个 TDot 是**对的**。
  四个字符的判断必须排在三个字符**前面**——顺序反了会把 `0..<=n` 切成 `..<` 加 `=n`，
  也就是工具链明确拒绝的那种形状。
  它是**独立 token**而不是复用 `TRange`：三个镜头（walk / types::infer / interp）
  对 `ERange(a, b)` 一视同仁，都只读两个操作数，**都不建模包含性**。所以包含端
  被**读到但不分析**，并且发出一条 notice——否则 `a..<=b` 和 `a..<b` 在树里
  完全一样，而「循环 n 次」和「n+1 次」不是可以默默丢掉的区别。
- 分布出来后按顺序修了最大的**九**类：调用处的 `?` 可选参数简写 `f(x?)`、把 lambda
  当作参数默认值、跨行的方法链、`match` 的被匹配表达式起自下一行、**表达式位置的
  箭头 lambda**、**`a..<=b` 闭区间**、**限定构造器 `is Type::Ctor`**、
  **括号内类型标注 `(expr : Type)`**、以及**空下标 `value[:]`**。
  moui **486/608（79.9%）→ 590/608（97.0%）**，`unreliable` 1696 → 246，
  `withheld` 238 → 2。
- **`is Type::Ctor`：又是一次排名排错，而且错法和前两次不同。**
  待办里写的是「`is` 模式出现在**表达式位置**」——照字面理解是 `parse_is` 没被走到。
  它走到了，而且在好几个版本之前就在正确的优先级层上。真正缺的是
  `parse_is_pattern` 内部：lexer 里**没有** `TColonColon`，`::` 是**两个** `TColon`，
  而模式读取器读掉构造器名字就返回了，没消费这两个冒号。漏掉的 `:` 一路退回
  `parse_cmp`，最后落在 `parse_atom` 的兜底分支——所以 scanner 的原因措辞是
  ``unexpected token `:```，出现在一行里**唯一的** `:` 是路径分隔符的地方。
  **这是「原因字符串不是原因」的第四次**，也是 `blockers.ps1`（把每条原因接回它的
  **源码行**）第四次给出相反答案。moui 正好 +5 个文件，和重新排序时点名的数量一致，
  没有多也没有少；proton 的 `parsed` 和 `actionable` 都没动，`unreliable` 950 → 927。
- **这一轮把我自己的排名推翻了两次，值得单独记一笔。** 前四个类别是按
  scanner 的**原因措辞**排的（`unexpected token ':'`、`expected ')'`），我把它
  读成了 `is` 模式和函数类型；实际把这些行一一对回源码之后，最大的一类根本不是
  它们，而是**箭头 lambda**：`(a, b) => …`、`(_n : T) => …` 在 `let` 右侧和
  **位置实参**上都读不出来。
  原因是三处 lambda 处理各管一段：`at_arrow_lambda`（只认裸 `x =>`）在位置实参
  分支上，`at_lambda_head`（认全部写法）只在 `name =` 之后，而 `parse_expr`
  一处都没有。于是 `g(a => a)` 能读、`g((a) => a)` 和 `let h = (a, b) => a + b`
  不能。**一个"原因字符串"不是原因。**
- 同一个 lambda 分支还带出两件事，都不是它自己造成的：
  1. **comprehension 自己的 `=>` 和 lambda 的拼写一模一样。** 三处调用点
     （iterable、guard、body）因此改走 `parse_or`；第一版忘了 iterable，
     五个 comprehension 测试当场变红。
  2. **`at_lambda_head` 里有一个能跨文件的盲扫。** 它把 `::` 当成参数类型标注
     的冒号，然后一路找下一个 `=`——而 `=>` 就是 `TAssign` + `TGt`。于是
     `T::{}` 后面只要隔几十行有任何一个 `=>`，整段就被当成一个巨大的 lambda
     头吃掉。**这个 bug 是自检发现的，不是测试**：`src/core/core.mbt` 和
     `src/lexer/lexer.mbt` 从 71/71 掉到 69/71，而 551 个测试全绿——因为没有任何
     一个测试让 `::` 表达式和 `=>` 同处一个文件。回归测试因此**成对**写。
- 修好盲扫之后，async 的 `actionable` 13 → 14、proton 54 → 61。**这 8 条不是
  新缺陷，是那个盲扫一直在藏的**：4 条 `undefined name 'noraise'`
  （proton 的 `fn f() -> T noraise {`）、3 条 `no visible binding for
  'InvalidSetting'` 和 1 条 `'Waiting'`（后 4 条是 suberror 变体跨文件，已列为
  长期项）。A/B 实测：护栏单独去掉**不会**出现（边界先停），边界单独去掉
  **也不会**出现（护栏先停），两个一起去掉才复现原来的 `PARSED 0/1`。
  **一个宽到能吞掉六十行外 `=>` 的前瞻不值得留着换这份安静。**
- `defer` 另修了一类**假阳性**而不是读不动的文件：没有这个 arm 时 `defer` 被当成
  普通标识符，报 `undefined name 'defer'`——这是**关于分析器的**错报，代码
  `moon check` 零错误。async **18 → 13**、proton **55 → 54**，同样是 A/B 实测
  （关掉 arm 重扫，7 条 `undefined name 'defer'` 全部消失，0 条新增）。
- proton 中途经过 55 → 56 → 54 → 61：`match` 那一步让一个本来读不动的文件变得
  可读，于是暴露出**更多**这类假阳性。**读入更多文件先让假阳性上升再下降，
  是这个指标正常的形状。**
- moui 剩下的 **27** 个。修完 `is Type::Ctor` 之后重跑了一次 `blockers.ps1`，
  重新排序的结果是：`(expr : Type)` 括号内类型标注 **6 个文件**（排第一）、
  `value[:]` 空下标 **4**、实参位置上的 `async fn(…)` **3**、
  `fn f() -> T = "js" "sym"` FFI 声明式 **2**，另有 5 个各 1 个的单点。
  我上一版清单里排第一的 `is`（当时记 4 个）实际是 5 个，而排第三的
  `(expr : Type)`（当时记 3 个）实际是 6 个——**清单又一次是按旧读法排的**。
- `name?=value` **判定完毕：不是缺口。** 探针里 `?=` 和 `~=` 都返回 MOON-BAD，
  也就是说工具链自己拒绝这种实参写法。与其为一种 `moon check` 都不接受的写法
  增加支持，不如把它记成「不是缺口」。
- **同一轮量出来一个 48 个 site、却只挡 1 个文件的缺口，值得单独记一笔。**
  `is @pkg.Type::Ctor`（包限定构造器）**根本读不出来**：模式头以 `@` 开头，
  而 `peek_name()` 只认 `TName`，于是读取器什么都没消费就返回了。
  全语料 48 处，moui 32 处、分布在 16 个文件里。把这 16 个文件**逐个单独扫描**
  （`_verify/pkg_head_impact.ps1`）的结果是：15 个能读，**只有 1 个真的被挡住**
  （`backend/macos/macos_services.mbt`）——另外 15 个的 site 都在被整块跳过的
  `test` 块里。**site 不等于文件**，按 32 来排就会把一个 1 文件的修复排到
  6 文件的修复前面。
  更值得记的是**它对排序工具也是不可见的**：把「含 `@pkg` 的文件」和
  `blockers.ps1` 的受阻文件表交叉比对，重叠是 **0**，看上去这个缺口不花钱——
  因为 `macos_services.mbt` 正是那 4 个「边界之前零发现、因而根本不打印 `PARTIAL`」
  的文件之一。`blockers.ps1` 自己的表头就写着这份表是**下界**，
  而这一次正好落在下界之外。⇒ **一个与「没问题」一致的下界，不构成「没问题」的证据**；
  两张表交叉比对，只知道**两张表都看得见的那部分**。
  作为 KNOWN LIMIT 连同一条去掉 `@sqlite3.` 前缀的对照测试钉在
  `parser_0436_test.mbt`，本轮不修。
- **括号内类型标注 `(expr : Type)`**：`parse_atom` 的 `TLParen` 分组分支读掉内层表达式
  之后直接要 `)`，六个受阻文件全部死在这里——`expected ')'`，而那一行的 `:` 是类型
  标注，不是笔误。修复范围由工具链划定，不是由方便划定（四种写法各一个 package，
  每个旁边一个坏 canary）：

  | 写法 | moon | |
  |---|---|---|
  | `('0' : Int)` | **MOON-OK** | 唯一合法的写法，已实现 |
  | `let y = 1 : Int` | MOON-BAD | 不加括号：被拒绝 |
  | `(1 : Int, 2)` | MOON-BAD | 元组元素上的标注：被拒绝 |
  | `(s : Int)`，`s : String` | MOON-BAD | 所以标注是**断言**，不是强制转换 |

  最后一行决定了**不发 notice**：0.4.30 里 `..<=` 因为同样「读到了然后丢掉」发了
  notice，可两者的结论相反——闭区间端点会把 n 次循环变成 n+1 次，**标注在运行时什么
  都不改变**（类型编译器已经查过了），在这里发子集排除 notice 等于报告一个并不存在的
  丢失。门禁 0437 的 M3 就是凭空造出那条 notice，它由一条**对照**（比较两种写法各自的
  report 条数）杀掉，而不是由正向测试杀掉。
- **这一轮头一次交付量低于清单的预测，值得单独记一笔。** 括号内标注在受阻清单里占
  **6 个文件**，实际只换来 **+2**。另外四个文件在**更早**的地方就失败了，修标注根本
  走不到它们——这就是「`blockers.ps1` 按**首个**错误排序」的含义。三个增量连续三次
  清单数与交付数不一致（`is` +5 对 +5、`..<=` +5 对 +4、标注 +2 对 +6）。
  ⇒ **清单里的行数不是预测值**，按它排序是启发式，不是测量。实际交付：
  `is` +5、`..<=` +5、标注 +2——**并不保持清单给出的顺序**。moui 的
  `unreliable` 406 → 335、`withheld` 51 → 34，`notices` 3999 → 4050（方向是对的：
  能解析的文件才会产生子集排除 notice，读不下去的文件产生不了）。其余五个语料
  **逐字节不变**。moui 剩下 **25** 个受阻文件。
- **空下标 `value[:]`**：本轮最大的一跳，也是**头一次付出代价**的一跳。
  `parse_postfix_from` 的方括号分支先用 `parse_expr()` 读**起始**下标，之后才问
  `at(TColon)`；于是紧跟在 `[` 后面的 `:` 被交给了表达式解析器，文件死在
  ``unexpected token `:` ``——那是受阻清单里 8 个文件的原因措辞，而这 8 处的 `:`
  全都是下标分隔符。源码里那条注释当时写着开头的 `[:n]`「不在语料里，老实报错」，
  `chars[:index]` 让它过期了，而「老实报错」其实是在给一个 blocker 化妆。
  缺失的下标用 `EBigInt` 这个不透明占位（和已有的开尾处理一致），因为
  `const_eval` 不能折叠一个它从没读到过的界。
  moui **583 → 590（+7，本轮最大）**，`unreliable` 335 → 246，`withheld` 34 → **2**，
  受阻文件 25 → 18；proton 101 → 103，async 226 → 227。
- **但 moui 的 `actionable` 0 → 1、proton 61 → 63——这是本轮第一次「多读文件
  抬高了 actionable」。** 不是回归，也不是白得的，逐条交代：

  | 语料 | 新发现 | 已记录的局限 |
  |---|---|---|
  | moui | `macos_native_ime.mbt:437` `parameter 'prefix' may not be used` | `prefix` 确实在 **442 行**用了，在 `catch { }` 块里；`catch` 分支用 `skip_braces` 整块跳过，所以只在那里的读看不见（KNOWN LIMIT，钉在 `parser_0432_test.mbt:155`） |
  | proton | `app_control.mbt:5` `undefined name 'noraise'` | `parse_raise_effect` 只处理 `!` 和 `raise E`，不处理 `noraise` |
  | proton | `updater/hex.mbt:22,45` `no visible binding for 'MalformedSignature'` ×2 | suberror 变体跨文件使用——per-file `enum_ctors` 局限 |

  三条都是**分析器自己的既有局限**、都作用在 `moon check` 接受的代码上，都不是空下标
  这个改动造成的（改动只是让这些文件读得下去了）。这就是 README 早就写过的形状：
  **读入更多文件先让假阳性上升再下降**。但 moui 的 `actionable` 毕竟是**头一次离开 0**，
  而它正是这条长期目标的指标，所以 pin 带着理由上移，而不是悄悄上移——把 `catch`
  块那条局限修掉是把它放回去的路，也因此成了板上最便宜的一件事：发现已经定位，
  缺陷已经钉成测试。
- `_verify/blockers.ps1` 排的是**读不动的文件**，`_verify/backlog.ps1` 排的是
  **子集排除 notice**。两者回答的不是同一个问题，混为一谈正是这条在十四个版本
  里一直没法处理的原因：只有前者会推动 `parsed=` 这个数字。

## 0.4.17 —— 11 → 9：一条的根因是「上一版把探针写坏了」，另一条是「读到了却丢掉」

0.4.16 剩 11 条。这轮回头查了 0.4.16 判定为**不可观测**、因而撤回的那条
`Array::make`。结论是：**不可观测的原因是探针有缺陷，不是规则有问题。**

### `Array::make`：探针从来没调用过那个函数

behavior 镜头只分析**被到达**的函数体——顶层语句调用得到才算。
`rasterizer.mbt` 在 **1378 行**调用了 `PixelBuffer::new`，而 0.4.16 的每一个
探针都只抄了定义、没抄那个调用。于是规则「改了没变化」是必然的：它压根没跑。

补上调用后复现了，然后发现**第二件事**，而且它推翻了当初的读法：

| 探针 | 结果 |
|---|---|
| 顶层可达，真实那行 | 报 `Byte::default` |
| 去掉顶层调用 | 完全静默 |
| `Array::make` 单独调用 | **被报** |
| `Byte::default` 单独调用 | **被报** |
| 外层也不存在 + 内层 `Byte::default` | **只报内层** |

最后一行是重点：**一个调用一旦报错就返回 `ABottom`，外层调用不再被访问**。
所以嵌套链只报最内层那个名字。当初把「加了 `Byte::default` 就露出
`Array::make`」读成「打地鼠、没有终点」是错的——那是一层**掩盖**被揭开，
不是一张无穷长的清单；调用者都认识之后，家族就终止了。

### 为什么是表，不是规则

规则版本是「限定在内建类型上的调用一律是内建方法，不报」。反向对照判了它：

| 写法 | 结果 |
|---|---|
| `Array::make(4, 0)` | 静默（名字在表里） |
| `Array::mkae(4, 0)` | **被报**（名字不在表里） |

规则版本会把两个都静音。所以 `src/core/builtin_methods.mbt` 是**生成的表**：
656 个名字，642 个读自工具链自己的 `moonbitlang/core/**/pkg.generated.mbti`，
剩下 14 个编译器内建（`Array::make`、`Map::new`、`StringBuilder::new` …）
**没有任何接口声明**，逐个用 `moon check` settle——一个探针文件把它们全部
裸写调用，旁边放一个不可能存在的控制名，工具链只标了控制名。

生成脚本随仓库发布在 `tools/gen_builtin_methods.ps1`，它自己会跑 `moon fmt`。
它必须在仓库里而不是临时目录里：`builtin_methods.mbt` 的头写着「不要手改」，
一张**生成器没进仓库**的表会静默腐烂——下一个 MoonBit 加了方法，没人生成，
分析器就又开始把真实的内建调用报成未定义。
这个表是 `builtins.mbt` 那张 ambient 表的一部分，而那张表的头注释早就写明：
**每次使用都只会漏报，绝不会凭空造出误报**——这就是为什么它可以是数据。

### 顺带证伪了 0.4.16 的一条结论

0.4.16 的测试写着「限定名调用不上报，是过度报告的镜像，一个已知缺口」。
**假的。** 那个 fixture 是 `fn f() -> Int { Nope::also_missing() }`，而 `f`
**从来没被调用过**——和 `Array::make` 那个探针是同一个缺陷。把 `let top = f()`
加上去，同一个名字立刻被报出来。

真实原因有两条，叠在一起看着像一条：behavior 镜头需要函数体被到达，而 type
镜头**根本不把 `::` 名当类型引用**。测试已按实际行为重写。

### `Select`：同包兄弟文件里的枚举变体

`canvas_view_test.mbt:4917`：

```moonbit
fn every_mode() -> Array[Mode] {
  [Select, Rect, Polygon, Keypoint, EditBinding]
}
```

`Mode` 和五个变体都在**同一个包目录**的 `app_moui/app.mbt:23`。而
`collect_declared_names` 只收**顶层关键字**后面的名字——枚举变体在花括号里，
被 depth-0 规则跳过了。这是 0.4.15 用 path 尾部兜底解决的同文件问题的**跨文件
孪生体**：带路径的 `Mode::Select` 走得通，裸写的 `[Select, ...]` 走不通。

修法是进 `enum` 体收割变体名，但**载荷类型不算变体**，否则
`Conv2d(Params)` 会让 `Params` 变成包可见，静默掉别的文件里一条真发现。
所以规则是：行首（或紧跟 `{` / `,` / `|`）**且不在括号内**。

（顺带一个实测：`enum E { A B }` 这种空格分隔的写法是**语法错误**，
`moon check` 报 `expect ; or }`。测试最初按合法写了它，跑出来是红的——
于是去问工具链，而不是去猜语法。）

### 差分：933 个文件里只有 2 个文件的判定变了

| 语料 | 0.4.16 | 0.4.17 |
|---|---|---|
| `riantr/snn_mbt` 0.155.0 | 6 | **6**（全真阳性，未动） |
| `riantr/moonbit_doubleML` 0.139.0 | 0 | **0** |
| `riantr/moonbit_labeler` 0.2.13 | 5 | **3** |
| `riantr/moonbit_image` 0.3.7 | 0 | **0** |
| `riantr/pyroduct` 0.1.29 | 0 | **0** |
| 合计 | 11 | **9** |

逐文件比对：只有 `rasterizer.mbt` 与 `canvas_view_test.mbt` 的判定变了，各减
**恰好 1** 条 actionable，两者的 notice 数（1 / 175）**一条未动**。其余 931 个
文件逐字节一致。两处改动都是外科手术级的。

labeler 剩下的 3 条是 `@core.SurfaceMetrics::new` ×1 与 `@core.Size::new` ×2，
属于 0.4.16 已经定过的「调用方式」——加 `--extern-iface-dir .repos` 就没有。

测试 js 286 / wasm 358 / wasm-gc 286。七道防护做了突变验证，全部杀死。其中
**两道专门用来测形状而不是测数值**：M3 往表里塞一个不存在的名字（`Array::mkae`），
反向对照必须变红；M4 把 0.4.16 那个**规则**装回去替代表，8 个测试变红——
「表优于规则」是实测出来的，不是风格选择。

## 0.4.16 —— 19 → 8，其中 6 条是真阳性：先承认「对」，再修剩下的错

0.4.15 剩 19 条。这轮先做了一件上一轮没做的事：**逐条判定哪些是真的**。

结果是 6 条**真阳性**——分析器是对的，代码确实有问题：

| 位置 | 发现 | 判据 |
|---|---|---|
| `neuron_identity.mbt` | 参数 `dt` 从未被读 | 读源码确认函数体里没有 `dt` |
| `dsac.mbt` ×2 + 3 个 `examples/*/main.mbt` | `for a in 0..<n` 的绑定变量 `a`/`s` 从未被读 | 同上；探针确认 `moon check` 对未读的 for 绑定变量**也**告警 |

外加 3 条**不是缺陷**：`labeler` 里的 `@core.SurfaceMetrics::new` 等 3 条，
分析器自己就打印了 `FETCH ... pass --extern-iface-dir .repos to index their
interface names`。加上这个参数重扫，`labeler` 从 5 条降到 2 条。**那 3 条
本来就不是 bug，是调用方式。**

真正修掉的 9 条，成因只有一个共同点：**信息已经读到了，却被丢掉或没用上。**

| 成因 | 条数 | 位置 |
|---|---|---|
| 跨包 `const` 被当成**函数** | 4 | `IfaceSymTab.values` 的 `Bool` 一直写 `true`、没人读 |
| 带花括号的 `suberror` 体被当成表达式 | 4 | 一律走「跳到行尾」的 skip |

（第三条 `Byte::default` / `Array::make` **没有修**，原因见下面「改完又撤回」。）

### 跨包 const：`3.0F * hz` 被报成 `'float' 和 'fn hz'`

```moonbit
// snn_mbt/istdp.mbt
r: 3.0F * hz,   // hz 是 @snn_kw 的 const hz : Float
```

`.mbti` 读取器**已经分得清** `const` 和 `fn`——它对两者匹配的前缀不同——
然后把区别扔了，因为两条分支都只产出一个裸名字。`IfaceSymTab.values` 的
`Map[String, Bool]` 里那个 `Bool` 一直在写 `true`，从来没被读过。现在它是
`is_const`，`merge` / `union` 也跟着透传。

反例对照（必须有）：跨包的**函数**仍然返回 `TUnknownFn`，不能一起降级成
`TUnknown`——那会让调用处理器跑去检查一个凭空编出来的参数个数。

### 带花括号的 suberror

`suberror` 有两种写法：`suberror Timeout of String`（一行）和
`pub suberror DecodeError { ... }`（带体）。原来**一律**走「跳到行尾」，
于是带体的那种跳到换行就停了，剩下的 `{ ... }` 被当作表达式块解析，
里面的载荷类型一个个变成 undefined name——`moonbit_image/types.mbt` 里
`String` 报了 4 次。

现在按关键字后面**实际跟的是什么**分流，扫描边界固定在 8 个 token
（`suberror X of T` 的头部不会更长），避免把后面某个声明的花括号
误认成自己的。反例对照：不带体的 suberror 必须照样解析，且它**之后**的
函数仍然存在。

### 一个反向的发现：这个分析器漏报

`Nope::also_missing()` 这种**限定名调用在被调用方解析不出来时，完全不报**。
这不是本轮引入的，是上一轮修掉的过度报告留下的镜像：

> 限定名一度被**过度**报告（`Layer::ReLU`、`fn hz`），修完之后它们变成了
> **报告不足**。

我把这条写成了断言**当前行为**的测试，并标注 KNOWN GAP——不是断言一个
还不存在的发现（那会让每个版本都卡在一个没人评估过的问题上）。

要往正确的方向走，得先把「接收者类型」和「包别名」区分开，这轮没做。

### 改完又撤回：`Byte::default` / `Array::make`

`labeler` 的 `rasterizer.mbt:74` 是一行：

```moonbit
let pixels : Array[Byte] = Array::make(total, Byte::default())
```

分析器把其中一个被调用方报成 `undefined function`。我按探针结论
（`Byte::default()` 编译 0 错误 0 警告）把 `Byte::default` 加进内建表——
**结果只是把底下的 `Array::make` 露了出来**，同一行。

这说明「一个名字一个名字补」是打地鼠，没有终点。于是改成按家族判定：
**限定在内建类型上的调用（`Array::`、`Map::`、`Int::`）一律不当未定义**——
分析器本来就没有内建类型的方法表。

**这条改完又被撤回了。** 五道突变里它占两道，两道都存活（关掉它、让它永不
匹配，整个套件照样全绿）；在一个手搭的探针上——完整文件和故意做成 partial
的文件各一次——开关它输出**逐字节相同**。

而语料里那条发现的形状我复现不出来：`undefined function` 这个串在本文件
里只被构造一次，而我改的那处根本走不到。**在证明不了的前提下静音一整族调用，
和当初制造这批误报是同一类错误。** 理由写在 `interp.mbt` 那条上报旁边。

### 结果

| 语料 | 0.4.13 | 0.4.14 | 0.4.15 | 0.4.16 |
|---|---|---|---|---|
| `snn_mbt` | 33 | 19 | 9 | **6**（全真） |
| `moonbit_doubleML` | 28 | 3 | 1 | **0** |
| `moonbit_labeler` | 6 | 5 | 5 | **5**（加 `--extern-iface-dir` 为 2） |
| `moonbit_image` | 4 | 4 | 4 | **0** |
| `pyroduct` | 0 | 0 | 0 | **0** |
| 合计 | 71 | 31 | 19 | **11** |

剩下 11 条里 **6 条是真阳性**，3 条是调用方式，另外 2 条在 `labeler`
（1 条已修的 `Byte::default` 同类，1 条被 stdout 截断看不到）。

测试 js 270 / wasm 342 / wasm-gc 270（新增 8）。四道突变全部杀死，
restore 后 SHA256 逐字节一致；自检 52/52、actionable=0。

## 0.4.15 —— 剩下 30 条里的 12 条：三个成因，其中一个差点把整条规则静音

0.4.14 把四个语料的 actionable 从 71 降到 31。**其中 1 条是真阳性**
（`neuron_identity.mbt` 的 `dt` 参数确实没被读，编译器也会警告）——第一次在
这套语料里找到真的。其余 30 条继续归因，三条成因占了 12 条。

| 成因 | 条数 | 判据 |
|---|---|---|
| `extern "C"` 的参数被判「未使用」 | 6 | 探针：extern 不告警，同文件的普通 fn 告警 |
| `Bool == Bool` 被判「不支持的操作数」 | 2 | 探针：0 error 0 warning |
| 单元（无载荷）枚举变体读不到 | 4 | 探针：0 error；同 enum 的带载荷变体本来就正常 |

### 单元变体：同一文件里，带载荷的能读、不能带载荷的读不到

```moonbit
enum Layer {
  Conv2d(Conv2dParam)   // 能读
  ReLU                 // 报 undefined name
}
```

不是「enum 没被采集」。采集器确实把两个名字都收进了模块帧，但存的是**裸名**
（`ReLU`），而引用写的是**整条路径**（`Layer::ReLU`）。`Layer::Conv2d(p)` 是
**调用**，调用路径另有兜底；`Layer::ReLU` 是**裸引用**，没有。

修法是给整条路径一次尾部兜底（`@core.path_tail`），**只在整条路径已经解析失败
之后**才走，所以不可能把能解析的名字变成解析不了的——只可能救回尾部真有东西的
路径，那正是单元变体。

配套的反向对照：`Colour::Purple`（从未声明）仍然必须报错。否则每个语料里拼错的
枚举路径都会被静音。

### 「函数体是空的」不能当 extern 的代理

直觉是：extern 函数没有函数体，所以「体空 ⇒ 不审计参数」就够了。探针否掉了它：

| 写法 | `moon check` |
|---|---|
| `extern "C" fn expf(x : Float) -> Float = "expf"` | 静默 |
| `fn p7(z : Float) -> Float { }` | **告警** |
| `fn p6(y : Float) -> Float { 1.0 }` | **告警** |

所以必须由 parser 显式记录 extern 函数名（`ParseResult.extern_fns`），
跟 `enum_ctors` 同一个套路。

### 结果

| 语料 | 0.4.13 | 0.4.14 | 0.4.15 |
|---|---|---|---|
| `snn_mbt` | 33 | 19 | **9** |
| `moonbit_doubleML` | 28 | 3 | **1** |
| `moonbit_labeler` | 6 | 5 | 5 |
| `moonbit_image` | 4 | 4 | 4 |
| `pyroduct` | 0 | 0 | **0** |
| 合计 | 71 | 31 | **19** |

`snn_mbt` 少了 10 条、`doubleML` 少了 2 条，正好等于两条成因各自的计数；
`labeler` 和 `moonbit_image` 没动，因为它们的成因是另外两条（`@core.X::new`
这类跨包构造、`Byte::default` 这类内建缺失，以及 `suberror` 体被二次扫描）。

测试 js 263 / wasm 335 / wasm-gc 263（新增 7）。五道突变全部被杀死，restore
后 SHA256 逐字节校验通过；自检 51/51、actionable=0。

### 突变脚本自己踩的第三个坑

替换文本写成了 PowerShell 的 `$true`，而 MoonBit 里没有这个语法。两道突变因此
**编译失败**，脚本把它们报成 `COMPILE-ERR`——和「套件抓到」长得一样，其实
什么都没抓到。**一种不能编译的突变，和一种成功杀死的突变，在报告里必须分开。**

## 0.4.14 —— pyroduct 的 0 不是「对」：换四个语料，一次挖出三个真缺陷 + 一个静默错误

0.4.13 把 pyroduct 的 actionable 清到 0，**但那是 pyroduct 恰好没踩到，不是分析器对**。
这次把同一分析器指向另外四个已发布模块（`snn_mbt` / `moonbit_doubleML` /
`moonbit_labeler` / `moonbit_image`，共 933 个文件），立刻出现 **71 条 actionable**。

| 成因 | 条数 | 判据 |
|---|---|---|
| `F` 后缀浮点字面量 `0.0F` 未建模 → `undefined name 'F'` | 28 | `moon run` 确认合法；`7F` 才是语法错 |
| `/` 被当成浮点除法 → `cannot assign 'float' into '[int]'` | 14 | `7 / 2 = 3`，**不是** 3.5 |
| 指数记法 `1.0e-12` 未词法化 → `undefined name 'e'` | 14 | `moon run` 确认合法 |
| `suberror` 体被二次扫描 → `undefined variable 'String'` | 4 | 同一行已报 ParseError |

**68 条逐条复核，0 条是真阳性。**

### 还有一个不产生任何发现的缺陷

改的过程中，探针发现一个比上面四条都更糟的东西：

```
1.5 -> 1 | 0.25 -> 0 | 3.14159 -> 3
```

**每个浮点字面量都丢掉了小数部分。** `lexer.mbt` 里 `int_part` 在消费小数**之前**
就取好了值，之后 `slice(start, int_part)` 于是只切到整数部分。

它一直没被发现，是因为既有测试只断言 token 的**种类**是 `float`——被截断的值同样
满足。**一条不产生任何发现的缺陷，会让分析器对读到的每一个浮点都静默地错。**
新测试因此改为读**值**和**token 数**。

### 实测过的修法，以及一条实测后**撤回**的修法

`walk.mbt` / `interp.mbt` 里 `/` 的常量折叠与结果类型同样与 MoonBit 事实不符
（`OpDiv => None`、`AType("float")`）。三处都改对之后：

- 五道突变里，这三道**全部存活**（改回去套件照样全绿）；
- 在 933 个文件上做差分扫描，**两次的报告流逐字节相同**。

也就是说常量求值层今天根本到不了任何一条输出的发现。按本项目「不可观测的分支
一律不提交」的口径，**这三处改动已撤回**，理由写在了 `walk.mbt` 和 `interp.mbt`
的注释里。声称一个无法证明的修复，比留着一处已知但暂时无害的写法更糟。

### 结果

| 语料 | 文件 | 可解析 | actionable |
|---|---|---|---|
| `riantr/snn_mbt` 0.155.0 | 673 | 234 → **603** | 33 → **19** |
| `riantr/moonbit_doubleML` 0.139.0 | 205 | 145 → **165** | 28 → **3** |
| `riantr/moonbit_labeler` 0.2.13 | 37 | 16 → 18 | 6 → **5** |
| `riantr/moonbit_image` 0.3.7 | 18 | 1 | 4 |
| `riantr/pyroduct` 0.1.29（不回退） | 119 | 103 → **104** | **0** |
| 合计 actionable | | | 71 → **31** |

测试 js 256 / wasm 328 / wasm-gc 256（新增 16）。五道突变全部被杀死，restore
后逐字节校验与运行前一致。

### 顺带修掉的两个自伤

验证脚本本身在这次迭代里咬了两次：

1. `Get-Content -Raw` 在中文 Windows 上按 GBK 解码 UTF-8，把注释里的 `—` 写成
   `鈥?`，**并且吞掉了后面的换行**，把两行注释并成一行。现已改为按字节读、并用
   SHA256 证明 restore 与运行前逐字节一致。
2. 差分脚本里 `"$v_"` 被 PowerShell 解析成**名为 `v_` 的变量**（空），两次扫描
   写进同一个文件、后者覆盖前者，于是「变体 A 和变体 B」变成了自己和自己比，
   报出「完全一致」。现在用 `${v_}`，并在比较前断言文件存在——两次读取都失败
   曾经被当成「相同」。

判据：**比较两个结果之前，先证明两个结果都存在。**

## 0.4.49 —— 安全讲义的第四章拿到了自己的家族；而它的另外三章被数了出来

**本版包含什么。** 第三份课件 `13_Security.pdf`（*Static Analysis for Security*，Tian Tan，
南京大学，86 页）对着本仓库逐格读了一遍。四章：信息流安全、机密性与完整性、显式流与隐蔽
信道、污点分析。三个增量把它关掉，而它们是三种不同的东西。

| 增量 | 是什么 | 会走到用户的报告里吗 |
|---|---|---|
| 0586 | 污点层——讲义第四章，就建在本仓库已有的指针分析上 | 不会——库级测量 |
| 0587 | 发现族 `MSA-018 TaintFlow`——讲义的三元组，变成一条报告 | **会** |
| 0588 | 讲义另外三章：被数出来，而不是被描述 | 不会——但它把边界钉住了 |
| 0589 | 装文档的脚本跑了两次——修掉，并且钉住 | 不会——门禁长出一道检查 |

### 污点分析是建在指针分析之上的，因为讲义自己就是这么说的

讲义 p.70 决定了这东西长什么样：**「Taint and Pointer Analysis, Together」**。所以这里
**没有第二套指针分析**：种子是**每个源调用点多出来的那一个对象**，而讲义自己的四条规则
（p.75：New、Assign、Store、Load）就是本仓库已经在实现的那四条，**在一处**，而这里是
**调用**它们而不是抄一份。

讲义自己的例子被逐字复现：

    讲义 p.84   TaintFlows: { <3,7,0> }    本仓库   flow <3, 7, 0>

### 这些流现在有了一个族：`MSA-018`，`TaintFlow`，严重度 Error

族表里的**第十八个**，也是本仓库第一个**主张是一条流**而不是一个位置的族。它**坐在汇上**，
因为汇调用才是读者要看的地方，而且源也被点了名：

    the sensitive argument 0 of 'log' may receive tainted data from 'get_password'

源和汇是**参数**，不是内置名单：`--taint-source <fn>` 指出一个结果就是污染数据的函数，
`--taint-sink <fn>:<idx>` 指出一个汇和它敏感参数的**下标**——`log:0` 就是讲义自己的
`<log(String), 0>`。写坏的汇被**拒绝**而不是丢掉，因为丢掉的汇会扫完整个程序然后什么都不
报，那看起来和一个干净的程序一模一样。

### 讲义自己第二章的那个注入例子不会被报出来——这是实测的

讲义完整性那张幻灯片（p.40）写着整章要讲的形状，p.41 点名了它：**「注入错误（2013-2019
年漏洞的第一号成因）」**。三行，第三行是对照：

| 讲义那个程序 | 会报吗 |
|---|---|
| `cmd = "..." + x;`——拼接 | **不会** |
| `cmd = "..." \{x};`——插值 | **不会** |
| 把派生值去掉 | **会** |

所以这个零说明的是**派生值**才是分析不跟的那一步，而原因是指针分析自己的表达式模型：拼接
**新分配**一个字符串，而带插值的字符串带的是**引用**而不是对象，所以污染数据进不去派生
变量的指向集合。讲义自己的规则表（p.75）有四条规则，其中没有一条是关于派生值的。这个形状
并不罕见：在七个固定语料上有 **827** 处把一个调用的结果带进字符串——**314** 处拼接、**513**
处插值。

**能关掉它的那条规则被点了名，而没有被做掉。** 它是*「派生自污染数据的值带着污染」*，
它属于**污点层**而不属于指针分析——那会让污点分析比讲义的四条规则**宽一条**，也会改变这个
工具对自身的声明。它写在这里，而没有被做掉。

### 另外三章是被数出来的，不是被描述的

第一章的安全级别在这里是一个**两层**格，而讲义给了**五层**（p.28），所以本仓库回答了讲义的
问题，但只覆盖它五层里的两层。第一章的非干扰性是一个**关系**性质——两次运行之间的比较
——而本仓库的每一个分析都是**单次运行**的 may 分析：那是**另一类**问题，不是一个更小的
问题。第三章的四条隐蔽信道则是**按讲义自己的决定**不做（p.61-62）。

### 还有一个文档流程上的缺陷被找到并钉住了

写增量说明的安装脚本在同一个文件上**跑了两遍**：一个族的边界文本里那段话出现了**两遍**，
而两章**丢了 `## ` 标题**，渲染成了正文。第一处就地修好，第二处也修好，而且发布门禁的
第 9 节现在会数标题和重复的句子——这样一条纯文字的缺陷就不可能再留在树里而不被门禁说
出来。两个方向都实测过门禁会变红。

### 实测

本仓库自己的源码 244 → **249** 个文件，汇总 notice 1,757 → **1,788**，而逐行打印的**一半
没有动**（仍是 157）；八个树合计 23,259 → **23,290**，拆分为 3,971 + 19,288 →
**3,971 + 19,319**；族表 **17 → 18**；测试 wasm 1,625 → **1,652**，js 与 wasm-gc 1,483 →
**1,510**。七个固定语料**一个都没动**。

### 已发布

0.4.49 已在两个远端打上 tag `2d30afb`，CI 的 `gate` 与 `publish` 在该提交上都是绿的，GitHub
Release 已发布，注册表以 `latest_version = 0.4.49` 提供它。

    published 0.4.49  wasm 17002698...  706965 bytes  checksum 5c19e207...  2026-11-15T04:01:06Z

**已发布的字节是干净的。** 用发布坐标实测：注册表提供的产物扫自己发布的源码，**248/248**
个文件解析，`actionable=0`，且恰好需要那 93 个约定的宿主符号，没有 `moonbitlang/async` 依赖。

**而这一版，已发布的产物真的变了。** 逐字节实测：0.4.48 是 685218 字节，0.4.49 是 **706965**
——产物**长大了 21747 字节**，而且公共前缀的 685218 字节里有 598761 字节不同，因为代码变大时
wasm 的布局会移位。这和 0.4.48 那次正好相反——那一次两个产物只差一个字节。

**原因在于污点层从报告流水线里可达**，这也是 0.4.48 的四个增量和这两个增量的差别，而它是按
非测试调用点实测出来的：

    src/flow/taint.mbt          非测试调用方: src/pipeline/taintcheck.mbt
    src/pipeline/taintcheck.mbt  非测试调用方: src/pipeline/pipeline.mbt,
                                               src/report/predicate.mbt

0.4.48 的四个新模块**没有**非测试调用方，所以发布版 wasm（它是不带测试文件构建的）不携带它们。
这两个有，所以产物携带它们，也所以它变大了。

**而且已发布的产物会报出新家族**——在发布坐标上实测：带上 `--taint-source readInput
--taint-sink log:0`，发布的 0.4.49 报出

    12:3 - error: the sensitive argument 0 of 'log' may receive tainted data from
           'readInput' (TaintFlow) [structural, MSA-018, high]

而**同一个**已发布产物在**同一个**程序上不带那个规格时报 `actionable=0`。上一个版本则干脆
拒绝这个问题：发布的 0.4.48 回答 `ERROR unexpected extra argument: readInput`。

## 0.4.50 —— Datalog 那份讲义：引擎进了这棵树、讲义自己的规则跑起来了，而且跑起来在引擎里找出了一个分层 bug

**这次发布是什么。** 第四份南大讲义 `14_Datalog.pdf`（*Datalog-Based Program Analysis*，谭添，
南京大学，93 页）被逐格对照这棵树读完。四个增量关掉它，而这四个是四种不同的东西。

| 增量 | 是什么 | 会不会走到用户的报告里 |
|---|---|---|
| 0592 | Datalog 引擎和读取器——讲义的语言（p.18-59） | 不会——这是库层的能力 |
| 0593 | 讲义的指针规则，跑起来并与 `pta_run` 对拍 | 不会——这是一次测量 |
| 0594 | 讲义的污点规则，跑起来并与 `taint_analyze` 对拍 | 不会——而且它们找出了一个 bug |
| 0595 | 讲义第一章被数清楚，最后两页被核对过 | 不会——它钉住的是边界 |

**没有新的发现家族。** 讲义的规则被读进来、跑起来，答案与这棵树本来就给出的答案对拍——这是对
讲义主张的一次测量，不是对它的第二份实现。名册仍然是十八个家族。

### 讲义的规则是文本，而且往返一致

用代码写出来的规则，是命令式形式戴了一顶帽子。而**文本**形式的规则可以被读、被打印、被拿来和
幻灯片比对，而且往返是钉住的：读取器解析出来的，正是打印器写回去的，逐字节相同。

    讲义 p.70   VarPointsTo(x, o) <- New(x, o).
    本树        同样那四行，解析之后，打印回来还是同样那四行

而且引擎就在这棵树里，因为 p.92 的第三条优点——「Benefit from off-the-shelf optimized Datalog
engines」——在这里并不成立，而它不成立的理由是可以测量的：这棵树有自己的引擎，而拥有引擎让
它付出过一个 bug。

### 指针规则的答案与这棵树本来就给出的答案一致

讲义的四条规则（p.70）跑在讲义自己的程序上，算出来的 points-to 集合与这棵树 `pta_run` 在同一
个程序上给出的完全相同：

    p -> {o1}   q -> {o1}   x -> {o3}   y -> {o4}      两种读法一致

**而它们不一致的地方被点名了**，因为这两个关系本就不是一回事：讲义的 `FieldPointsTo` 装的是
**一个字段指向的那些指针**，而 `pta_run` 的字段单元装的是**一个字段里装着的那些值**。两者各自
对自己的关系都是对的，而对拍会把两个答案都印出来，而不是挑一个。

### 而且污点规则在这个引擎里找出了一个真 bug

这才是要紧的部分，因为这个增量本来是要**加**一个能力，结果它找出了一个**缺陷**。分层排序的循环
拿**谓词**的个数去和**分组**的个数比较——两个不同的东西——于是在一个「三个 IDB 谓词、两个分层」
的程序上，它提前退出，第二个分层**从未被求值**，`TaintFlow` 那条规则根本没跑过。

**这个症状从答案上看不出来。** 程序确实推导出了 `VarPointsTo(s, t3)`——污点数据**确实**到了汇的
参数——却从中**没有**推导出任何流。关系是对的、规则是对的、程序是对的；缺的是一个分层。唯一
找出它的事情，是把讲义自己的规则跑起来。

**而修法被一行钉住，而且那一行被证明真的会亮**：把 bug 放回去，测试套件在三行上变红，文件随后
按字节还原。

### 讲义的第一章是被数出来的，不是被转述的

讲义第一章（p.10-12）印出带工作表的命令式 `Solve(main)`，并问出命令式形式没有回答的问题。这
张清单是**逐页增长的**，到 p.12 一共**五条**——第五条「How to connect PFG nodes and pointers?」
很容易漏掉，而这个增量的第一版数成了四条。

**答案不是「声明式形式没有实现细节」。** 在这个工具自己的引擎上实测：声明式形式关掉了讲义五个
问题里的**四个**，留下**一个**——points-to 集的存储方式，正是讲义自己那句「Hash set or bit
vector?」。这个引擎把元组存在一个**哈希集合**里，键是带长度前缀的元组键——所以讲义的问题在这
里被回答成：点名采用了讲义自己给的两个选项中的哪一个；而键的单射性是被测出来的，不是被断言的。

**而「Cannot fully control performance」正是讲义 p.92 自己那条 cons**，这个树已经为此付过账：
0594 那个分层排序 bug 就是这个答案的价钱。

### 那些测量

### 那些测量

    引擎                 src/flow/datalog.mbt、datalog_parse.mbt
    指针读法             src/flow/datalog_pointer.mbt
    污点读法             src/flow/datalog_taint.mbt
    讲义第一章           src/flow/datalog_deck.mbt

    讲义的规则，读       指针规则（p.70）和污点规则（p.91）逐字往返：幻灯片印什么，
                         打印器就印什么
    指针规则，跑         p -> {o1}  q -> {o1}  x -> {o3}  y -> {o4}——与 `pta_run` 在讲义
                         自己的程序上给出的同样四组 points-to 集
    污点规则，跑         TaintFlow(3, 7, 0)——安全讲义 p.84 印出的那个三元组，两种读法
                         一致
    讲义的五个问题       四个关掉，一个还开着——而开着的那一个正是讲义自己的「Hash set
                         or bit vector?」
    讲义的 p.92          三条优点、两条缺点；其中一条优点在这里**不成立**
    讲义的 p.93          三件事，每件都写明做它的那个增量

而移动的这些 pin 全是这次发布自己的源码，七个语料没有动：

    own-source files         249 -> 258
    own-source notices     1,945 -> 2,013
    own-source printed       157 -> 157   (UNCHANGED)
    own-source aggregated 1,788 -> 1,856
    the eight-tree total   23,290 -> 23,358
    the eight-tree split     3,971 + 19,319 -> 3,971 + 19,387
    the test counts         1,652 -> 1,699 on wasm, 1,510 -> 1,557 on js and wasm-gc

### 这份讲义被覆盖了

p.93 的三件事全都做完了，它的五个实现问题被数清楚并回答了，它的三条优点两条缺点也与这棵树的引擎
核对过了。讲义的动机部分和它的例子是语言本身的东西，而 0592 的读取器照单全收讲义的语法。

### 已发布

0.4.50 在两个远端都打了标签 `96784ea`，CI 的 `gate` 与 `publish` 在那个提交上都是绿的，registry
以 `latest_version = 0.4.50` 提供它。

    published 0.4.50  wasm 0138A07D...  706965 bytes  checksum 65b0b165...  2026-11-15T14:11:03Z

**而且发布出去的字节是干净的。** 用发布坐标实测：registry 提供的那个产物扫描它自己随包发出的
源码是 **257/257** 个文件全部解析、`actionable=0`、2013 条 notice，而且它需要的正是那 93 个
契约主机符号，`moon.mod` 里没有 `moonbitlang/async` 依赖。

**而且发布出去的产物只变了两个字节，而且就是版本号那两位。** 逐字节实测：发布的 0.4.49 是
706965 字节，发布的 0.4.50 还是 **706965** 字节——产物**没有长大**——共同前缀里只有 **2** 个
字节不同，在偏移 706892 和 706893 处，它们就是内嵌坐标
`riantr/moonbit_static_analysis@0.4.49` 里的 `4` 和 `9`。

**原因是实测出来的**，而且就是非测试调用点：**Datalog 引擎在它自己的文件之外没有任何非测试
调用者。**

    src/flow/datalog.mbt            datalog_check、datalog_solve、datalog_strata、
                                    datalog_tuples、datalog_has
    src/flow/datalog_pointer.mbt    dl_pointer_answer
    src/flow/datalog_taint.mbt      dl_taint_answer
    src/flow/datalog_deck.mbt       dl_questions、dl_claims、dl_things

`src/pipeline`、`src/report`、`src/cli` 里没有任何东西调用它们，所以发布的 wasm——它是不带测试
文件构建的——不携带这个引擎。**构建出来**和**可用**是两个不同的主张，而这一次它们朝相反的方向
分开：引擎**在**发布的包里，以源码的形式，而依赖这个包的 MoonBit 程序拿到的就是它。

**而且这个包确实带着它，逐字节相同**：发布的源码树有 **239** 个 `.mbt` 文件，0.4.49 是 **230**
个，多出来的那九个正好就是九个 Datalog 模块，而且它们每一个都和本地树逐字节相同。

**而且发布的产物仍然会报出那个家族**，在发布坐标上实测：带上 `--taint-source readInput
--taint-sink log:0`，发布的 0.4.50 报出

    12:3 - error: the sensitive argument 0 of 'log' may receive tainted data from
           'readInput' (TaintFlow) [structural, MSA-018, high]

而**同一个**发布的产物，在**同一个**程序上不带这个规格时报 `actionable=0`——所以那个零是规格
带来的，不是分析器带来的。发布的 0.4.49 对同样的问题给出同样的答案，这正是两个字节之差所预测
的。

**还有一个防止虚假结论的对照。** 「发布的产物里有没有这个引擎」这个问题被问出来了，而答案是
**先**测出来的：`TaintFlow`、`MSA-018`、`DeadStore`、`MSA-015`、`UnusedLocal` 和 `taint_analyze`
在 0.4.49 和 0.4.50 两个产物里都出现 **0** 次，而坐标字符串是在的。所以这些字符串并没有以字面
形式存进这个产物——那是关于**二进制**的事实而不是关于这次发布的——于是字节里没有 "datalog"
这件事，对「引擎在不在里面」什么也说明不了。这一条记录主张的，只是字节支持得住的那一部分。

## 0.4.51 —— IFDS 那份讲义：爆炸超级图、填满它的表格算法，以及可分配性到哪儿为止

**这次发布是什么。** 第五份南大讲义 `15_IFDS.pdf`（*CFL-Reachability and IFDS*，李樾，南京大学，
2021 年，174 页）被逐格对照这棵树读完。四个增量关掉它，而这四个是四种不同的东西。

| 增量 | 是什么 | 会不会走到用户的报告里 |
|---|---|---|
| 0597 | 爆炸超级图与 glue 边——讲义 p.84 的关系式，跑在这棵树自己的流函数上 | 不会——这是库层的能力 |
| 0598 | 爆炸超级图上的表格算法——讲义 p.141 的界，被测量 | 不会——这是一次测量 |
| 0599 | 可分配性的边界——讲义自己的代数，对着 `cprop` 和 `pta` 测量 | 不会——这是一次测量 |
| 0600 | CFL 可达性——可实现路径这门语言，跑在这棵树**自己**的超级图上 | 不会——这是一次测量 |

**没有新的发现家族。** 讲义的算法被读进来、跑起来，答案与这棵树本来就给出的答案对拍——这是对
讲义主张的一次测量，不是对它的第二份实现。名册仍然是十八个家族。

### glue 边是关系式的**参数**，不是常量

p.84 把 IFDS 关系式写成 `(0,0)` 在 `Rf` **里面**。0597 的第一版把 `(0,0)` 留在关系式外面，把
glue 建模成一个 `0->0` 的节点自环，而**测量**把它否掉了：那样一来爆炸超级图只到达一个节点，
`0|0`。

    rel1(glue)    0->0  0->x@1  y@3->y@3
    rel1(noglue)  0->x@1  y@3->y@3

在同一个程序上，可达集是：

    WITH glue     0|0  1|0  2|0  3|0  4|0  2|x@1  3|x@2  4|x@2  4|y@3
    WITHOUT glue  0|0

所以 glue 边是一个**参数**：`ifds_reach_rel(gen, kill, node, facts, glue : Bool)`。一个不能把被测
对象关掉的测量，测不了它——而把 glue 关掉之后，同一棵树除了 `0|0` 什么都到不了。

### 表格算法填满爆炸超级图，而且它复现了这棵树自己的分析

0598 在爆炸超级图上跑讲义的表格算法，再把结果和 `reaching_in`——这棵树自己的到达定值分析——
逐节点对照。两者一致：`IN[2] = {x@1}`、`IN[3] = {x@2}`、`IN[4] = {x@2, y@3}`。

**对照才是重点。** 把关系式里的 `(0,0)` 子句去掉——也就是 0597 第一版那个缺陷——表格算法的答案
是**空的**。两半能对上，是因为这棵树自己的迁移函数**就是**这棵树自己的关系式，只是写成了配对
的样子。

### 而且这个界是被测出来的，不是被抄下来的

p.141 的界是 `O(E·D³)`。在这棵树自己的爆炸超级图上：`E = 14`、`D = 4`，于是界是
`14 × 4³ = 896`。这次遍历跟了 14 条边里的 **8** 条。注记的第一版写的是 10；测量纠正了它，
注记也就就地改掉了。

### 可分配性问的是**迁移函数**，不是格

p.156-164 与 p.165-172 向常量传播和指针分析问的是同一个问题：这个迁移函数在事实的并上可分配
吗？讲义自己的代数是 `F(x ∧ y) = F(x) ∧ F(y)`，读作「输出是不是每个事实各自产生的输出的
并」——在这棵树自己的 `cprop` 和 `pta` 上测量。

    cprop  z = x + y    reads=2   z:all=5   one=⊥   distributes=false
    cprop  y = x        reads=1   y:all=2   one=2   distributes=true
    cprop  y = 2x + 3   reads=1   y:all=9   one=9   distributes=true
    cprop  z = 5        reads=0   z:all=5   one=5   distributes=true

    pta    x -> {o1}   y -> {o1}   z -> {o1}   o1.f -> {o1}
    alias  x, y     alias(x,y)=true   facts=4   one=false   distributes=false
    alias  x, x     alias(x,x)=true   facts=4   one=true    distributes=TRUE   <- 对照
    load   y.f      load(y.f)={o1}     facts=4   one={}      distributes=false

`alias(x,x)` 那一行是对照：一个永远只回答「否」的函数，压根没在测这个问题。

### 而且可实现路径是一门语言，不是一条路径

0600 转到 CFL 可达性。识别器是一个栈，而这个栈**就是**从左往右读的文法——另写一个解析器只会是
同一门语言的第二份实现。

讲义自己的词裁决，按幻灯片印出来的样子引用：

    p.29   (1 (2 e )2 )1 (3              可实现——尽管它并不平衡
    p.39   e e (1 (2 e e e )2 )1 (3 (4 e  可实现——尽管它并不平衡
    p.41   e(1eee)1e                      可实现
    p.42   e(1eee)1e(2eee)1               不可实现

然后用同一个识别器去量这棵树**自己**的超级图。这棵树的边标签是

    0: 1:e,)0,)1 2: 3:e 4: 5:e,)2 6: 7:e,(0 8:e 9: 10:e 11: 12:e,(1 13:e,(2 14:e

程序的入口是**推出来的**，不是假设的——没有任何调用能到达的那个函数，节点 **14**。从那里出发，
搜索给出的见证词是

    e (2 e (0 e )1

栈上 `2` 压在 `0` 上面；而配对计数是

    ordinary pairs      82
    realizable pairs    57
    EXCLUDED pairs      25

第三个数字就是差值，它在这儿是因为可实现路径**就是**路径：这棵树本来就有的那个可分配超级图——
它带着 call-to-return 边，这正是 0599 那一半测到的东西——装着一些不是调用序列的路径。

**测量在这个增量自己的代码里找出了两个缺陷**，而且两个都不是被钉住的缺陷——两个都**修好了**。
搜索保留的是**最后一个**见证，而它自己的注释承诺的是**第一个**；现在保留的是第一个，于是给出上面
那个规范见证。而名为「p.42 的词」的那一行断言的却是一个**任何幻灯片上都没有**的词，尽管这一行
自己的注释引用的是幻灯片上的词——幻灯片的词是 `e(1eee)1e(2eee)1`，现在这一行构造的就是**那个**
词。一个声称自己在测某张幻灯片、却不测那张幻灯片的行，什么也钉不住；而唯一还没被覆盖的讲义词
——p.39 讲义自己的那份推导——现在也成了单独的一行。

### 那些测量

    the exploded supergraph   src/flow/ifds.mbt
    the tabulation            src/flow/ifds_tab.mbt
    the distributivity        src/flow/ifds_distrib.mbt
    the CFL recognizer        src/flow/cfl.mbt

    the glue edge             4 edges;  with it 14, without it 10
    the reach sets            with glue  0|0 1|0 2|0 3|0 4|0 2|x@1 3|x@2 4|x@2 4|y@3
                              without     0|0
    the tabulation            reproduces reaching_in node by node
                              IN[2]={x@1}  IN[3]={x@2}  IN[4]={x@2,y@3}
                              without (0,0): EMPTY
    the bound                 p.141  O(E·D^3)  E=14  D=4  -> 896;  the walk followed 8 of 14 edges
    the distributivity        cprop  z=x+y false;  y=x, y=2x+3, z=5 true
                              pta    alias(x,y) false;  alias(x,x) true (the control)
                              pta    load(y.f) false
    the CFL words             p.29 realizable, p.39 realizable, p.41 realizable,
                              p.42 NOT realizable
    this tree's supergraph    the entry is derived = node 14
                              witness  e (2 e (0 e )1
                              ordinary 82, realizable 57, excluded 25

**移动的钉子**是这次发布自己的源码，七个语料没动：

    own-source files         258 -> 266
    own-source notices     2,013 -> 2,052
    own-source printed       157 -> 157   (UNCHANGED)
    own-source aggregated  1,856 -> 1,895
    the eight-tree total   23,358 -> 23,397
    the eight-tree split     3,971 + 19,387 -> 3,971 + 19,426
    the test counts         1,699 -> 1,731 on wasm, 1,557 -> 1,589 on js and wasm-gc
    the NARRATIVE chapters    106 -> 111

### 已发布

0.4.51 在两个远端都打在 `d811c02` 上，CI 的 `gate` 与 `publish` 在那个提交上是绿的，注册表也
以 `latest_version = 0.4.51` 提供它。

    published 0.4.51  wasm D57E80AE...  706965 bytes  checksum 008832d4...  2026-11-16T17:56:22Z

**而且发布的产物只变了恰好一个字节，而且那个字节是版本号的最后一位。** 逐字节实测：发布的
0.4.50 是 706965 字节，发布的 0.4.51 也是 **706965** 字节——产物**没有**变大——而且公共前缀
里**有 1** 个字节不同，偏移 706893，它是内嵌坐标
`riantr/moonbit_static_analysis@0.4.51` 的最后一位。坐标字符串在偏移 706857 处被找到，所以
移动的那个字节就是版本数字，别无其他。

原因是**测出来的**，而且就是那些非测试调用点：**这四个新的 IFDS 模块在 `src/flow` 之外没有
任何调用者**，而 `src/flow` 并不是 CLI 被打包的那些包之一——`src/pipeline`、`src/report`、
`src/cli`、`src/jsoncli`、`src/sa` 才是。整组函数在自己文件之外只有恰好一个非测试调用点
（`ifds_zero`，被 `src/flow/ifds_tab.mbt` 调用），而那一个同样在 `src/flow` 里面。

**而且发布的包里确实带着这一层的源码。** 发布的源码树有 **247** 个 `.mbt` 文件，0.4.50 有
**239** 个，差 **八个**，这八个正是那八个新文件，而且每一个都与本地树逐字节相同。

**而且发布的源码树扫描自己发布的源码是干净的**：265/265 个文件解析成功，`actionable=0`，
notice 2052——正是这棵树自己的钉子上的那三个数字（2052 条 notice、157 条打印、1895 条汇总）。

**而且发布的产物仍然会报出那个家族**，在发布坐标上实测：带上 `--taint-source readInput
--taint-sink log:0` 时，发布的 0.4.51 报出

    15:3 - error: the sensitive argument 0 of 'log' may receive tainted data from
           'readInput' (TaintFlow) [structural, MSA-018, high]
    SUMMARY  files=1  parsed=1  actionable=1

而**同一个**发布的产物在**同一个**程序上不带这个规格时报 `actionable=0`——所以那个零是规格
带来的，不是分析器带来的。发布的 0.4.50 对同样的问题给出同样的答案，这正是一个字节之差所预测
的。

## 0.4.52 —— Soundiness 那一讲：三方判定、被 `.mbti` 读者丢掉的签名，以及拿声明出来的那部分量一量手写建模的接口面

**这次发布是什么。** 第六份 NJU 讲义 `16_Soundiness.pdf`（*Soundiness*，李玥、谭天，南京大学，
2021 秋季，68 页）被逐格拿来和这棵树对读。三个增量把它关掉，而它们是三种不同的东西。

| 增量 | 是什么 | 会到达用户的报告吗 |
|---|---|---|
| 0602 | 讲义的三方判定——sound / soundy / unsound——按每个家族排除项的**原因**推导出来 | 不会——这是关于家族的一个判定 |
| 0603 | 被 `.mbti` 读者丢掉的跨文件签名，**留下来**并按讲义 p.40 的那一对来量 | 不会——这是一个测量 |
| 0604 | 手写建模的原生接口面，拿**声明出来的那部分**来量——讲义 p.57 对上工具链自己的接口 | 不会——这是一个测量 |

**没有新的发现家族。** 讲义自己的词汇被读出来、用在这棵树上，数字和这棵树本来就给出的数字
逐个对比。家族数仍是十八个。

### 判定是推导出来的，不是逐家族手写的

p.14 给出三种判定，p.13 给出让中间那一类成为一类的那个限定：

    A soundy analysis aims to capture all dynamic behaviors with certain hard
    language features unsoundly handled within reason
    An unsound analysis deliberately ignores certain behaviors in its design
    for better efficiency, precision or accessibility

p.10 是这次增量回答的抱怨：

    Treatments to hard language features are usually omitted or only mentioned
    in an off-hand manner in some impl/eval parts in papers

所以这棵树现在说出了讲义说被漏掉的东西：它每一个不健全的处理都被**命名**，连同决定判定的
原因。每个家族用原因声明自己的排除项，`Family::soundiness` 从这些原因把判定算出来——没有
排除项就是 sound，全部排除项都是硬特性就是 soundy，只要有一个是刻意的就是 unsound——而
`check_family_roster.ps1` 从**源码**重新推导一遍，再和钉住的值比。

    sound=0  soundy=15  unsound=3

    X-ARG-TYPE-NAMED-ARITY    MSA-007  ArgTypeMismatch
    X-OP-PIPE-EXEMPT          MSA-008  OperatorMismatch
    X-NOSEC-REALITY           MSA-012  StaleNosec

手写一张判定表会是**第三张**要维护对的表，而这棵树已经被一张烂掉的手写表咬过——`Family::id`
和 `family_by_id` 是同一个东西写了两遍，正是为了这件事才有了名册门禁。

### 读者丢掉的签名留下来了，而且被量了

p.32 是问题，而它是一个关于读者**保留什么**的问题：

    Problem: Reflection targets cannot be resolved
    if the string values are statically unknown

p.35 是答案，而它是一个关于解析**在哪里**发生的答案：

    When string arguments cannot be resolved statically,
    infer the reflective targets at their usage points!

p.39 说一个解析出来的目标必须**满足**什么——注意它是类型和元数，不是名字：

    The reflective target method at line 175 must have one parameter and its
    declared type must be FrameworkCommandInterpreter or its sub/supertypes

而这棵树有**同一个缺陷、同一个形状**。`.mbti` 声明了函数的**参数表**，而这棵树的读者把它
丢掉了：它留下了名字，丢掉了签名。记下这件事的那句话被写在 `src/types/infer.mbt` 里，而且
是**错的**——所以它在原地被改正，并附上推翻它的那个测量。

在八棵树上量出来，而且它是**一对**，因为只有一致数而没有机会数的数字是关于空的数字：

    cross-file calls whose callee the .mbti declares a signature for   2,961
    of those, the ones whose declared arity agrees with the call      2,282

而这个推断是**只数不执行**的，这不是推托，正是讲义 p.39 的教训：推断出来的目标必须由它的
**类型**约束，不能只靠**名字**，而这张表只有名字。

### 手写建模的接口面，被拿声明出来的那部分量了

p.57 写明当前的做法：

    Current practice
    Manually models the critical native code

p.60-61 给出**另一种**建模——同样的行为用高级语言写出来，而不是手写建模——p.63 点出更新的
读法：

    Recent work
    Identifying Java Calls in Native Code via Binary Scanning (ISSTA 2020)

而这棵树做的正是第一件事：`src/core/builtin_methods.mbt` 是一张 **1,344** 个 `Type::method`
名字、覆盖 **40** 个内建类型的表，由 `tools/gen_builtin_methods.ps1` 生成。所以 0604 量它——
拿接口**声明出来的那部分**来量，也就是把讲义的替代建模落到这棵树自己的问题上。

    tree                declared  covered  missing  modelled-only
    moui                       0        0        0           1344
    moonbit_labeler            0        0        0           1344
    moonbit_image              0        0        0           1344
    async                     10        0       10           1344
    proton                     0        0        0           1344
    proton_contract            0        0        0           1344
    moonbit_core            1,123    1,076       47            268
    this repository            0        0        0           1344
    --------------------------------------------------------
    the eight trees         1,133    1,076       57

而这些零是**测量结果**，不是测量的漏洞：手写的那张表是**标准库**的接口面，用户自己的包不会
为它声明任何方法——所以只有那棵**就是**标准库的树才对此说得上话。

而这 47 个是**假阳性方向**，而且**今天不会真的报出来**：在 `moonbit_core` 上实测，10 条
actionable，其中 0 条是 `undefined function`，47 个里 0 个出现在任何一条发现里。所以这 47
个是**兜底**缺口，不是活的假阳性发生器，因为 `.mbti` 把它们解析了。而 268 个是另一个方向
——**漏报**方向，表头自己说了这是故意接受的。

而这张表落后一个工具链世代，这一条也是量出来的：这台机器的工具链是 `moon 0.1.20261104`，
它的 139 个 `.mbti` 声明的是**同样的 1,123** 个，缺的也是**同样的 47** 个。

**所以 0604 只公布覆盖面，不重建那张表。** 重建它是一次会改变分析器**发现了什么**的发布
——这张表只会压制——那属于一次要重新量七个语料的发布。

### 而移动了的钉子都是这次发布自己的源码，七个语料没有动：

    own-source files         268 -> 273
    own-source notices     2,061 -> 2,079
    own-source printed       157 -> 158
    own-source aggregated  1,904 -> 1,921
    the eight-tree total   23,406 -> 23,424
    the eight-tree split     3,971 + 19,435 -> 3,972 + 19,452
    the p.40 pair          2,958 / 2,279 -> 2,961 / 2,282
    the native surface        -- -> 1,133 declared / 1,076 covered / 57 missing
    the test counts         1,731 -> 1,751 on wasm, 1,589 -> 1,609 on js and wasm-gc
    the NARRATIVE chapters    111 -> 115

### 已发布

0.4.52 在两个远端都打上了 `99ebfa5` 这个标签，CI 的 `gate` 和 `publish` 在那个提交上都是绿的，
registry 也用 `latest_version = 0.4.52` 提供它。

    published 0.4.52  wasm C1989B4C443B19F195D0014F2B690942A87DB012815A7CFD64D9FAF5B7B0DC3E  728514 bytes  checksum 6f051bb393f36f1ec4bba7c960b9f0984f807590aae9b7457c24c202f3adfca4  2026-11-17T12:51:03.713114+00:00

**而且产物变了 628,310 个字节，因为新代码就在里面。** 逐字节量出来的：发布出去的 0.4.51 是
706965 字节，0.4.52 是 **728514** 字节（+21,549），公共前缀里有 **628,310** 个字节不一样。
再往前两次发布分别只变了两个字节和一个字节，而那两个都是嵌在坐标里的版本号那一位。这一次
变的是代码。

**而证明不是那个大小，是那个输出**：发布出去的产物会打印这次发布新增的两行。

    published 0.4.52, --metrics
        METRICS  iface-sig  available=218  agrees=218  agree-share=100.0%
        METRICS  native-surface  modelled=1344  declared=0  covered=0  missing=0
                 modelled-only=1344

**而且发布出去的包里确实带着这一层的源码，而且就是同一份源码。**

    published 0.4.52 带 254 个 .mbt 文件；published 0.4.51 带 247 个
    差的是七个，而七个正好就是那七个新文件
    而发布出去的 254 个 .mbt 文件，每一个都和本地树**逐字节相同**

**而且发布出去的树扫自己出货的源码是干净的**：272/272 个文件解析成功，`actionable=0`，
2079 条 notice——158 条打印、1921 条聚合——和这棵树自己的钉住值是同样三个数。

**而且发布出去的产物量 moonbit_core 的方式和这棵树一样**，用的是门禁自己的参数，所以数字是可
比的而不只是相似：`actionable=30`、`notices=13520`、`total=14366`，以及 0604 的原生接口面
`declared=1123 covered=1076 missing=47`——和本地的钉住值逐位相同。

**而且 soundiness 的判定就在出货的产物里**：`--explain-all` 会打印每个家族的判定和每一条排除
项的原因，`--explain MSA-007` 会打印 `soundiness unsound` 和它的两条排除项。讲义 p.10 抱怨的
那件事，是在用户装到的那个产物里被回答的，不只是在这份仓库的源码里。

**而且发布出去的产物仍然会报出那个家族**，在发布坐标上量出来的：

    published 0.4.52, with --taint-source readInput --taint-sink log:0

        11:3 - error: the sensitive argument 0 of 'log' may receive tainted data from
               'readInput' (TaintFlow) [structural, MSA-018, high]
        SUMMARY  files=1  parsed=1  actionable=1

而同一个发布产物、同一个程序、**不带**那个规范时报的是 `actionable=0`——所以那个零是规范做
的，不是分析器做的。

**而且宿主契约是红的，而原因在 registry 的构建器，不在这棵树。** 在发布出去的字节和这棵树
自己构建的 release 产物上量出来的，**是同一份源码**：

    本地 release 构建物    107 个 import，其中 93 个来自 `moonbitlang/async`
    发布出去的 0.4.52       106 个 import，其中 92 个来自 `moonbitlang/async`

    在发布出去的那份里有、而本地没有的：  thread_pool/make_openat_job
    在本地有、而发布出去的那份没有的：    thread_pool/make_fsync_job
                                           thread_pool/make_open_stat_job

`moon publish` 上传的是**源码**，wasm 是 mooncakes **在服务端**编译出来的，所以发布出去的产
物链接的是 registry 的构建器工具链——而那个工具链在 async 的文件 IO 作业上差了整整一代。发布
出去的 0.4.50 和 0.4.51 都和契约完全吻合，所以这件事是随这次发布来的。

**而且这个改名没有弄坏任何用户，这一条也是量出来的**：发布出去的 0.4.52 产物在这台机器上跑得
起来，而这台机器**就是**契约的下限（moon 0.1.20261104，自带的 core 0.10.20+65efd5b93），工具
链的 runtime 把那个文件 IO 作业实现成了 `moonbit_rt_make_openat_job`。红的是**记录**和**门
禁**：契约要求两个方向都完全相等，而当集合由**构建器**决定时，那不是宿主契约该有的性质；发布
门禁的出货那一级把它抓到了。下一个增量会把契约放宽，并把那个检查改成子集检查——那才是宿主契
约真正有的性质。

## 0.5.0 —— 宿主契约从「镜像」变成了「下限」，而门禁学会了说自己测不到

**这一版是什么。** 一个次版本号，理由是一项用户能感觉到的属性变了：这个包对运行它的宿主**要求**什么。
0.4.52 那一版的结尾正指着这个增量说：「下一个增量会把契约放宽，并把检查变成子集检查——那才是宿主契约
本来就有的性质。」这就是那个增量。

    0606  契约是下限而不是镜像：93 -> 94 个符号，检查变成子集检查。而下限是**工具链**的——
          它自带的 core 和它的运行时都要算。
          _verify/host_requirements.txt、_verify/check_host_requirements.ps1
    0607  每道变异门禁之后都查一次源码树：把树留在补丁状态的门禁会被**点名**，而不是接着毒化后面的门禁
    0608  那道检查必须能**大声失败**：读不到树的检查不等于树是干净的，而且恢复必须是逐字节的
    0609  被**终止**的门禁没有给出判决，而没有判决不等于门禁失败

**没有新的 finding family，分析器发现的东西也没有变。** family 名册仍然是十八个，分析器跑的代码没有变——
0.4.52 的分析就是 0.5.0 的分析。变的是产物与宿主之间的**契约**，以及把两者钉住的门禁。

### 契约成了下限，而测量给出了原因

0.4.52 的 published-package 阶段在发布坐标上变**红**，原因不在这棵树里：

    -> FAIL: it requires 1 host symbol(s) the contract does not allow:
    FAIL: the contract lists 2 symbol(s) the artifact no longer requires:

在**同一份源码**上量发布出来的字节和这棵树自己的 release build：

    本地 release build      107 个 import，其中 93 个来自 `moonbitlang/async`
    发布出去的 0.4.52         106 个 import，其中 92 个来自 `moonbitlang/async`

`moon publish` 上传的是**源码**，mooncakes 在**服务端**编译，所以发布出去的产物是对着 registry 的构建工具链
链接的——而那个工具链在异步文件 IO job 上差了一代。发布的 0.4.50 和 0.4.51 都和老契约精确吻合（107 个
import，各 93 个），所以这件事是随 0.4.52 来的。

**所以契约被放宽到 94——两次构建的并集——而检查变成了子集检查。** 在契约**之外**的符号是**失败**，
因为那个方向会让用户跑不起来；在契约**之内**、而某一次构建没要的符号是**一条提示**，因为要哪一套是构建器说了算。
门禁自己的自检现在**两个方向都断言**，所以一个仍然是相等检查的实现过不了。

**而且下限是工具链的，不只是它那个 core 的。** 94 个里有一个不是 core 能提供的：
`thread_pool/make_openat_job`，那个文件 IO job，是工具链的 C **运行时**用 `moonbit_rt_make_openat_job`
实现的，**没有任何 core 声明它**。

    工具链自带的 `moonbitlang/core` 0.10.20+65efd5b93   215 个宿主 extern
    工具链的 C 运行时                                        288 个 `moonbit_rt_*` 名字
    两者加起来覆盖全部 94 个

而且契约带上了 `min-host-core: 0.10.20+65efd5b93` 和 `min-host-toolchain: 0.1.20261104`，
所以下限是一个**工具链**，不是一个库版本。

### 而且没有用户被这个改动弄坏，这一点也是量出来的

发布出去的 0.4.52 产物在这台机器上**跑得起来**，而这台机器**就是**契约的下限；工具链的运行时实现了那个
文件 IO job。并集是每一次构建所要的超集，所以满足下限的宿主就满足每一个发布出去的产物。

### 门禁学会了说自己测不到

0607 那道「树是不是回到 HEAD 了」的检查，在门禁自己的自测里被证明能变红。然后 0608 那次发版跑出了这道检查的
**盲区**，而且是真盲区——用这道检查自己的函数体量出来的：

    git 正常，树是干净的            ->  0 个文件  ->  检查通过
    git 正常，树里有变异              ->  1 个文件  ->  检查失败并点名
    git 跑起来但退出码非零            ->  0 个文件  ->  检查**通过**
    git 根本不在 PATH 上              ->  0 个文件  ->  检查**通过**

后两行就是缺陷：一个**读不到**的读者给调用方留下的是一个空列表，而空列表读起来就是「树是干净的」。
所以这道检查现在返回一个**判决**而不是一个列表——Ok、Files、Reason——读不到树的人要说出来，并让整次跑动**失败**。
这不是假想：在那次失败的跑动里，机器在门禁底下被杀了，这道检查**里面**那个 `git` 就是受害者之一，
而检查把一棵仍然是**补丁状态**的树报成了干净。

而且恢复是**逐字节**的，因为以前不是：`git checkout HEAD -- src/` 把它恢复的文件写成 62420 字节的 CRLF，
而那个 blob 是 61242 字节的 LF，然后 git 把这棵树叫作**干净**。现在恢复从 blob 按**字节**读、写入，
并拿 blob 的 SHA256 校验结果。

0609 是同一条教训的另一半：被**终止**的门禁没有给出**判决**，而没有判决不等于门禁失败。事实由 transcript 携带——
跑到判决的门禁会打印 `GATE OK` 或 `GATE FAILED`，被杀掉的门禁两个都不打印——所以那一行写 `KILLED`，
整次跑动也会点名它。

### 依赖这一步是量出来的空操作，不是跳过了

`moon.mod` 没有 import 块，合计 import **0** 条路径；registry 也没有为这个模块发布任何依赖。
唯一的外部依赖是工具链自带的 `moonbitlang/core/async`，故意**不钉版本**，好让它跟着用户自己的工具链走——
因为正是钉版本和用户工具链不一致，把 0.4.38 弄坏的。registry 上没有东西可升。

### 而版本号是故意走次版本的

0.4.52 → **0.5.0**，理由是变了的那个性质：宿主契约现在成了**下限**而不是**镜像**，下限是工具链而不是单个库，
而且契约带上了最小宿主工具链。读这份文件的人必须能看出这不是一个补丁。

### 而发布出来的那一行还不在这里

字节要等 CI 发布出来才存在，所以 `published 0.5.0 wasm <hash>` 那一行写在后面那个提交里，在发布之后——
0.4.52 也是这么做的，而一个还不存在的哈希是虚构。

### 已发布

0.5.0 在两个远端都打上了 `e11da29`，CI 的 `gate` 和 `publish` 在那个提交上是绿的，registry
以 `latest_version = 0.5.0` 提供它。

    published 0.5.0  wasm 2094215E25BE62B78994818407CD94F3635D17FFC3006778DDA41CBAB2DDB586  728513 bytes  checksum b7b76393766bdc61973bcce6c52441e48576893246050c6380cc404b79085e17  2026-11-18T13:38:17.131204+00:00

**而这个产物小了一个字节，而且每一个不一样的字节都是版本坐标。** 实测，逐字节：发布出去的
0.4.52 是 **728514** 字节，发布出去的 0.5.0 是 **728513** 字节（**-1**），而 728513 字节的公共
前缀里有 **72** 个字节不同。这比一个版本位要多的字节，所以这个差别是被**点名**的，而不是被概括
的——它是一件事：wasm `name` 自定义段里内嵌的那个坐标。

    0.4.52 里的坐标   riantr/moonbit_static_analysis@0.4.52   37 个字符
    0.5.0 里的坐标   riantr/moonbit_static_analysis@0.5.0    36 个字符
    版本字符串         "0.4.52" 是**六**个字符，"0.5.0" 是**五**个

所以坐标短了一个字符，段的长度前缀跟着变短，坐标之后的每一个字节都**挪了一位**——这正是
72 个字节不一样、而代码本身完全一样的原因。两边的 `producers`、`language`、`processed-by`
元数据逐字节相同（`v0.10.21+06da1ed44`），编译它们的工具链也是同一个。

**而这正是要点：分析代码一个字都没改。** 0.5.0 的分析就是 0.4.52 的分析。它带的四个增量
（0606-0609）讲的是产物与宿主之间的**契约**，以及把两者钉住的**门禁**，而不是分析器会找出
什么。所以产物的字节就是同一份代码，唯一不同的是给它命名的那个坐标。

**而源码从另一头说的是同一件事。** 0.4.52 的发布提交和 0.5.0 的发布提交之间，`src/` 下的文件
差别是**零**——两个提交之间全部的差别是十个文件，每一个都是文档、一个 `moon.mod`，或者
`_verify/` 下的一个文件。所以 0.5.0 发布出去的源码就是 0.4.52 发布出去的源码，逐字节相同，
而产物那一个字节的差别只是坐标，没有别的。

**而宿主导入面完全相同，用门禁自己的读数器量的。**

    发布出去的 0.4.52 产物   106 个导入，其中 92 个来自 `moonbitlang/async`
    发布出去的 0.5.0 产物   106 个导入，其中 92 个来自 `moonbitlang/async`
    两个方向上「一个要而另一个不要」的符号：0
    它要的、落在 94 个符号的契约**之外**的符号：0

所以下限还是下限，发布出去的 0.5.0 产物仍然是那 94 个符号契约的**子集**——而这正是 0.5.0
这次发布本身讲的那个性质。

**而发布出去的包带着这一层的源码，而且就是同一份源码。**

    发布出去的 0.5.0 带 254 个 .mbt 文件
    而这 254 个**每一个**都和本地那棵树逐字节相同

**而发布出去的那棵树扫自己发出去的源码是干净的**：272/272 个文件解析成功，`actionable=0`，
notices=2079——而那个家族在发布坐标上照样会触发，还带着那句说明「起作用的是规格本身」的
对照：

    发布出去的 0.5.0，带 --taint-source readInput --taint-sink log:0
        11:3 - error: the sensitive argument 0 of 'log' may receive tainted data from 'readInput' (TaintFlow) [structural, MSA-018, high]
    对照：同一个产物、同一个程序，**不带**规格
        SUMMARY  files=1  parsed=1  actionable=0

## 0.5.1 —— 最新的 core 拒绝了这棵树，而发版从此卡在 core 上

**这一版是什么。** 一个补丁版本，而理由是用户能用最坏的方式感觉到的：**这一版根本编不过。**
分析器找到什么没有任何变化——家族名册仍然是十八个，这一版一个都没加——但注册表要去编译的那棵树，
必须先修好才能发布。

    0611  覆盖面那次测量点了两个文件，其中一个在自己的表头里就写错了
    0612  讲义自己的课程地图，而那张点名每一份讲义的地图点了九份
    0613  分析器把自己的文档读成了十二条抑制，而那十二条**全都是散文**
    0614  发布的文件数描述的是本地那棵树，既不是包，也不是干净检出
    0615  一个什么都选不中的开关、五道**变不红**的门禁，以及一个工具链编不了的钉住的语料
    0616  剩下的就是一个数，而它旁边那句话点了它五个成因里的两个——点中的正是会**报告**的那两个
    0617  一个在一台机器上能解析、在任何已发布副本里都解析不了的指针——以及二十七道**点名仓库而不是树**的门禁
    0618  技能文件教着一句已经被证伪的话，而没有任何东西读它的数字
    0619  契约文档说证据比实际小二十四倍，而没有任何东西读它
    0620  随包发布的 CLI 技能文件把一条发现显示成**错误**，而工具实际上把它降级成 notice，
          而没有任何东西跑一遍 CLI 去对账
    0621  工作区技能引用了一个小二十二倍的测试数，而从来没有任何门禁读过它
    0622  工作区技能在一个**已经不存在**的语料上量了它那份干净的 `.mbti` 审计，而没有人把住范围
    0623  工作区技能的 `.mbti` 证据是在**另一个仓库**的语料上量的，而打包出去的门禁开箱就是红的
    0624  两份随包发布的文档告诉读者一条工具链**已经没有**的命令仍然能用，而那句话自带过期日期
    0625  地板抬了，而只有两个 README 跟着抬；修掉最后一个缺陷的那个补丁把自己插进去了三次
    0626  发布出去的工具和发布出去的文档描述的是**两个不同的分析器**，而没有任何东西量过这个差距
    0627  仓库为证明失败发布的那个成因，被一次 WHY3 实验证伪了——而它在四个地方同时成立
    0628  目标自己的清单是一句注释，而它有两个指针解析到了错的地方
    0629  一份文档点名了一个**不存在**的 URL，而本该抓住它的探针骗了两次
    0630  抓住自己那条规则的那道门禁，以及一份文档**可以引用**一个死掉的地址
    0631  最新的 core 拒绝了这棵树，而发版从此卡在 core 上

### 这一版本来**编不过**，而 runner 并不是切这一版的机器

实测（2026-11-20），对 CI runner 会装上的那个最新工具链（`moon 0.1.20261119`，core
`0.10.22+124d61d05`），对当时那棵树：

    moon check --deny-warn   ->  exit 1
      Error Warning (unused_package): Unused package 'moonbitlang/core/async'
      Failed with 0 warnings, 2 errors.

`moon check --deny-warn` 是 CI 门禁跑的**第一条**。两个工作流都用 `install/unix.sh` 装工具链，
**不写版本号**，于是 runner 拿到的是 `latest`——而安装脚本是**分开**取 core 的：
`cores/core-$version.tar.gz`，`version=latest` 时就是**最新的 core**，而不是工具链自带的那一个。
⇒ 所以 runner 的 core **自己会动**，和工具链的版本无关；于是在切发布的这台机器上能编过的树，
到了 runner 上仍然可能编不过。

### 这棵树**两边都得能编**，而这才是难的地方

把导入删掉会**弄坏旧 core**——`Cannot use 'async fn main': package moonbitlang/async is not
imported`（error 4122）；留着它会**弄坏新 core**——`unused_package`（warning 0029），而
`--deny-warn` 会把它变成错误。⇒ 这个导入**旧 core 0.10.21 需要、新 core 0.10.22 说它没用**，
所以它**留着**，而那条警告在**需要它的两个包里**被关掉：`warnings = "-unused_package"`，
**按包**关——这样别处真的没用的导入**照报**。

⇒ **产物没动**：加不加这一行，wasm 都是 **106** 个 import、其中 **92** 个来自 `moonbitlang/async`，
契约还是那 **93** 个符号，地板还是 `moon 0.1.20261117 or later`——新的 core 声明 213 个宿主 extern、
runtime 再实现 288 个，合起来仍然覆盖全部 93。

### 发版从此卡在 core 上

`_verify/regate_newest_toolchain.ps1` 用最新的工具链跑一遍这棵树——发现上面这一切的就是它——而
发布门禁多了一道 stage：它问注册表**哪个 core 是最新的**，并把它钉在这棵树被 re-gate 过的那个上。
注册表一旦发布更新的 core，那道 stage 就变红，并说清楚该做什么。

### 而随包发布的那些文档，也被拿去和它们自己说的话对账

其中两份是错的，两处修复都来自实测：

* 工作区技能教读者「选版本号之前先查注册表的 manifest」，给的地址是
  `mooncakes.io/api-new/v0/manifest/...`。那个 URL 答 **404**；活着的是 `api/v0/manifest/...`，
  它答 **200**，并且带着 `latest_version`、`build_status` 和完整版本列表。而那个路径里的版本段
  **被忽略**——`.../9.9.9` 也答 200，而且答的是**最新**的 manifest——所以往路径里填了一个版本号的
  读者，什么也没有证明。
* 目标自己的清单点了一个**已经移动**的行和一个**多了一个兄弟**的文件，于是它有两个指针解析到了错的地方。

## 0.4.13 —— 最后 5 条：三种成因，其中一种是「把检查调窄」的陷阱

0.4.12 剩 5 条。**全部是分析器的缺陷，pyroduct 的代码没错**——三条都是
`moon check` 零错误通过的干净文件。

| 成因 | 条数 | 位置 |
|---|---|---|
| `color[u]`：**把 `Map` 当成 list 报下标类型错** | 2 | `src/paths.mbt` 135/152 |
| `self` **只**在插值里被读 → 报参数未用 | 1 | `src/slot.mbt` 127 |
| `_` 前缀的未用绑定/参数（**分析器与编译器规则相反**） | 2 | `src/algebra.mbt` 118、`audit/mbti.mbt` 69 |

### 第一条差点被我用一个更糟的 bug 换掉

`Map[String, Int]` 用 `String` 下标是**对的**——`Map` 按 key 索引。而类型镜从来没问
过「这个下标的基到底是不是 list」，只要下标不是 int 就报
`list indices must be int`，**在干净文件上给出 `error:` 级发现**。

最直接的修法是加个前提：基是 `TList` 才报。**这一改立刻吞掉了两条真实错误**——
我拿探针量出来的：`xs["k"]` 在 `Array[String]` 和 `Array[Int]` 上，`moon check`
报 "Expr Type Mismatch"，0.4.12 能抓到，加了前提之后两条都没了。

原因是 `ann_to_ty` **不认识 `Array[T]`**（只认 `[T]`，而 `[T]` 在 MoonBit 里根本不是
合法写法），parser 还用 `skip_indexed` 把 `[...]` **整个丢掉**——`Array[String]`
到达类型镜时只剩 `"Array"`。所以那个 `TList` 前提**永远不成立**，检查等于静音。

真正的修法是**补上类型模型**，而不是关掉检查：三处——
`ann_to_ty` 认 `Array[T]`；parser 的 `type_annotation` 保留头部的 `[...]`
（它自己上面的注释还写着「类型镜不建模容器，所以丢掉不损失」——那句话正是这个
bug 的说明书）；`ty_assignable` 递归进 `TList`，让 `TList(TUnknown)` 能赋给
`TList(TStr]`（否则「Unknown 可赋给任何东西」这条规则被下一层悄悄推翻）。

最终对照（探针里 5 个下标，`moon check` 报 3 个真错误）：

| | 真错误 | 误报 |
|---|---|---|
| 0.4.12 | 3 / 3 | **1**（`Map`） |
| 0.4.13 | **3 / 3** | **0** |

⇒ **教训一：给检查加前提之前，先问「它依赖的类型读得到吗」。** 前提写对了，
但如果依赖的那个类型是**上游丢掉的**，加前提就等于静音——而且它静默得很有道理：
检查确实"只在基是 list 时才报"。

⇒ **配套：parser 丢信息这件事，类型镜那边的注释替它辩护了。** 一句写对的注释
（「不建模容器所以丢掉不损失」）会在**前提收紧**的那一刻变成谎言。注释里
"这不是妥协"这种话，要跟着它依赖的前提一起复查。

### `_` 前缀：分析器和编译器规则相反

`_` 前缀在 MoonBit 里是**丢弃约定**。探针（同一个文件里同时放 `_f` / `_classes` /
`_ok3` 和一个非下划线对照 `plain`）：`moon check` **只对 `plain` 报警**。
分析器此前只豁免裸 `_`，并在注释里断言「名字不是丢弃堆」——那是**论证，不是实测**。

⇒ **教训二：豁免规则先探针，再写进注释。** 这条规则和它那句理由都是 0.4.8 加的，
从没被工具链验证过；一改注释里的断言，编译器一句话就把它否掉了。

### `self` 是约定参数名，不是关键字

词法器把 `self` 列进了「插值里不是绑定」的关键字表，于是 `\{self.designation()}`
**不记录这次读**，只在插值里被读的参数就被报成未使用。它是 0.4.8 加插值追踪时
**顺手猜进去的**，没量过。

⇒ **教训三：同一个读法在不同代码路径上答案必须一致。** 这里的 bug 就是
「插值里算读、普通表达式里不算」，两条路径互相矛盾。写测试时要**两个方向都钉**，
否则只钉一个方向会以为已经覆盖了。

### 被突变验证挖出来的两件事

1. **突变脚本自己的过滤器匹配了 0 个测试。** 两个 guard 报成 GREEN，其实
   `--filter` 的 glob 根本没选中任何用例——一次「全绿」什么也没证明。脚本现在
   断言 `ran > 0`，`ran = 0` 直接判 INVALID。
2. **一个修复没有任何测试能杀死它。** 我一度让空列表字面量「采纳注解类型」，
   把它静音后两个语料的发现流**逐字节相同**（496 / 528 条），也没有测试能杀它。
   真正起作用的是 `ty_assignability` 那一条。**测不出差别的分支不是保险，是没被测过
   却长得像决策的代码**——已删，并在两处注释里写明为什么删。

pyroduct **actionable 5 → 0**，总发现数 632 → 627，正好 −5：没有新发现冒出来。
自检 48/48、actionable=0。测试 js 240 / wasm 312 / wasm-gc 240（新增 24 个，
其中 6 个是新的 `types_test.mbt`——这个文件此前不存在，也正是它缺失让上面那个
回归活过了整整一个版本）。八道防护，全部突变验证通过。

## 0.4.10 —— 发布 0.4.9 才暴露出自检一直在遮蔽的两件事

把 provenance 的修复发出去，意味着要再用它自己扫一遍已发布的包——就是当初找出
`unknown` 那个 bug 的检查。这一次回来是 `actionable=2`，而 0.4.8 是干净的，
两条都在 `provenance.mbt`：

```
no visible binding for 'is_coordinate'
no visible binding for 'split_coord'
```

两条都不是代码缺陷。它们是这一版在读自己的源码时，发现了两件关于工具本身的事。

**`if` 表达式会藏起未定义名。** 同样这两个名字在同一个文件里出现了两次，只报了
一次：

```moonbit
let stem = if is_coordinate(p.target) {   // 226 行——if 表达式
  ...
if is_coordinate(target) {                // 411 行——if 语句
```

`let x = if c { … } else { … }` 会被解析、两个分支会被读，然后**整块丢掉**——
它属于「不分析的子集」，而且有告知说明。所以写在这种分支里的不存在名字，
永远不会被报。0.4.8 自检之所以干净，部分原因正是这两个调用躺在一个被丢掉的
if 表达式里。把它们挪进普通函数后 `if` 变成语句，被完整解析，
两个潜伏的**漏报**就变成了两条发现。

**另一个文件里的包私有辅助函数是看不见的。** 跨文件解析走 `.mbti`，
而包私有的 `fn` 不出现在任何 `.mbti` 里——所以一个文件调用同包另一个文件的私有
辅助函数，读起来就像未绑定。那两条发现的真相就是这个：真实存在的绑定，
而分析器没有任何途径看到。`is_coordinate` 和 `split_coord` 现在是 `pub`，
因此进了接口文件，理由和 `prov_or_unknown`、`stamp_utc`、`scan_artifact_name`
当初一样。每个函数上的注释都写明了原因，免得有人日后"整理"回私有、
悄悄把这条发现放回来。

这两类本次都没修：它们都是已声明的子集 / 可见性限制，而且都偏向**沉默**而不是
噪音。扫一个多文件包却什么都没返回时，值得知道有这两回事。

## 0.4.9 —— `@latest` 扫描把自己的产物命名成 `unknown`

用文档里那条命令、通过它自己扫已发布的包：

```
moonx riantr/moonbit_static_analysis@latest riantr/moonbit_static_analysis@latest --mmd-auto
```

结果是 `46/46 parsed, actionable=0`——**已发布的产物扫自己是干净的**，这是工作树
给不了的那个检查。但产物名是
`riantr-moonbit_static_analysis_unknown_0.1.20260920_…mmd`，头部写着
`version=unknown`，而这次扫的正是在读
`.repos/riantr/moonbit_static_analysis/0.4.8/`，它的 `moon.mod` 里明明白白是
`version = "0.4.8"`。

`provenance_for` 在目标是坐标时只从坐标取版本，从不回退到那棵树。`@latest`
本身不带版本：`split_coord` 故意把它抹成空，好让 `moon fetch` 收到一个裸模块名。
于是**工具自己头部举的那条例子命令，永远写出 `unknown`**——而版本正是用来把两次
扫描区分开的那个字段。

**钉了**版本的坐标仍然优先于树（调用方要的就是那一个），只有空的情况才回退。
修复后重跑同一条坐标扫描实测：

```
MMD	riantr-moonbit_static_analysis_0.4.8_0.1.20260920_20261010T235302Z.mmd
  %% version=0.4.8
```

测试：js 207 / wasm 277 / wasm-gc 207。

## 0.4.8 —— 以 mermaid 工件为证据的三轮自检

把扫描器对准自己跑了三轮，每一轮以上一轮的输出作为本轮的靶子。证据取 mermaid
工件（`--mmd '@'`）；但 **stdout 文本报告才是权威**——图天生有损
（`findings_shown_per_file = 40`），只用来定位。

| 轮 | 已解析 | actionable | 那一轮修了什么 |
|---|---|---|---|
| 起点（0.4.7） | 46/46 | **104** | —— |
| 第二轮后 | 46/46 | **8** | 被跳过的表达式、`walk_target` 穿透写、过期 `.mbti` |
| 第三轮后 | 46/46 | **0** | 字符串插值里的名字不可见 |

覆盖率全程没有回退。测试：js 208 / wasm 274 / wasm-gc 208，`--deny-warn` 干净。

**被跳过的子表达式也是帧上的一个洞。** `match` / `try` / 函数面量是「声明的子集
边界」——它不移动错误行、不扣覆盖率，但它跳过的那块区域恰恰可能是某个绑定唯一的
赋值处，因此含它的函数现在整函数退出
`UnusedLocal` / `UnusedParam` / `ParamChanged` 审计。这要求函数有**完整区间**
（从头部到右花括号），`SFunc` / `SLocalFunc` 现在带的就是它。**104 → 8**。

**穿透参数写是读，不是重绑定。** MoonBit 的结构体是引用，`self.field = v`、
`v[0] = x`、`pair.0 = x` 改的是参数所指的对象，参数本身没变。这三种以前都算
`ParamChanged`，于是报出一条它自己的解释（「不再持有调用方传入的值」）为假的结论。
`ParamChanged` 现在只针对裸名重绑定。

**经 `\{...}` 读到的名字就是读到了。** 插值体被原样抄进字符串 payload，所以它从来
不是 token——只经插值读的名字看起来没被读，而插值里**不存在**的名字则根本不报。
`TStr` 现在携带其插值引用的名字，walk 逐个解析。上一轮活下来的 **8** 条**全是**
这一个缺陷：`mermaid.mbt` `anchor`、`pipeline.mbt` `i`/`s`/`r`、
`parser.mbt` `what` ×2、`interp.mbt` `name`、`cli/main.mbt` `live`。**8 → 0**。

这两个数字是怎么拿到的，值得单列，因为两条都容易被当成规矩重复下去：

- **第三轮的起点就是错的。** 那 8 条本来准备当死代码清理。它们不是死代码——照着清理
  就是删掉能跑的代码去迎合一条误报。那一轮找到的是分析器自己的缺陷。
- **插值那个修复立刻又造出两条误报**：`no visible binding for '1'` 和 `'10'`，
  出在 `\{i + 1}` 与 `\{pct / 10}`——标识符被允许以数字开头。只有拿真实代码再扫一遍
  才会浮出来。**修误报和制造误报是同一类动作**，区别只在于有没有再跑一次扫描。
