Diem Move 语言循环完全指南:while、loop、break 与 continue 的语法、类型与源码实现
Diem Move 语言循环完全指南:while、loop、break 与 continue 的语法、类型与源码实现
导读
本文是 Diem 区块链的 Move 智能合约语言编程指南系列之一,完整讲解 Move 中仅有的两种循环构造 while 与 loop,以及配套的 break、continue 表达式。读完本文,你将掌握 Move 循环的完整语法、break/continue 独有的"任意类型"灵活语义、while/loop 表达式本身的类型规则,并能结合源码理解循环从解析、类型检查到中间表示(HLIR/CFGIR)的完整编译路径。文中的所有代码示例与结论均可直接用于编写可编译的 Move 模块与脚本。
Move 中的循环构造概览
Move 语言(本仓库中位于 language/ 目录)为开发者提供了两种循环构造:
while循环:先判断布尔条件,条件为true时重复执行循环体;loop表达式:无条件反复执行循环体,直到在循环体内遇到break。
两者都以"表达式"(expression)而非"语句"的形式存在——这在 Move 中是一个重要事实,因为 Move 中几乎一切都是表达式,循环也不例外,它们的类型规则会在后文专门讨论。
while 循环
while 构造的语法为 while (condition) body,其中:
condition必须是类型为bool的表达式;body(循环体)必须是类型为 unit(即())的表达式。
循环体被反复执行,直到条件求值结果为 false。
下面的示例是一个简单的 while 循环,计算从 1 到 n 的整数之和:
fun sum(n: u64): u64 {
let sum = 0;
let i = 1;
while (i <= n) {
sum = sum + i;
i = i + 1
};
sum
}
注意示例中的两个细节:
while的条件(i <= n)必须用圆括号包裹(语法解析层面的强制要求,详见下文源码分析);- 循环体内部最后一条表达式
i = i + 1之后没有分号,整个while表达式以分号;结束,然后函数返回sum。
无限循环是合法的
只要条件永远不为 false,while 就会一直执行下去。Move 允许无限循环存在:
fun foo() {
while (true) { }
}
无限循环(以及下文的无 break 的 loop)在类型系统中属于"发散"表达式,Move 编译器会依据其类型规则做出特殊处理,这一点在 while 与 loop 的类型一节中会详细展开。
break:提前退出循环
break 表达式用于在条件尚未求值为 false 时提前退出循环。
例如,下面的循环使用 break 找到 n 的大于 1 的最小因子:
fun upper_bound_sqrt(n: u64): u64 {
// assuming the input is not 0 or 1
let i = 2;
while (i <= n) {
if (n % i == 0) break;
i = i + 1
};
i
}
当 n % i == 0 成立时,break 立即终止 while 循环,此时 i 就是 n 的最小因子,函数返回该值。
使用限制:break 表达式不能用在循环之外。这一点不仅在文档层面声明,也在编译器的类型检查阶段强制实施——见下文"源码实现"中的 LoopInfo 追踪机制。
continue:跳过本次迭代剩余部分
continue 表达式会跳过循环体的剩余部分,直接进入下一次迭代。
下面的循环计算 1, 2, ..., n 之和,但跳过所有能被 10 整除的数:
fun sum_intermediate(n: u64): u64 {
let sum = 0;
let i = 1;
while (i <= n) {
if (i % 10 == 0) continue;
sum = sum + i;
i = i + 1
};
sum
}
当 i % 10 == 0 时,continue 会让控制流直接回到循环条件判断,跳过 sum = sum + i 与 i = i + 1。
使用限制:与 break 相同,continue 表达式也不能用在循环之外。
break 与 continue 的类型:Move 独有的灵活性
这是 Move 循环最值得注意的语言特性之一:break 和 continue,就像 return 和 abort 一样,可以具有任意类型。
这意味着它们可以作为任意需要值的表达式位置出现,而不会产生类型错误。下面的两个示例展示了这种灵活类型的实际用途。
示例一:break 具有任意类型
下面的函数同时从两个向量(vector)尾部弹出元素,每次取出较小的那个,直到两个向量有一个为空,返回收集结果的向量:
fun pop_smallest_while_not_equal(
v1: vector<u64>,
v2: vector<u64>,
): vector<u64> {
let result = Vector::empty();
while (!Vector::is_empty(&v1) && !Vector::is_empty(&v2)) {
let u1 = *Vector::borrow(&v1, Vector::length(&v1) - 1);
let u2 = *Vector::borrow(&v1, Vector::length(&v1) - 1);
let popped =
if (u1 < u2) Vector::pop_back(&mut v1)
else if (u2 < u1) Vector::pop_back(&mut v2)
else break; // Here, `break` has type `u64`
Vector::push_back(&mut result, popped);
};
result
}
关键点在于注释标注的位置:let popped = ... else break;。在这个上下文中,if-else 表达式期望产生一个 u64 类型的值,而 break 被赋予了类型 u64,因此类型检查可以通过。
示例二:continue 具有任意类型
fun pick(
indexes: vector<u64>,
v1: &vector<address>,
v2: &vector<address>
): vector<address> {
let len1 = Vector::length(v1);
let len2 = Vector::length(v2);
let result = Vector::empty();
while (!Vector::is_empty(&indexes)) {
let index = Vector::pop_back(&mut indexes);
let chosen_vector =
if (index < len1) v1
else if (index < len2) v2
else continue; // Here, `continue` has type `&vector<address>`
Vector::push_back(&mut result, *Vector::borrow(chosen_vector, index))
};
result
}
同理,这里 if-else 需要产生一个 &vector<address> 类型的引用,continue 被赋予该类型,于是合法。
这种设计背后的原理是:break、continue(以及 return、abort)是"发散"(diverging)控制流,它们永远不会正常地"产生"一个值,因此可以兼容任何预期类型——这与许多现代编程语言中的 bottom type(如 Rust 的 !)思想一致。Move 文档中明确说明 break/continue 的类型约束与 return/abort 相同。
loop 表达式
loop 表达式会反复执行循环体(类型为 () 的表达式),直到遇到 break。它的语法是 loop body,与 while 不同,loop 不需要也不允许在关键字后写括号条件——它本身就是无条件的。
没有 break 时永不停止
fun foo() {
let i = 0;
loop { i = i + 1 }
}
上面的 loop 没有 break,会无限执行下去。
用 loop 重写 sum
下面是用 loop 实现前文 sum 函数的版本,通过 if (i > n) break; 主动退出:
fun sum(n: u64): u64 {
let sum = 0;
let i = 0;
loop {
i = i + 1;
if (i > n) break;
sum = sum + i
};
sum
}
在 loop 中使用 continue
continue 同样可以用于 loop。前文的 sum_intermediate(跳过被 10 整除的数)用 loop 改写如下:
fun sum_intermediate(n: u64): u64 {
let sum = 0;
let i = 0;
loop {
if (i % 10 == 0) continue;
i = i + 1;
if (i > n) break;
sum = sum + i
};
sum
}
注意这个版本与 while 版本在语义上的细微差别:由于 continue 会直接跳到下一次迭代的开头,这里把 i = i + 1 放在 continue 之后、break 判断之前,确保被 continue 跳过的迭代不会漏掉递增。这个例子也提醒我们:在改写循环构造时,continue 的跳转位置会直接影响变量更新的时机。
while 与 loop 的类型
Move 的循环是"有类型的表达式"(typed expressions),理解这一点对编写类型正确的代码至关重要。
while 表达式的类型永远是 ()
无论循环体是什么,while 表达式整体始终具有 unit 类型:
let () = while (i < 10) { i = i + 1 };
上面的 let () = ... 语法明确将 while 表达式的类型绑定为 (),这是合法的。
含 break 的 loop 类型为 ()
如果 loop 中包含 break,那么该 loop 表达式的类型就是 unit ():
(loop { if (i < 10) i = i + 1 else break }: ());
let () = loop { if (i < 10) i = i + 1 else break };
第一行用显式类型标注 : () 断言,第二行用 let () = ... 绑定验证。
无 break 的 loop 具有任意类型
如果 loop 中没有 break,那么它永远不会正常结束,属于发散表达式,可以具有任何类型——这与 return、abort、break、continue 的行为一致:
(loop (): u64);
(loop (): address);
(loop (): &vector<vector<u8>>);
同一个 loop () 可以分别被断言为 u64、address 甚至嵌套引用类型 &vector<vector<u8>>,全部合法。这个特性可用于"已知不会返回"的占位位置。
源码实现:从语法解析到控制流表示
本文档所在仓库的 Move 语言编译器实现(language/move-lang/)完整支撑了上述语法与类型规则。下面沿着编译管线梳理循环相关的实现证据。
语法解析:while 必须带括号,loop 直接跟表达式
在 语言解析器 中,parse_exp 函数对两种循环的解析逻辑非常清晰:
- 遇到
Tok::While时,先consume_token(tokens, Tok::LParen)消费左括号,解析条件表达式后再消费右括号,最后解析循环体,构造Exp_::While(eb, eloop); - 遇到
Tok::Loop时,直接解析循环体表达式,构造Exp_::Loop(eloop),不需要括号。
对应地,语法 AST 定义 中:
While(Box<Exp>, Box<Exp>),
Loop(Box<Exp>),
While 携带两个表达式(条件与循环体),Loop 只携带一个表达式。这从语法层面解释了为什么 while 的条件必须用圆括号包裹,而 loop 不能带条件。
类型检查:break/continue 必须位于循环内部
在类型检查阶段,编译器需要确认 break 与 continue 没有被用在循环之外。从 类型检查核心 的实现可以看到一个专门的追踪机制:
LoopInfo_::NotInLoop => panic!("ICE exit_loop called while not in a loop"),
类型检查器通过维护循环上下文信息(LoopInfo)来判断 break/continue 是否合法:只有当当前正处于某个循环内部时,"退出循环"操作才是被允许的;否则会触发内部错误。这正是文档中"break 表达式不能用在循环之外""continue 表达式不能用在循环之外"两条规则的编译器级保障。
中间表示:HLIR 中的循环节点与跳转命令
解析与类型检查之后,循环会被翻译到高层中间表示 HLIR。在 HLIR AST 定义 中可以看到循环的正式表示:
pub enum Statement_ {
...
While {
cond: (Block, Box<Exp>),
block: Block,
},
Loop {
block: Block,
has_break: bool,
},
...
}
pub enum Command_ {
...
Break,
Continue,
...
}
两个值得注意的实现细节:
Loop节点带有has_break标记:HLIR 在翻译loop时会记录该循环体内是否出现过break,这个标记正是前文"含break的loop类型为()、无break的loop可以是任意类型"这一类型规则的直接依据;Break与Continue被建模为命令(Command):它们与Abort、Return并列,在后续的 CFGIR(控制流图中间表示)阶段会被转换为基本块之间的跳转,最终映射到底层字节码中的分支指令。
在 HLIR 翻译器 中可以看到 Exp_::While、Exp_::Loop、TE::Break、TE::Continue 分别被转换为上述 HLIR 语句与命令的过程。
测试用例:循环语义的正确性验证
仓库中提供了大量与循环相关的编译测试,用于验证上述语义。这些测试分布在 language/move-lang/tests/move_check/ 目录下:
- control_flow/infinite_loop_with_dead_exits.move:验证无限循环中
break、return等退出路径的合法性; - liveness/trailing_semi_loops.move:覆盖
loop表达式的类型断言(如(loop (): ()))、break/continue在分支中的组合以及尾随分号场景; - parser/expr_loop_braces.move:验证
loop的花括号语法解析; - locals/use_after_move_loop.move 与 locals/use_after_move_while.move:验证循环内的变量使用(use-after-move)分析,确保 Move 的所有权规则在循环跨迭代场景下仍然成立;
- locals/use_before_assign_loop.move 与 locals/use_before_assign_while.move:验证循环内的"先使用后赋值"检测。
特别值得关注的是 liveness/trailing_semi_loops.move 中的这段用例,它同时覆盖了 loop 的类型断言、continue/break 在条件分支中的使用,以及循环体变量在退出后的延续使用:
script {
fun main(cond: bool) {
let x;
loop {
if (cond) {
x = 1;
break
} else {
x = 2;
continue
};
};
x;
}
}
这里 loop 中同时存在 break 与 continue,两个分支都先为 x 赋值;循环退出后 x 被继续使用——类型检查器需要能够证明无论走哪条路径,x 都已被初始化。这正是 Move 控制流分析在循环场景下的核心验证目标。
小结与实践要点
- Move 只有两种循环构造:
while (cond) body与loop body,且它们都是表达式; while的条件必须是bool类型、必须用圆括号包裹,循环体类型必须为();loop无条件执行,只能通过循环体内的break退出;break与continue只能出现在循环内部(编译器通过LoopInfo上下文强制检查);break、continue与return、abort一样,可以具有任意类型,可在需要特定类型值的位置使用;while表达式的类型恒为();含break的loop类型为();无break的loop(发散)可以是任意类型;- 改写循环构造时要注意
continue的跳转位置对循环体变量更新时机的影响。
掌握这些规则,你就能在 Diem Move 智能合约中安全、高效地编写各种循环逻辑,并理解其背后的编译期保证。