코루틴 내부 동작 — CPS 변환과 상태 머신이 suspend를 가능하게 하는 원리

public interface Continuation<in T> {
    public val context: CoroutineContext
    public fun resumeWith(result: Result<T>)
}

// 우리가 작성한 코드
suspend fun fetchUser(id: Long): User { /* ... */ }

// 컴파일 후 (개념적)
fun fetchUser(id: Long, continuation: Continuation<User>): Any? { /* ... */ }

// 원본 코드
suspend fun loadUserData(userId: Long): UserData {
    val user = fetchUser(userId)       // 중단점 1
    val posts = fetchPosts(user.id)     // 중단점 2
    val friends = fetchFriends(user.id) // 중단점 3
    return UserData(user, posts, friends)
}

fun loadUserData(userId: Long, cont: Continuation<UserData>): Any? {
    // 상태 머신을 담는 Continuation 구현체
    val sm = cont as? LoadUserDataContinuation
        ?: LoadUserDataContinuation(cont)

    when (sm.label) {
        0 -> {
            sm.label = 1
            val result = fetchUser(userId, sm)
            if (result == COROUTINE_SUSPENDED) return COROUTINE_SUSPENDED
            sm.user = result as User
        }
        1 -> {
            sm.user = sm.result as User
            sm.label = 2
            val result = fetchPosts(sm.user.id, sm)
            if (result == COROUTINE_SUSPENDED) return COROUTINE_SUSPENDED
            sm.posts = result as List<Post>
        }
        2 -> {
            sm.posts = sm.result as List<Post>
            sm.label = 3
            val result = fetchFriends(sm.user.id, sm)
            if (result == COROUTINE_SUSPENDED) return COROUTINE_SUSPENDED
            sm.friends = result as List<User>
        }
        3 -> {
            sm.friends = sm.result as List<User>
            return UserData(sm.user, sm.posts, sm.friends)
        }
    }
    // 다음 상태로 진행
    return loadUserData(userId, sm) // 재귀적으로 다음 상태 실행
}

suspend fun simpleSuspend(): String {
    val a = suspendFunction1()
    val b = suspendFunction2(a)
    return b
}

public static final Object simpleSuspend(Continuation<? super String> $completion) {
    // Continuation 구현체 생성 또는 재사용
    SimpleSuspendContinuation cont;
    if ($completion instanceof SimpleSuspendContinuation) {
        cont = (SimpleSuspendContinuation) $completion;
        // 재진입 확인
    } else {
        cont = new SimpleSuspendContinuation($completion);
    }

    Object result = cont.result;
    Object SUSPENDED = IntrinsicsKt.getCOROUTINE_SUSPENDED();

    switch (cont.label) {
        case 0:
            cont.label = 1;
            Object a = suspendFunction1(cont);
            if (a == SUSPENDED) return SUSPENDED;
            // fall-through
        case 1:
            String a = (String) result;
            cont.label = 2;
            Object b = suspendFunction2(a, cont);
            if (b == SUSPENDED) return SUSPENDED;
            // fall-through
        case 2:
            return (String) result;
        default:
            throw new IllegalStateException("call to 'resume' before 'invoke'");
    }
}

suspend fun fetchFromNetwork(url: String): Response =
    suspendCancellableCoroutine { continuation ->
        val call = httpClient.newCall(Request.Builder().url(url).build())

        call.enqueue(object : Callback {
            override fun onResponse(call: Call, response: Response) {
                continuation.resume(response) // 성공 시 재개
            }

            override fun onFailure(call: Call, e: IOException) {
                continuation.resumeWithException(e) // 실패 시 예외와 함께 재개
            }
        })

        // 코루틴 취소 시 네트워크 요청도 취소
        continuation.invokeOnCancellation {
            call.cancel()
        }
    }

suspend fun cachedFetch(id: Long): User {
    val cached = cache[id]
    if (cached != null) return cached // 중단 없이 바로 반환

    val user = fetchFromDb(id) // 여기서만 중단 가능
    cache[id] = user
    return user
}

// Dispatchers.IO의 개념적 동작
class IoDispatcher : ContinuationInterceptor {
    override fun <T> interceptContinuation(
        continuation: Continuation<T>
    ): Continuation<T> {
        return DispatchedContinuation(this, continuation)
    }
}

// 콜백 방식 — 3개의 콜백 객체 생성
fetchUser(id) { user ->
    fetchPosts(user.id) { posts ->
        fetchFriends(user.id) { friends ->
            callback(UserData(user, posts, friends))
        }
    }
}

// 코루틴 — 1개의 상태 머신 객체
suspend fun loadUserData(id: Long): UserData {
    val user = fetchUser(id)
    val posts = fetchPosts(user.id)
    val friends = fetchFriends(user.id)
    return UserData(user, posts, friends)
}