Ios swift – SWIFT TASK CONTINUATION MISUSE: – method leaked its continuation! – Not blocking main thread?

You said:

But the call to the external lib sometimes prints SWIFT TASK CONTINUATION MISUSE: leaked its continuation, which means its completion will not be called if I understood correctly, and the code after this is not executed. It happens especially when I spam the button.

The library apparently does not handle concurrent requests.

This will happen if the library saves your completion-handler closures in properties, which are replaced with new closures when you call it concurrently. This is a mistake on the part of the library and it should either (a) not permit concurrent requests, immediately calling the error completion hander if one attempts to do so; or (b) be modified to support concurrent requests.

I would advise opening a ticket with he provider of that library. But until it is remedied, it is your responsibility to prevent concurrent requests. There are a variety of approaches:

1. The easiest way would be to disable the button:

   func onButtonTap(_ button: UIButton) {
       button.isEnabled = false
   
       Task {
           defer { button.isEnabled = true }
   
           do {
               try await callExternalLib()
           } catch {
               …
           }
       }
   }
   

2. If you quickly tap the button, say, five times and you really want the external library to run its routine five times, then you would want to make your tasks to run sequentially. The easiest way to do this would be an AsyncChannel from the Swift Async Algorithms package.

   So, you’d create a channel:

   let channel = AsyncChannel<Void>()
   

   You would monitor that channel:

   for try await _ in channel {
       try await callExternalLib()
   }
   

   And then, on a button tap, you would send to your channel:

   func onButtonTap(_ button: UIButton) {
       Task { await self.channel.send(()) }
   }
   

   So, a full MRE of this pattern would be:

   import UIKit
   import AsyncAlgorithms
   
   class ViewController: UIViewController {
       var monitorTask: Task<Void, any Error>?
       let externalLibrary = ExternalLibrary()
       let channel = AsyncChannel<Void>()
   
       override func viewDidAppear(_ animated: Bool) {
           super.viewDidAppear(animated)
   
           startMonitoring()
       }
   
       override func viewDidDisappear(_ animated: Bool) {
           super.viewDidDisappear(animated)
   
           stopMonitoring()
       }
   
       @IBAction func onButtonTap(_ button: UIButton) {
           Task { await self.channel.send(()) }
       }
   }
   
   // MARK: - Private implementation
   
   private extension ViewController {
       func startMonitoring() {
           guard monitorTask == nil else { return } // if accidentally called when already running, don’t start again, losing reference to old task
   
           monitorTask = Task {
               for try await _ in channel {
                   try await callExternalLib()
               }
           }
       }
   
       func stopMonitoring() {
           monitorTask?.cancel()
           monitorTask = nil
       }
   
       func callExternalLib() async throws {
           try await withCheckedThrowingContinuation { continuation in
               externalLibrary.doSomething {
                   continuation.resume()
               } onFailure: { error in
                   continuation.resume(throwing: error)
               }
           }
       }
   }
   
   // MARK: - ExternalLibrary
   
   class ExternalLibrary {
       private var successClosure: (() -> Void)?
       private var failureClosure: ((any Error) -> Void)?
   
       func doSomething(onSuccess: @escaping () -> Void, onFailure: @escaping (any Error) -> Void) {
           successClosure = onSuccess
           failureClosure = onFailure
   
           DispatchQueue.main.asyncAfter(deadline: .now() + 10) { [self] in
               successClosure?()
               successClosure = nil
               failureClosure = nil
           }
       }
   }
   

   The only interesting thing to note here is that you do not want to rely upon deinit to cancel your asynchronous sequence, but rather start the monitoring of the channel when the view appears and cancel it when the view is ultimately dismissed.

3. The third approach would be to cancel the previous doSomething before submitting another. When wrapping the completion-handler-closure-based call in a withCheckedThrowingContinuation, you’d also wrap that in a withTaskCancellationHandler. E.g.,

   class ViewController: UIViewController {
       var externalLibraryTask: Task<Void, any Error>?
       let externalLibrary = ExternalLibrary()
   
       @IBAction func onButtonTap(_ button: UIButton) {
           externalLibraryTask?.cancel()
   
           externalLibraryTask = Task {
               try await self.callExternalLib()
           }
       }
   }
   
   // MARK: - Private implementation
   
   private extension ViewController {
       func callExternalLib() async throws {
           try await withTaskCancellationHandler {
               try await withCheckedThrowingContinuation { continuation in
                   externalLibrary.doSomething {
                       continuation.resume()
                   } onFailure: { error in
                       continuation.resume(throwing: error)
                   }
               }
           } onCancel: {
               …
           }
       }
   }
   

   But, this pattern only works if the external library supports cancellation at all. I might wager that if they failed to handle something as basic as concurrent requests, they probably have not contemplated cancellation support, either. We simply cannot comment further without more details about this external library.

   But, I include this for the sake of completeness.

To answer your follow-up questions:

My first question is, why can I still use the main thread if the code
after is never executed ? Shouldn’t the main thread be blocked there
waiting for it’s completion ?

No, an await does not block an actor. It suspends the current function’s execution, but frees the actor to carry on and do other work. Actors are “reentrant”. See Actor Reentrancy in SE-0306.

My second question is, how does the system know that the completion
will never be called ? Does it track if the completion is retained in
the external lib at runtime, if the owner of the reference dies, it
raises this leak warning?

When the last reference to the continuation is removed (i.e., the third party library releases those closures), the system verifies whether the continuation has been called or not. If not, you get this warning.

My third question is, could this lead to a crash ? Or the system just
cancel the Task and I shouldn’t worry about it ?

If you used the “unsafe” rendition, withUnsafe[Throwing]Continuation it would crash. It will not crash when using the “checked” rendition.

But that does not mean you should not fix it. See SE-0300, which says:

Instead of leading to undefined behavior, CheckedContinuation will instead trap if the program attempts to resume the continuation multiple times. CheckedContinuation will also log a warning if the continuation is discarded without ever resuming the task, which leaves the task stuck in its suspended state, leaking any resources it holds.

Bottom line, you want to heed the warning and resolve the issue.