We've noticed that Context Receivers don't enforce...

# compiler

[dave]

We've noticed that Context Receivers don't enforce types in the way that we would expect. Is it by design that this compiles?

data object Ctx1
data object Ctx2

interface MyThing<Ctx> {
    context(Ctx)
    fun foo(): String
}

class Ctx1Thing : MyThing<Ctx1> {
    context(Ctx2) override fun foo() = "bob"
}

[Javier]

Does it compile via terminal or just no IDE warning/error?

[dave]

It compiles both in Idea and through our gradle build. We're using:
openjdk 20.0.2
Kotlin 1.9.10

[Javier]

I think it shouldn’t as it shouldn’t if you put those context as parameters of foo.

Only if those objects would extend the same interface

[natpryce]

Using David’s code, this main method compiles but fails at runtime with a ClassCastException:

fun main() {
    val myThing : MyThing<Ctx1> = Ctx1Thing()
    
    with(Ctx2) {
        with(Ctx1) {
            myThing.foo()
        }
    }
}

[natpryce]

Exception in thread "main" java.lang.ClassCastException: class example.signup.Ctx1 cannot be cast to class example.signup.Ctx2 (example.signup.Ctx1 and example.signup.Ctx2 are in unnamed module of loader 'app')
	at example.signup.Ctx1Thing.foo(Example.kt:11)
	at example.signup.ExampleKt.main(Example.kt:20)
	at example.signup.ExampleKt.main(Example.kt)

[dave]

That still doesn't fail to compile - it actually was our original version before we simpified the example 🙂

interface MyCtx

data object Ctx1 : MyCtx
data object Ctx2 : MyCtx

interface MyThing<MyCtx> {
    context(MyCtx)
    fun foo(): String
}

class Ctx1Thing : MyThing<Ctx1> {
    context(Ctx2) override fun foo() = "bob"
}

[dave]

And as @natpryce has pointed out - we get a class cast at runtime 😞

[Javier]

I mean if you want to get the same behavior you can remove context and put them as foo parameters. context is just sugar for that.

The compiler is not catching this issue with context but it should

[natpryce]

Agreed. Contexts are a convenient way of passing parameters to methods without repetitive code, and so should be typechecked in the same way.

[Javier]

class Ctx1Thing : MyThing<Ctx1> {
    context(Ctx2) override fun foo() = "bob"
}

This can't work as Ctx1 is not related to Ctx2

The next would fail too

interface MyCtx

data object Ctx1 : MyCtx
data object Ctx2 : MyCtx

interface MyThing<MyCtx> {
    fun foo(param: MyCtx): String
}

class Ctx1Thing : MyThing<Ctx1> {
    override fun foo(param: Ctx1) = "bob" // works
    override fun foo(param: Ctx2) = "bob" // fails
}

[Javier]

Probably this issue is already reported in YouTrack

[dave]

But it doesn't fail! 🙂

[dave]

That's why I was asking here. If we can confirm that this is not designed behaviour then that's fine. But for a "feature" of a statically types language to not be actually type checked seems like a bug. 🙂

[dave]

I've raised this to cover the problem. Please upvote 🙂