Stored property cannot have covariant 'Self' type

Using Swift
1

While tinkering :slight_smile: with @David_Smith's excellent example ThreadsafeCounter, I got this error: Stored property cannot have covariant 'Self' type.

import os

@main
enum CounterTest {
    static func main () async {
        let counter = ThreadsafeCounter ()
        
        let N = 10 * 1024 * 1024
        for _ in 0..<N {
            Task.detached {
                counter.increment ()
            }
        }
        while counter.value < N {
            counter.decrement()
            counter.increment()
        }
        print (N, counter.value)
        assert (N == counter.value)
    }
}

final class ThreadsafeCounter {
    private (set) var value: Int = 0
    
    // var protectedCounter : OSAllocatedUnfairLock <ThreadsafeCounter>?
    var protectedCounter : OSAllocatedUnfairLock <Self>?
        // ^^^ Error: `Stored property cannot have covariant 'Self' type`

    init () {
        self.protectedCounter = OSAllocatedUnfairLock (initialState: self)
    }
    
    func increment() {
        protectedCounter?.withLock {$0.value += 1}
    }

    func decrement () {
        protectedCounter?.withLock {$0.value -= 1}
    }
}

However, the error disappears if I substitute ThreadsafeCounter for Self.

Can anyone shed some light on this please?

Thank you.

2

FWIW that example was typed directly into the forum and has not been tested at all, caveat emptor :slight_smile:

For an actual threadsafe counter I would probably use the Atomics package

1 Like
3

Tangentially related:

struct S {
    func foo() {
        let s: Self = self // ✅
    }
}

final class C {
    func foo() {
        let s: Self = self // 🛑 Cannot convert value of type 'C' to specified type 'Self'
    }
}
3 Likes
4

Stored variable of Self type (especially when subclassing) helps to explain this.

I suspect this is an oversight in the Swift compiler - as far as I can tell, the fact that Self (ThreadsafeCounter) is final should mean that there are no covariance problems. Only if it were non-final would it open the door to covariance problems like those shown in the StackOverflow answers.

2 Likes