Why is is legit to call any extension function on `Nothing`, but not for example class functions? Is...

# announcements

[Marc Knaup]

Why is is legit to call any extension function on Nothing, but not for example class functions? Is that a bug?
This is especially confusing if this (unexpectedly?) resolves to Nothing because there’s not even a warning 😅

error("foo").hasSurrogatePairAt(1)

[Marc Knaup]

on that note: https://youtrack.jetbrains.com/issue/KT-35647

[diesieben07]

It's legit because Nothing is a subtype of every other type. You can literally put a value of type Nothing everywhere (because such a value can never exist).

[Marc Knaup]

I know, so why doesn’t it work for class methods? It’s a subtype!

[diesieben07]

Probably due to how method resolution is implemented. If the Kotlin compiler would actually evaluate all instance methods of the Nothing class, it would literally have to be every method in every class. That's not really feasible.

[diesieben07]

Extension functions however are resolved like top level functions

[Anastasia Finogenova]

Why do you want an extension to a class method 🤔 if something you can just create an extension to the class and then call that method underneath

[Anastasia Finogenova]

Funny how this idea never occurred to me...an extension to a method

[diesieben07]

I think you are misunderstanding the issue, Anastasia

[Anastasia Finogenova]

Maybe could you explain in detail...very curious

[diesieben07]

The issue is about being able to call any extension functions on a value of type Nothing (which is correct, because Nothing is a subtype of every other type so it can be the receiver for every extension function), but not instance functions (which should still technically be okay, since Nothing is still a subtype of every other type and so should inherit literally every instance method on every class).

[Anastasia Finogenova]

Just tested it and it doesn't look like you can call any extension fun on Nothing🤷 the only extension function I can call on Nothing is the one I created for the type Nothing. So i can't call an extension for Unit, Boolean, Fragment or Any on Nothing

[Anastasia Finogenova]

Here is the docs it doesn't actually say that Nothing is a subtype of everything https://kotlinlang.org/api/latest/jvm/stdlib/kotlin/-nothing.html

[Anastasia Finogenova]

It is in Scala though 🤷 also if you open the source code in AS Nothing doesn't extend any other type vs in Scala it actually extends Any

[Anastasia Finogenova]

So I am curious to know where is it said that Nothing is a subtype of any other type?

[Marc Knaup]

@Anastasia Finogenova you can call any extension function (that isn’t ambiguous) on Nothing, but autocompletion won’t tell you 🙂

[Marc Knaup]

I was editing some code where an extension function was called on an implicit this.
After editing some other part of the code, this changed to Nothing and the extension function call was still totally fine. There wasn’t even a warning due to a Kotlin bug.

So I was curious why Nothing behaves so differently in different situations.
And I have no idea why it would be useful to call any function on Nothing, whether extension or not 🤔

[Anastasia Finogenova]

Weird maybe It was a different version of the studio or kotlin plugin as when I type in the fun name it still doesn't offer me to import it but I didn't try to manually import it 🤷 it was still showing it red

[Marc Knaup]

Just use one which doesn’t need an import like .toDouble()

[Anastasia Finogenova]

I see, it highlights as unreasonable code but it is unreachable 😅

[Anastasia Finogenova]

Why would you expect it to be reached as Nothing will never return

[Anastasia Finogenova]

Nothing has a private constructor and no instance it is used as an explicit type of a function that never returns, throws an exception always for example. So the code is always unreachable

[bezrukov]

and why do you think it's an issue?
it's ok that you can call B.extension() on A type if A extends B.
And sicne Nothing extends every type, it's also ok. You won't be able to instantiate Nothing class, so it will be never invoked in runtime

[Anastasia Finogenova]

So when does it say that Nothing extends every type in Kotlin and how is it done as it doesn't extend anything form the source code, can you point where it says that Nothing extends every type @bezrukov

[Marc Knaup]

It’s two different issues here:
a) Inconsistency that you can call any extension on Nothing but not instance members.
b) The “unreachable code” warning doesn’t always work. It didn’t for me which caused an extension function invocation on Nothing to not raise any flags.

Simple example for b)

fun <T> foo(block: T.() -> Unit) {}

fun main() {
    foo<Nothing> {
        hasSurrogatePairAt(1) // no warning
    }
}

[Anastasia Finogenova]

That's interesting

[Anastasia Finogenova]

When I added this.toDouble() in the body of your function it started to show the warning @Marc Knaup

[Anastasia Finogenova]

So it does do it but maybe this particular case of type inference is buggy

[Anastasia Finogenova]

So the issue is valid I am still curious where to read about the statement that Nothing is a subtype of everything in Kotlin docs 🤔

[Marc Knaup]

I also remember that statement but cannot find it anywhere in the documentation 😮

[Marc Knaup]

Runtime won’t agree though.

enum class MyEnum

@UseExperimental(ExperimentalStdlibApi::class)
fun main() {
    println(Nothing::class.starProjectedType.isSubtypeOf(typeOf<Any?>()))    // true
    println(Nothing::class.starProjectedType.isSubtypeOf(typeOf<Unit>()))    // false
    println(Nothing::class.starProjectedType.isSubtypeOf(typeOf<MyEnum>()))  // false
}

[Marc Knaup]

It’s more a theoretical subtype of every type since it can be used in any place where another type is needed.
But the code will obviously never execute.

[bezrukov]

Yes, it's not about runtime, because both java and kotlin doesn't support multiple parent classes. on JVM it's backed by Void for java compatibility, that's why you see false when trying to check on subtype. Nothing is more like just a marker for compiler.

[bezrukov]

And I also can't find an official kdoc about this 🙂

[molikuner]

I just remembered a talk from KotlinConf 2018:

https://youtu.be/juFkdMv4B9s?t=1021▾

Maybe this helps a little bit.

[gildor]

I don't see any inconsistency. Extension function resolution is different from instance method resolution, Nothing just doesn't have methods to call, but it's fine to call extension function or pass it as argument to any function
Unreachable code warning should work, if it doesn't, it is a bug