Explicitly mark main queue helper block

Sources/Extensions/CPListItem+Kingfisher.swift

@@ -180,7 +180,7 @@ extension KingfisherWrapper where Base: CPListItem {
             },
             referenceTaskIdentifierChecker: { issuedIdentifier == self.taskIdentifier },
             completionHandler: { result in
-                CallbackQueue.mainCurrentOrAsync.execute { @MainActor in
+                CallbackQueueMain.currentOrAsync {
                     guard issuedIdentifier == self.taskIdentifier else {
                         let reason: KingfisherError.ImageSettingErrorReason
                         do {

Sources/Extensions/ImageView+Kingfisher.swift

@@ -326,7 +326,7 @@ extension KingfisherWrapper where Base: KFCrossPlatformImageView {
             progressiveImageSetter: { self.base.image = $0 },
             referenceTaskIdentifierChecker: { issuedIdentifier == self.taskIdentifier },
             completionHandler: { result in
-                CallbackQueue.mainCurrentOrAsync.execute { @MainActor in
+                CallbackQueueMain.currentOrAsync {
                     maybeIndicator?.stopAnimatingView()
                     guard issuedIdentifier == self.taskIdentifier else {
                         let reason: KingfisherError.ImageSettingErrorReason

Sources/Extensions/NSTextAttachment+Kingfisher.swift

@@ -196,7 +196,7 @@ extension KingfisherWrapper where Base: NSTextAttachment {
             progressiveImageSetter: { self.base.image = $0 },
             referenceTaskIdentifierChecker: { issuedIdentifier == self.taskIdentifier },
             completionHandler: { result in
-                CallbackQueue.mainCurrentOrAsync.execute { @MainActor in
+                CallbackQueueMain.currentOrAsync {
                     guard issuedIdentifier == self.taskIdentifier else {
                         let reason: KingfisherError.ImageSettingErrorReason
                         do {

Sources/Extensions/UIButton+Kingfisher.swift

@@ -143,7 +143,7 @@ extension KingfisherWrapper where Base: UIButton {
             progressiveImageSetter: { self.base.setImage($0, for: state) },
             referenceTaskIdentifierChecker: { issuedIdentifier == self.taskIdentifier(for: state) },
             completionHandler: { result in
-                CallbackQueue.mainCurrentOrAsync.execute { @MainActor in
+                CallbackQueueMain.currentOrAsync {
                     guard issuedIdentifier == self.taskIdentifier(for: state) else {
                         let reason: KingfisherError.ImageSettingErrorReason
                         do {
@@ -300,7 +300,7 @@ extension KingfisherWrapper where Base: UIButton {
             progressiveImageSetter: { self.base.setBackgroundImage($0, for: state) },
             referenceTaskIdentifierChecker: { issuedIdentifier == self.backgroundTaskIdentifier(for: state) },
             completionHandler: { result in
-                CallbackQueue.mainCurrentOrAsync.execute { @MainActor in
+                CallbackQueueMain.currentOrAsync {
                     guard issuedIdentifier == self.backgroundTaskIdentifier(for: state) else {
                         let reason: KingfisherError.ImageSettingErrorReason
                         do {

Sources/SwiftUI/ImageBinder.swift

@@ -67,7 +67,7 @@ extension KFImage {
 
         func start<HoldingView: KFImageHoldingView>(context: Context<HoldingView>) {
             guard let source = context.source else {
-                CallbackQueue.mainCurrentOrAsync.execute { @MainActor in
+                CallbackQueueMain.currentOrAsync {
                     context.onFailureDelegate.call(KingfisherError.imageSettingError(reason: .emptySource))
                     if let image = context.options.onFailureImage {
                         self.loadedImage = image
@@ -93,14 +93,14 @@ extension KFImage {
 
                         guard let self else { return }
 
-                        CallbackQueue.mainCurrentOrAsync.execute { @MainActor in
+                        CallbackQueueMain.currentOrAsync {
                             self.downloadTask = nil
                             self.loading = false
                         }
                         
                         switch result {
                         case .success(let value):
-                            CallbackQueue.mainCurrentOrAsync.execute { @MainActor in
+                            CallbackQueueMain.currentOrAsync {
                                 if let fadeDuration = context.fadeTransitionDuration(cacheType: value.cacheType) {
                                     self.animating = true
                                     let animation = Animation.linear(duration: fadeDuration)
@@ -115,18 +115,18 @@ extension KFImage {
                                 self.animating = false
                             }
 
-                            CallbackQueue.mainAsync.execute {  @MainActor in
+                            CallbackQueueMain.async {
                                 context.onSuccessDelegate.call(value)
                             }
                         case .failure(let error):
-                            CallbackQueue.mainCurrentOrAsync.execute { @MainActor in
+                            CallbackQueueMain.currentOrAsync {
                                 if let image = context.options.onFailureImage {
                                     self.loadedImage = image
                                 }
                                 self.markLoaded(sendChangeEvent: false)
                             }
                             
-                            CallbackQueue.mainAsync.execute { @MainActor in
+                            CallbackQueueMain.async {
                                 context.onFailureDelegate.call(error)
                             }
                         }

Sources/Utility/CallbackQueue.swift

@@ -49,11 +49,9 @@ public enum CallbackQueue: Sendable {
     public func execute(_ block: @Sendable @escaping () -> Void) {
         switch self {
         case .mainAsync:
-            Task {
-                await MainActor.run { block() }
-            }
+            CallbackQueueMain.async { block() }
         case .mainCurrentOrAsync:
-            DispatchQueue.main.safeAsync { block() }
+            CallbackQueueMain.currentOrAsync { block() }
         case .untouch:
             block()
         case .dispatch(let queue):
@@ -71,15 +69,16 @@ public enum CallbackQueue: Sendable {
     }
 }
 
-extension DispatchQueue {
-    // This method will dispatch the `block` to self.
-    // If `self` is the main queue, and current thread is main thread, the block
-    // will be invoked immediately instead of being dispatched.
-    func safeAsync(_ block: @Sendable @escaping () -> Void) {
-        if self === DispatchQueue.main && Thread.isMainThread {
-            block()
+enum CallbackQueueMain {
+    static func currentOrAsync(_ block: @MainActor @Sendable @escaping () -> Void) {
+        if Thread.isMainThread {
+            MainActor.assumeIsolated { block() }
         } else {
-            async { block() }
+            DispatchQueue.main.async { block() }
         }
     }
+    
+    static func async(_ block: @MainActor @Sendable @escaping () -> Void) {
+        DispatchQueue.main.async { block() }
+    }
 }