Swift Optional Checking "Unexpectedly found nil" - ios

Question

I'm not sure why Swift is complaining that list1 = list1!.next unexpectedly found nil when my if statement checks if list1 != nil. Could anyone explain why checking if list1 != nil is not enough? I've tried changing it to
if list1 {
list1 = list1!.next
}
but it suggested that I check using != nil
Here's a gist
Here's my code:
class Node {
var data: Int
var next: Node?
init (data: Int) {
self.data = data
}
}
func addReversed (var list1: Node?, var list2: Node?) -> Node {
var carry = 0
var head: Node? = nil
var prev: Node? = nil
while list1 != nil || list2 != nil {
var newNode = addNode(list1, list2, &carry)
appendNode(head, prev, newNode)
if list1 != nil {
list1 = list1!.next
}
if list2 != nil {
list2 = list2!.next
}
}
if carry > 0 {
var carryNode = Node(data: carry)
appendNode(head, prev, carryNode)
}
return head!
}

Answer 1

This is not what you asked, but I think it may have a lot to do with the problem. I tested your Node and your basic addReversed code and I couldn't get a crash. But at that time I didn't have any of your other global functions, so I had to just comment them out while testing. Since I didn't crash, therefore I came to believe that the problem is in one of those global functions.
Then you published your gist, with the code to those global functions, and I can see immediately that this code is deeply flawed:
func appendNode(var head: Node?, var prev: Node?, node: Node) {
if head == nil {
head = node
}
if prev == nil {
prev = node
}
else {
prev!.next = node
prev = node
}
}
You seem to think that saying e.g. prev = node will replace the node that came in as prev with the node that came in as node in some outside world. It will not. These are the names of local variables only. So none of that code has any effect at all - except for prev!.next = node, because there you are mutating an instance that exists also in the outside world (because this is a reference type, a class instance).
If you want to replace the object that came in on a parameter with another object, you need an inout parameter.
For example:
class Dog {
let name:String
init(_ s:String) {
name = s
}
}
func replaceDog(var d:Dog) {
d = Dog("Rover") // this is what you are doing
}
var d = Dog("Fido")
replaceDog(d)
d // still Fido
But:
class Dog {
let name:String
init(_ s:String) {
name = s
}
}
func replaceDog(inout d:Dog) {
d = Dog("Rover")
}
var d = Dog("Fido")
replaceDog(&d)
d // Rover
Your code is full of this same false assumption, and I think, although I have not worked out the details, that this assumption is the cause of your difficulty here. My guess is that you got this linked list implementation from some other language that has pointers, but you are not using pointers in your implementation. The way to use pointers in Swift is with inout!