I had this issue happening to me yesterday. I was dealing with a piece of production code that was crashing at a certain point with this crash info

0   Goga  0x00000001000b90b8 function signature specialization <Arg[0] = Owned To Guaranteed, Arg[1] = Owned To Guaranteed> of Goga.NewViewController.emailButtonPressed (Goga.NewViewController)(ObjectiveC.UIButton) -> () (NewViewController.swift:0)

1   Goga  0x00000001000c0488 Goga.NewViewController.(emailButtonPressed (Goga.NewViewController) -> (ObjectiveC.UIButton) -> ()).(closure #2) (NewViewController.swift:872)

2   Goga  0x00000001000bd250 partial apply forwarder for reabstraction thunk helper from @callee_owned (@in ObjectiveC.UIAlertAction!) -> (@out ()) to @callee_owned (@owned ObjectiveC.UIAlertAction!) -> (@unowned ()) (NewViewController.swift:0)

However, when I found the bug, after hours of trying to replicate the issue, any error message for it couldn't be found in the crash log. The bug was showing in XCode instead as:

unexpectedly found nil while unwrapping an Optional value

My question is, how to catch the nil-optional error in production code?

Edit:

Just to add a bit more of a perspective to the original problem, I found the issue in this sample code:

let cell = tableView.cellForRowAtIndexPath(indexPath)  

cell.textLabel.text = "Hello" // CRASH if the cell is not visible in the view

I should have done this instead:

if let cell = tableView.cellForRowAtIndexPath(indexPath) {

  cell.textLabel.text = "Hello" // Never get executed if cell is nil

} 

The way to "catch" the "nil-optional error" is simply by writing your code correctly. Don't abuse forced unwrapping and forced down casting.

In this specific case, simply reading the crash details can give us some information:

1   Goga  0x00000001000c0488 Goga.NewViewController.(emailButtonPressed (Goga.NewViewController) -> (ObjectiveC.UIButton) -> ()).(closure #2) (NewViewController.swift:872)

Somewhere around line 872 of NewViewController.swift, you're force unwrapping something that's actually nil (and therefore cannot be unwrapped).

The solution is to go to line 872 of NewViewController.swift, find any occurrences of the exclamation point, determine whether it's a force-unwrapping operator or if it's a boolean operator... and if it's a force unwrapping operator, fix it using Swift's optional binding design patterns.

It could be that you're doing something like this:

let foo = bar!

Or perhaps somewhere bar is declared like this:

var bar: AnyObject!

Then it's never initialized (or at some point set to nil) and then because it's implicitly unwrapped, you're doing something like this:

let foo: AnyObject = bar

These can both lead to the error you're looking at.

Yes, implicitly unwrapped optionals and forced unwrapping can make things slightly more convenient when writing your code, but in the end, all it means is you run into these problems that you have to eventually track down later. And there's no need to do so when Swift has plenty of tools to ensure we're being safe with nil.

When dealing with optionals you should be conditionally unwrapping them with an if statement.

var yourOptional: String?



if let unwrapped = yourOptional {

 // Do something with the variable

} else {

// It was nil

}

Or use guard it's easier just as you get complex code

guard let optional = someOptional else {

  return // or do what need's to be done if nil

}

Checking API Availability

if #available(iOS 9, OSX 10.10, *) {

   // Use iOS 9 APIs on iOS, and use OS X v10.10 APIs on OS X

} else {

   // Fall back to earlier iOS and OS X APIs

}

It will come be prepared.