Stack using Linked List in Swift
That looks already quite good and clean. Here are my remarks:


private var first: StackNode? = nil // The topmost node in the stack



An optional value is initalized to nil by default, so

private var first: StackNode? // The topmost node in the stack


is sufficient. And with a different variable name it becomes self-explaining:

private var top: StackNode?


There are trailing semi-colons at some places, these are not needed in Swift.

Here


    let newElement = StackNode(newElement)
    newElement.next = first
    first = newElement



you pass one property of the new node as parameter of the init method, and
set the other via accessor, which looks asymmetric to me. With

private class StackNode {
    var next: StackNode?
    let element: T

    init(_ element: T, next: StackNode?) {
        self.element = element
        self.next = next
    }
}


this simplifies to

    let newElement = StackNode(newElement, next: first)
    first = newElement


or even

    first = StackNode(newElement, next: first)


Note also that the element property in StackNode can be a constant.

A better property name for


/// The number of elements in the stack
var size: Int 



might be count – that is what all Swift collection types use. The forced
unwrap in


    // Traverse the list
    while current != nil {
        count += 1
        current = current!.next
    }



is safe, but can even be avoided with

    // Traverse the list
    while let node = current {
        count += 1
        current = node.next
    }


A common practice is to put the implementation of protocols into separate
extensions:

extension StackList: CustomStringConvertible {
    var description: String { ... }
}


Naming: class StackNode is defined within the StackList “namespace,”
so you can simply name it Node. And I would name StackList just
Stack – it is an implementation detail that it uses a linked list.

Further suggestions

Make StackList conform to Sequence. A simple implementation would be

extension StackList: Sequence {
    func makeIterator() -&gt; AnyIterator&lt;T&gt; {
        var current = first
        return AnyIterator {
            guard let node = current else { return nil }
            defer { current = node.next }
            return node.element
        }
    }
}


That allows to enumerate all elements easily:

for item in stack { print(item) }


In addition, you can use it in the description method which then simplifies
to

extension StackList: CustomStringConvertible {
    var description: String {
        return "[" + self.map { "\($0)" }.joined(separator: ", ") + "]"
    }
}


Implement a peek() method to get the top element without removing it,
and an isEmpty property.