Rust RFC 92 深度解读:用表达式子类别 e' 消除 struct literal 解析歧义

原创2026-10-14 11:18:351,814 阅读
文章标签:文档

Rust RFC 92 深度解读:用表达式子类别 e' 消除 struct literal 解析歧义

本篇基于 Rust 语言 RFC 仓库中的 text/0092-struct-grammar.md(RFC 92,2014 年提出),系统讲解 Rust 解析器早期如何依赖"前瞻查找 : 冒号"这一脆弱手段来区分 struct literal 与"标识符 + 代码块",以及 RFC 92 提出的替代方案:引入一个排除 struct literal 的表达式子类别 e',并让 for、if 等后接 block 的语法直接消费 e' 而非任意表达式。读完本文,你可以理解该歧义的根源、正式文法改造前后的对照、RESTRICT_BLOCK 解析模式标志位的实现思路,以及这一设计在后续 Rust 语法(if let、placement in 等)中的持续影响。

问题背景:靠前瞻找 : 来识别 struct literal

在 struct literal 语法被引入的早期,Rust 的表达式语法中存在一个根本性的二义性:当一个表达式后面紧跟着 { 时,解析器无法仅凭文法确定这个 { 是属于一个 block(代码块),还是属于一个 struct literal。RFC 92 给出了 Rust 抽象语法的一个简化子集来展示这个问题:

e      ::= x
         | e `.` f
         | name `{` (x `:` e)+ `}`
         | block
         | `for` e `in` e block
         | `if` e block (`else` block)?
         | `|` pattern* `|` e
         | ...
block  ::=  `{` (e;)* e? `}`

在这套文法中,x(变量引用)与 name(类型名/标识符)无法从词法层面区分,因此 for 表达式中的 e block 片段与 struct literal 表达式 name { x: e, ... } 产生歧义——for S { x: 3 } { ... } 既可以读作"for 循环,其迭代表达式是 struct literal S { x: 3 },随后接循环体 block",也可以读作其他组合。早期的 Rust 编译器用**前瞻(lookahead)**解决了它:解析器向前扫描 struct literal 内部,寻找 : 冒号 token;一旦看到 name 后面跟着 { 再后面是 field : 结构,就判定这是一个 struct literal,否则把 {...} 当作控制流的 block。

这种"基于寻找"(looking ahead)的解析方式正是 RFC 92 要解决的病灶。

动机:前瞻解析为什么脆弱

RFC 92 的 Motivation 部分给出了四条递进的担忧,每一条都指向"用 : 前瞻做特殊判定"这条路径的长期风险:

  1. 类型标注(type ascription)会破坏它。 如果将来允许在类型位置使用 :(例如给表达式标注类型),冒号就不再是 struct literal 的专属特征,前瞻判定会立刻失效。仓库中的 text/0803-type-ascription.md 正是探讨这类"类型标注语法"的提案,可见这一冲突在语言演进中确实被反复触及。
  2. struct literal 自身的语法演化会破坏它。 如果未来允许空 struct 用花括号书写(即 S {} 成为合法 struct literal),或允许 struct literal 把字段名与本地变量名统一(shorthand 语法——S { x } 等价于 S { x: x },这一能力在 struct literal pattern 中早已存在),那么 struct literal 里就不再"必须"出现 :,前瞻判定同样崩溃。RFC 92 指出当时社区已有此类提案,属于高概率的演进方向。
  3. 错误提示质量。 靠特殊判定的解析方式难以给出精准的诊断信息;而用文法层面的子类别约束,可以在解析失败时更清楚地告诉用户"这个位置不允许 struct literal"。
  4. 未来不可预见的功能。 语言演进中可能出现今天无法预测的语法,它们都可能与": 前瞻"这条隐形约定相撞。用正式文法把约束显式化,比依赖一条隐式解析惯例更抗风险。

RFC 92 同时评估了兼容性代价:在 for/if 等位置直接使用 struct literal 作为控制表达式"应该相当罕见"(Hopefully, it is pretty rare),因此破坏性影响面很小;真遇到被破坏的代码,把 struct literal 先赋值给一个变量即可修复。但作者明确承认这是一项向后不兼容的改动(backwards incompatible change),因此它应当阻塞 Rust 1.0 的发布节奏——这体现了语言早期对"文法地基"与"发布里程碑"之间取舍的严肃态度。

详细设计:引入排除 struct literal 的表达式子类别 e'

改造后的文法

RFC 92 的核心提案是把表达式文法拆成两层:

e      ::= e'
         | name `{` (x `:` e)+ `}`
         | `|` pattern* `|` e
         | ...
e'     ::= x
         | e `.` f
         | block
         | `for` e `in` e' block
         | `if` e' block (`else` block)?
         | `|` pattern* `|` e'
         | ...
block  ::=  `{` (e;)* e? `}`

设计要点逐条拆解:

  • e' 就是 e 去掉 struct literal 生产式(production)后的子集。 它仍然包含变量引用、字段访问 e . f、block、控制流表达式、闭包等一切其他表达式,唯独不含 name { x: e }。
  • 凡是"表达式后紧跟 block"的位置,一律改用 e'。 观察 for 表达式:for e in e' block——注意 in 之后的迭代表达式是受限的 e',而循环体是 block;if 表达式同样写成 if e' block。条件表达式后紧跟 then-block,如果允许 struct literal 出现在条件位置,if S { a: 1 } { ... } 就会再次产生歧义,所以条件位置消费的是 e'。
  • 闭包等"元表达式"需要双版本。 RFC 92 特别指出:对于任何"某个子表达式位于词法最后位置"的表达式(上面的简化文法中指闭包,以及一元、二元运算符表达式),需要提供两个版本——放在 e 里的常规版本,和一个把最后那个子表达式替换为 e' 的版本(即放入 e' 的版本)。这样限制才能沿着表达式树向"紧邻 block 的那个子表达式"逐层传导。例如 if x + S { a: 1 } { ... } 这类写法中,加法右侧紧贴 then-block 的子表达式必须落入受限版本,struct literal 依然被排除。
  • e 的生产式以 e' 开头(e ::= e' | ...),意味着 e' 是 e 的真子集:任何受限位置能用的表达式,普通位置都能用;反之 struct literal 只出现在 e 级别的位置。

改造后的效果是:歧义从"解析期的动态特判"变成了"文法期的静态约束"。for e in e' block 里,e' 根本不含 struct literal 生产式,for S { a: 1 } { ... } 这类输入在文法层面就不合法,解析器无需再扫描 : 来猜。

实现路径:RESTRICT_BLOCK 解析模式

RFC 92 还给出了工程实现层面的方案:正式文法的两分法在递归下降解析器中并不要求真的维护两套解析函数,只需在解析器的"限制状态"机制上加一个标志位。原文指出,实现会更简单——只要给 parser::restriction 增加一个叫 RESTRICT_BLOCK(或类似命名)的 flag,它把解析器置入一个"镜像 e' 的解析模式":

  • 解析 e' 位置的表达式时进入该模式;
  • 在普通表达式的复合结构内部,对除最后一个子表达式之外的所有子表达式都退出该模式(因为它们的后面不会紧跟 block,不受限),只在最后那个子表达式处保持该模式。

从源码结构看,这正是当年 Rust 编译器 parser::Parser 中 restriction 机制的典型用法——用"进入/退出限制模式"的显式状态机替代"看到 { 就往前找 :"的隐式前瞻。这种设计也呼应了 Drawbacks 一节的评价:正式文法和解析过程在形式上稍微复杂了一点点,但整体更简单——需要的前瞻更少,也没有了一条需要维护的特殊判定规则。

对现有代码的破坏面与规避方式

由于该改动移除了"条件/迭代表达式位置直接写 struct literal"的合法性,受影响的代码形态大致是:

// 改造前合法、改造后非法:控制表达式位置直接出现 struct literal
for S { a: 1 } { ... }
if S { a: 1 } { ... }

RFC 92 给出的修复路径非常直接:把 struct literal 先绑定到变量,再参与控制流:

let s = S { a: 1 };
for s { ... }      // 迭代器位置
if s.cond { ... }  // 条件位置

或等价地用括号显式分组(这依赖另一条相关的解析约定,见下文"后续影响")。作者对破坏面做了乐观但有依据的估计:这类位置使用 struct literal 的场景"pretty rare",因此 fallout 很小。

备选方案对比:贪婪解析为什么更差

RFC 92 的 Alternatives 一节列出了两种不采纳的路径,对比它们有助于理解为何 e' 子类别是更优解:

  1. 什么都不做(现状)。 继续依赖 : 前瞻。如前所述,它会在 type ascription、空 struct 花括号语法、shorthand 字段名等演进中随时被击穿,且无法给出好的错误诊断。
  2. 贪婪解析(greedy parse)。 允许这些位置出现任意表达式,但约定在这些位置贪婪地解析非终结符:即 for N {} {} 被解析成 for (N {}) {}——把第一个 {} 优先并入迭代表达式,使其成为 struct literal。RFC 92 认为这更糟,理由是概率判断:"一个标识符后紧跟两个 block"(解析成 (for N {}) {},即 N 是迭代器、第一个 block 是循环体)的频率,远高于"这些位置出现 struct literal"的频率。换句话说,贪婪规则把更常见的写法判成了解析错误或错误分组,而 e' 方案恰好保住了更常见的那一侧。

未决问题:限制是否要暴露给解析器之外

RFC 92 的 Unresolved questions 只有一条,但很关键:

Do we need to expose this distinction anywhere outside of the parser? E.g., macros?

即"e 与 e' 的区分是否需要在解析器之外暴露,比如在宏系统中"。从后来仓库中同类 RFC 的表述可以推断,这个问题在实践中以"每条受限位置各自重申限制"的方式处理:新引入的、表达式后接 block 的语法都会在文法说明中明确"此处表达式不含 struct literal"。例如:

  • text/0160-if-let.md(if let)规定其条件表达式"restricted to disallow a trailing braced block (e.g. for struct literals) the same way the expression in the normal if statement is, to avoid ambiguity with the then-block"——if let Some(x) = S { a: 1 } { ... } 中的 S { a: 1 } 同样不合法,与 if 的限制完全一致。
  • text/0809-box-and-in-for-stdlib.md(box 与 placement in)在定义 placement 语法 in <place-expr> { <block> } 时直接引用本 RFC 作为机制依据:当 <place-expr> 只是标识符时,<place-expr> { <block> } 不会被解析为 struct literal,实现手段"restrict <place-expr> to not include struct literals (see RFC 92)"。

这表明 RFC 92 提出的不只是当年的一次解析器修补,而是一个可复用的文法约定模板:凡是新增"表达式 + block"形态的语法,都应当沿用"表达式位置排除 struct literal"的子类别约束,而非各自发明消歧规则。

历史定位:从前瞻特判到正式文法约束的完整闭环

仓库中 text/0218-empty-struct-with-braces.md 的附录补全了这条线索的"前史",值得结合阅读。它记录了 Rust 更早期(2013 年前后)处理同一歧义的方式:当时 match x {} ... 会被解析为 match (x {}) ...,if x {} 的条件就是 struct literal x {}——消歧依据是"struct literal 内部必须至少有一个带标签的字段(即必须有 :)",而这正是 RFC 92 所批评的前瞻式判定。最终社区选择了"移除空 struct 的 S {} 构造语法"这一当时最省事的权宜之计(most expedient option),而明确没有选择"在 { 终止表达式的位置加解析限制、要求 struct literal 必须加括号"的方案。

此后情况发生了变化:解析器层面正式采纳了 RFC 92 所述的限制规则。RFC 218 明确指出,正因为"已经引入了一条 Rust 文法限制,在这些上下文中必须用括号消解 struct literal 歧义",当年驱动禁用 S {} 的解析歧义"no longer present",允许 struct S {} / S {} 语法回归才不会引入新的歧义。它给出的典型用法是 for e in (S {x: 3}) { ... } 与 match (S {x: 3}) { ... }——在受限位置确实需要 struct literal 时,用括号把它整体括起来,把它变成一个不受 e' 约束的普通 e 表达式,这是该限制在用户侧的标准规避手段。

由此可以完整还原这条演进链:

  1. 早期:name { ... } 与 name block 歧义,靠"内部必须出现 :"的前瞻特判 + 禁用 S {} 空花括号语法维持运转;
  2. RFC 92:把约束正式化——定义 e'(不含 struct literal 的表达式子类别),for/if/闭包等"表达式后接 block"的语法改消费 e',解析器以 RESTRICT_BLOCK 模式标志实现,彻底移除 : 前瞻;
  3. 后续:新语法(if let、placement in 等)沿用同一子类别约定;空 struct 花括号语法得以在不再引入歧义的前提下回归(text/0218-empty-struct-with-braces.md);受限位置需要 struct literal 时用括号消歧。

小结

RFC 92 用一次很小的文法手术解决了一个会在语言长期演进中反复爆雷的解析隐患:

  • 问题:e block 与 name { x: e } 的词法歧义,早期靠前瞻查找 : 特判;
  • 方案:拆出 e' 表达式子类别,"表达式后紧跟 block(或其首个终结符可为 block 的非终结符)"的位置一律消费 e';复合表达式提供"末位子表达式受限"的双版本;
  • 实现:parser::restriction 增加 RESTRICT_BLOCK 类模式标志,进入/退出受限模式替代前瞻;
  • 代价:正式文法稍复杂,且向后不兼容(罕见位置直接写 struct literal 的代码需改写,故应阻塞 1.0);
  • 收益:消除对 : 的隐式依赖,为 type ascription、空 struct 花括号、字段名 shorthand 等演进扫清文法障碍,并沉淀为一个可被后续 RFC(text/0160-if-let.md、text/0809-box-and-in-for-stdlib.md)直接引用的语法约束模板。

对阅读 Rust 文法或实现 Rust 系解析器的开发者而言,这份 RFC 的价值在于示范了一个通用模式:当一个语法构造与词法相邻符号天然冲突时,优先在文法层面显式定义受限子类别,而不是在解析器里堆特殊判定的前瞻逻辑。

延伸阅读:lang_changes.md(语言类 RFC 的治理流程,RFC 92 属于其中需走完整流程的"语言语义或语法变更")、text/0092-struct-grammar.md(本文所依据的 RFC 原文)。

登录后查看全文
rfcs