A modern programming language that makes developers happier.

kotlinlang

Is there a particular reason objects cannot be autocast in this case:
```sealed class Sc {
    object Foo : Sc()
}

fun (sc: Sc){
    when (sc){
        Sc.Foo -> sc // <-- type is still Sc here, not Foo
    }
}```
Seems like a basic case but I couldnt even find an issue on youtrack about it

Yes that is one way to fix it.. but it seems silly to have an expensive instance check instead of simple equality

strange...
`if (sc == Sc.Foo)`  not working
`if (sc === Sc.Foo)` working

`equals` can be overriden, so equality doesn't guarantees that `sc` is really `Sc.Foo`
```sealed class Sc {
    object Foo : Sc() {
        fun bar() {}
    }

    class FakeFoo : Sc() {
        override fun equals(other: Any?): Boolean {
            return true
        }
    }
}
fun foo(){
    val sc: Sc = Sc.FakeFoo()
    
    when (sc) {
        Sc.Foo -> sc
    }
    // this when is equal to such if 
    //   where `equals` is called
    if (sc == Sc.Foo) { // it's true
        sc
    }
}```

Also "instanceof is expensive" is a myth, at least on the JVM.

Ah yes. Makes sense except that doesnt when assume it isnt ? How else would it assert the exhaustiveness ?

If you know it's the object, then you can just use `Sc.Foo` instead of `sc` as a fix.

I have created a ticket about it: <https://youtrack.jetbrains.com/issue/KT-35269>