I’ve got a `kotlin.native.concurrent.InvalidMutabilityException` that I can’t explain. ``` compa...

# kotlin-native

[ribesg]

I’ve got a kotlin.native.concurrent.InvalidMutabilityException that I can’t explain.

companion object {

        internal var xs: Set<X> by atomic(HashSet())
            private set

        fun registerX(x: X) {
            xs = xs + x
        }

    }

atomic being:

inline fun <reified T> atomic(initial: T) = AtomicDelegate(initial)

AtomicDelegate being:

class AtomicDelegate<T>(initial: T) : ReadWriteProperty<Any?, T> {

    private val atomic = AtomicReference(initial)

    override fun getValue(thisRef: Any?, property: KProperty<*>): T =
        atomic.get()

    override fun setValue(thisRef: Any?, property: KProperty<*>, value: T) {
        atomic.set(value)
    }

}

And AtomicReference here is:

internal actual class AtomicReference<T> actual constructor(initial: T) {

    private val atomic =
        kotlin.native.concurrent.FreezableAtomicReference(initial)

    actual fun get(): T =
        atomic.value

    actual fun set(newValue: T) {
        atomic.compareAndSet(get(), newValue)
    }

}

The app crashes when registerX is called:

Uncaught Kotlin exception: kotlin.native.concurrent.InvalidMutabilityException: mutation attempt of frozen kotlin.collections.HashSet@221c288

Where in my code am I attempting to modify a frozen HashSet? I’m pretty sure I’m just creating a new local one, modifying it, then assigning it which makes it frozen (that’s what the + does)

[Marko Mitic]

Where do you actually freeze the set, though?

[Marko Mitic]

I'd assume that delegate's setValue should look like this:

atomic.set(value.freeze())

[ribesg]

Well I supposed it got frozen automatically when assigned. The error states it’s frozen. So I suppose that means it’s been frozen before? Is my assumption that local variables aren’t frozen false?

[ribesg]

I’m clearly not understanding something because I’m sure I’m not trying to mutate anything frozen. I’m actually not mutating anything in this code

[Marko Mitic]

AtomicReference expects frozen values, you need to freeze them before assigning them to atomicReference

[Marko Mitic]

Not sure if that's the exact cause of your problem, but it could be

[ribesg]

I forgot to mention that AtomicReference is actually a custom thing, it’s a multiplatform expect, I’m adding it to my main message

[ribesg]

So I should use atomic.compareAndSet(get(), newValue.freeze()) instead of atomic.compareAndSet(get(), newValue)

[Marko Mitic]

I think so

[Marko Mitic]

I see you're trying to make common KMP code K/N-friendly, how's that going?

[Marko Mitic]

Btw, Stately has KMP implementations of AtomicReference, freeze(), etc. Might be helpful https://github.com/touchlab/Stately/

[Dominaezzz]

The only place I see a mutation is xs + x. Is that the entire stacktrace?

[ribesg]

There’s no stacktrace in native

[ribesg]

@Marko Mitic pretty good overall, just a bunch of object `var`s who need to use my atomic delegate, but other than that it’s kinda straightforward. We already have a production Android/iOS app with common backends

[ribesg]

@Dominaezzz this mutation occurs on a local instance, so it’s not frozen, right? The source of + (from kotlin):

public operator fun <T> Set<T>.plus(element: T): Set<T> {
    val result = LinkedHashSet<T>(mapCapacity(size + 1))
    result.addAll(this)
    result.add(element)
    return result
}

add and addAll are the only mutations I see, and they should work because result should not be frozen, unless I don’t understand something

[ribesg]

@Marko Mitic Stately doesn’t freeze the value when setting https://github.com/touchlab/Stately/blob/master/stately/src/nativeCommonMain/kotlin/co/touchlab/stately/concurrency/AtomicReference.kt#L27

[Dominaezzz]

They shouldn't be frozen but it says a HashSet is being mutated.

[Marko Mitic]

Yeah, Stately doesn't freeze the reference because native AtomicReference doesn't either, they both expect object passed to be frozen already

[ribesg]

I replaced xs = xs + x with xs = setOf(x, *xs.toTypedArray()) and it seems to work. So the local hash map created by + is frozen?

[louiscad]

@ribesg That FrozenDelegate works well for me: https://github.com/LouisCAD/Splitties/blob/fb8a6266fe84443dca91d9ef73abcdabe0ff0275/modules/preferences/src/appleMain/kotlin/splitties/preferences/FrozenDelegate.kt

[ribesg]

Yeah that’s basically what I have now

[ribesg]

The only problem I have left is that I can’t implement an unregisterX function, I don’t see how I can do that without modifying collections