1
// 源码
2
func loadData() async throws -> String {
3
    let uid = try await fetchUserID()        // await-1
4
    let profile = try await fetchProfile(uid) // await-2
5
    return profile.name
6
}

1
// ⬢ 每个 async 函数对应一个上下文帧（放在堆上）
2
typedef struct {
3
    SwiftAsyncContext header;   // Swift 运行时代码生成的公共头
4
    uint8_t   state;           // 状态机标签
5
    Error    *error;           // 异常槽
6
    String    result;          // 返回值槽
7
    /* 持久化的局部 */
8
    UserID    uid;
9
    Profile   profile;
10
} LoadDataContext;
11

12
/* 编译器展开后的实现，swiftasync 调用约定 */
13
void loadData_swiftasync(LoadDataContext *ctx) {
14
  switch (ctx->state) {
15

16
    case 0: { // 初始态
17
      /* 将“后续步骤”封装成 continuation，传给被等待的函数 */
18
      ctx->state = 1;
19
      fetchUserID_swiftasync(/*continuation=*/ctx);
20
      return;                           // ⬅️ 挂起，线程可去干别的
21
    }
22

23
    case 1: { // await-1 恢复点
24
      if (ctx->error) goto fail;        // fetchUserID 报错
25
      ctx->uid = ctx->header.resume_val;
26
      ctx->state = 2;
27
      fetchProfile_swiftasync(ctx);     // 第二个 await
28
      return;
29
    }
30

31
    case 2: { // await-2 恢复点
32
      if (ctx->error) goto fail;        // fetchProfile 报错
33
      ctx->profile = ctx->header.resume_val;
34
      ctx->result = ctx->profile.name;  // 计算最终返回值
35
      swift_async_return(ctx);          // 触发最外层 .value
36
      return;
37
    }
38
  }
39

40
fail:
41
  swift_async_throw(ctx, ctx->error);   // 向上传播 try/catch
42
}

1
// #[allow(…)]: 仅演示
2
enum LoadDataFuture {               // 状态枚举
3
    Step0,
4
    Step1 { fut_uid: FetchUserID }, // 持久化局部 = 字段
5
    Step2 { uid: UserID, fut_prof: FetchProfile },
6
    Done(Result<String, Error>),
7
}
8

9
impl Future for LoadDataFuture {
10
    type Output = Result<String, Error>;
11

12
    fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>)
13
        -> Poll<Self::Output> {
14

15
        loop {
16
            match *self {
17
                LoadDataFuture::Step0 => {
18
                    let fut = fetch_user_id();              // 创建子 future
19
                    *self = LoadDataFuture::Step1 { fut_uid: fut };
20
                }
21

22
                LoadDataFuture::Step1 { ref mut fut_uid } => {
23
                    match fut_uid.poll(cx) {
24
                        Poll::Pending => return Poll::Pending, // 挂起
25
                        Poll::Ready(id) => {
26
                            let fut = fetch_profile(id?);
27
                            *self = LoadDataFuture::Step2 { uid: id?, fut_prof: fut };
28
                        }
29
                    }
30
                }
31

32
                LoadDataFuture::Step2 { ref mut fut_prof, .. } => {
33
                    match fut_prof.poll(cx) {
34
                        Poll::Pending => return Poll::Pending,
35
                        Poll::Ready(profile) => {
36
                            *self = LoadDataFuture::Done(Ok(profile?.name));
37
                            return Poll::Ready(Ok(profile?.name));
38
                        }
39
                    }
40
                }
41

42
                LoadDataFuture::Done(ref out) => return Poll::Ready(out.clone()),
43
            }
44
        }
45
    }
46
}