Swift 2.1 do-try-catch not catching error

Question

Here's my Swift 2.1 code snippet. The error that's occurring is shown in the comments at the point where the error appears.

The error shows up in the debugging panel, and the app crashes. The app never prints the line in the catch, nor does it gracefully return as expected.

let audioFileURL = receivedAudio.filePathURL

guard let audioFile = try? AVAudioFile(forReading: audioFileURL) else {
    print("file setup failed")
    return
}

let audioFileFrameCount = AVAudioFrameCount(audioFile.length)

audioFileBuffer = AVAudioPCMBuffer(PCMFormat: audioFile.fileFormat, frameCapacity: audioFileFrameCount)

do {
    // ERROR: AVAudioFile.mm:263: -[AVAudioFile readIntoBuffer:frameCount:error:]: error -50
    // Terminating app due to uncaught exception 'com.apple.coreaudio.avfaudio', reason: 'error -50'
    // -50 = Core Audio: bad param
    try audioFile.readIntoBuffer(audioFileBuffer)
}
catch {
    print("unable to load sound file into buffer")
    return
}

From everything I've seen, my do/try/catch format should be correct.

audioFile.readIntoBuffer returns void and has the keyword throws.

Yet, the catch is never executed.

What am I missing?

UPDATE: From Apple's documentation on AVAudioFile

For:

func readIntoBuffer(_ buffer: AVAudioPCMBuffer) throws

Under Discussion:

HANDLING ERRORS IN SWIFT:

In Swift, this API is imported as an initializer and is marked with the throws keyword to indicate that it throws an error in cases of failure.

You call this method in a try expression and handle any errors in the catch clauses of a do statement, as described in Error Handling in The Swift Programming Language (Swift 2.1) and Error Handling in Using Swift with Cocoa and Objective-C (Swift 2.1).

From The Swift Programming Language (Swift 2.1): Error Handline

NOTE

Error handling in Swift resembles exception handling in other languages, with the use of the try, catch and throw keywords. Unlike exception handling in many languages—including Objective-C—error handling in Swift does not involve unwinding the call stack, a process that can be computationally expensive. As such, the performance characteristics of a throw statement are comparable to those of a return statement.

And, finally, from the same document:

Handling Errors Using Do-Catch

You use a do-catch statement to handle errors by running a block of code. If an error is thrown by the code in the do clause, it is matched against the catch clauses to determine which one of them can handle the error.

I don't have to write and throw my own errors/exceptions for them to be caught. I should be able to catch Swift's exceptions as well.

Answer 1

The do - catch combination is fine. This issue is simply one that cannot be caught - and therefore never makes it to the catch block.

If the issue were catchable (defined and handled via Swift's throws functionality), the catch block would've been executed.

---

Some semantics: there is a long-standing argument about the differences between the terms error and exception.

Some developers consider the two terms to be distinct. In this case, the term error represents an issue that was designed to be handled. Swift's throws action would fit here. In this case, a do - catch combination would allow the issue to be caught.

An exception, for these developers, represents an unexpected, usually fatal, issue that cannot be caught and handled. (Generally, even if you could catch it, you would not be able to handle it.)

Others consider the two terms to be equivalent and interchangeable, regardless of whether the issue in question can be caught or not. (Apple's documentation seems to follow this philosophy.)

(Updated to focus on the answer rather than the semantics.)

Answer 2

catch will only catch the errors that are explicitly thrown. It will never catch exceptions.

What you seem to have here is an exception happening in the AVAudioFile SDK, not a Swift error, so it's not caught:

ERROR: AVAudioFile.mm:263: -[AVAudioFile readIntoBuffer:frameCount:error:]: error -50
Terminating app due to uncaught exception 'com.apple.coreaudio.avfaudio', reason: 'error -50'
-50 = Core Audio: bad param

In the context of Swift, "error" means an error thrown by a function, nothing else. The function being yours or not does not matter.

Exceptions in Swift are not caught ever. It's not the same as in Java at all, for example. In Swift, error != exception, they are two very different things.

I understand your opinion that "It should work for both" but it's simply not the case. You can see this as a semantic situation with using the keyword "catch" if you want, because it's the same keyword as other languages but behaves very differently; it resembles, but it's not the same.

As for your exception with AVAudioFile, I don't have a solution - maybe it's a bug in this SDK? Or it's not yet properly bind to Swift and the throwing system. In this case, and if nobody else has a solution, don't hesitate to report the bug to Apple.

Answer 3

see this example

struct E: ErrorType{}

func foo(i: Int) throws {
    if i == 0 {
        throw E()
    }
    print(10 / (i - 1))
}

do {
    //try foo(1) // if you uncomment this line, the execution 
    // will crash, even though the function is declared 
    // as throwing and you use proper calling style (do / try / catch pattern)
    try foo(0)
} catch {
    print("error: ", error) // error: E()
}