Swift Compiler Crash With WKUIDelegate And Async/Await

Hey guys! Let's dive into a head-scratcher that's been bugging a few of us in the Swift community. We've got a compiler crash related to using async/await within a WKUIDelegate implementation. Specifically, it happens when trying to forward a call to a legacy delegate. Sounds fun, right?

The Core Issue: IRGen Crash

So, what's the deal? Well, the Swift compiler, specifically the Intermediate Representation Generator (IRGen), is throwing a fit. When we try to use async await to call a method on a legacy WKUIDelegate, the compiler just crashes. Yep, you read that right. No helpful error messages, just a full-on crash. This happens in Xcode 26.0.1, and it seems to affect both Swift 5 and Swift 6.

The Problem in Detail:

The core of the problem seems to be within the webView(_:runJavaScriptAlertPanelWithMessage:initiatedByFrame:) method of the WKUIDelegate protocol. When you try to await a call to a legacy delegate within this method, boom! The compiler gives up the ghost. But, the weird thing is, other async calls within the same method body work just fine. And, as a further twist, the completion handler variant of the same webView method also compiles and works without issue. Talk about a confusing situation!

To make it super clear, here's a simplified version of the code that triggers the crash:

import UIKit
import WebKit

class ViewController: UIViewController {
    private weak var legacyResponder: WKUIDelegate?
}

extension ViewController: WKUIDelegate {
    func webView(
        _ webView: WKWebView,
        runJavaScriptAlertPanelWithMessage message: String,
        initiatedByFrame frame: WKFrameInfo
    ) async {
        // This line causes the compiler to crash
        await legacyResponder?.webView?(
            webView,
            runJavaScriptAlertPanelWithMessage: message,
            initiatedByFrame: frame
        )
    }
}

Debugging Steps:

The stack trace is a bit of a beast, but the key clues point to the IRGen phase. It seems like there's a problem with how the compiler is handling the async/await calls when they're directed to the legacy delegate. Unfortunately, the error messages aren't super helpful, so it's a bit like searching in the dark. We need to report this bug to the Swift community to get it fixed!

Reproduction and Root Cause

Reproduction Steps:

Reproducing the issue is pretty straightforward, thankfully. You just need to create a simple project with a WKWebView and implement the WKUIDelegate protocol in your view controller. Then, include the code snippet above, making sure to replace the legacyResponder with your own legacy WKUIDelegate. When you try to compile, it should crash with the error message.

Potential Root Causes:

Okay, so why is this happening? Here are some potential reasons:

• Interaction between async/await and legacy Objective-C: The legacy delegate is likely written in Objective-C. There might be some incompatibility in how the Swift compiler handles async/await calls that are being forwarded to Objective-C code. It's possible that the compiler is not correctly translating the asynchronous nature of the Swift code into the Objective-C runtime.
• Compiler Bug: Let's face it, compilers can have bugs. There might be a specific code path in the IRGen that isn't handling this particular scenario correctly. It could be related to how the compiler is transforming the code, or perhaps a problem with how it's dealing with the delegate's methods.
• Incorrect Metadata: It is possible that the compiler is not generating the correct metadata for the async call, causing a problem at runtime. It is possible that the compiler cannot correctly infer the types of the parameters when the method is called on the legacy responder. This can cause the compiler to generate invalid IR.

Workarounds and Solutions

Possible Workarounds:

While we wait for a fix, here are some workarounds you can try:

• Use Completion Handlers: As the original report mentions, the completion handler version of the webView method seems to work fine. If you can refactor your code to use this, it might get you past the crash. It is recommended to use completion handlers, as this is a workaround that is less likely to break in the future.
• Avoid Awaiting the Legacy Delegate Directly: If possible, try to avoid awaiting the call directly. Instead, you might be able to process the result of the call asynchronously using Task { ... } or similar mechanisms. This might prevent the compiler from crashing, but it may also add complexity.
• Refactor Your Code: If your goal is to gradually refactor to Swift, try to refactor the delegate method to Swift as soon as possible. Refactoring can involve creating a Swift implementation of the delegate method. This is a longer-term solution.
• Report the Bug: The most important step! Report this bug to the Swift community on Swift.org or other reporting channels. Include the stack trace and the minimal reproducible example. The more people who report it, the more attention it will get.

Potential Solutions:

• Swift Compiler Fix: The ultimate solution is a fix from the Swift compiler team. They will need to identify the root cause in the IRGen and fix it. This is probably going to be the main solution.
• Improved Interoperability: Improvements to Swift's interoperability with Objective-C could resolve the issue. There might be specific areas where async/await needs better handling when interacting with Objective-C delegates.

Conclusion

So, there you have it, guys. A frustrating but interesting issue that highlights a real-world problem when mixing async/await with legacy code and delegates. It's a great reminder of the complexities of software development! While the crash is a pain, at least we have some workarounds and a clear path forward: Report the bug and keep an eye out for updates from the Swift team. Stay tuned, and let's hope for a fix soon!

If you've encountered this issue or have any other insights, please share them in the comments below. Let's work together to help squash this bug! And as always, thanks for reading! Happy coding!