Same method for nullable and non-nullable arguments

Question

I'm trying to create two almost-same methods that handle nullable and non-nullable arguments slightly differently:

fun parse(type: Any) : MyObject {
    return handleParse(type)
}

fun parse(type: Any?) : MyObject? {
    if (type == null)
        return null

    return handleParse(type)
}

But I get this error in Android Studio:

Platform declaration clash: The following declarations have the same JVM signature

---

The goal is that it automatically handles nullable and non-nullable values in Kotlin, without me using !! every time I call it on nullable terms.

I've already tried adding the @JvmName("-name") annotation as mentioned in this answer but that doesn't work either. Obviously, I can change the method name to something else as well, but that is just circling around and avoiding the issue altogether.

Hoping there's an easy way to do this or at least a sensible workaround. Would also appreciate the reasoning behind the way things currently work, and why I should or shouldn't do this.

Answer 1

Reason why this doesn't work is simple, Java doesn't have null-safe types, meaning that both methods look completely same to Java, and Kotlin aims to provide as much interoperability with Java as possible.

But if you think a bit more about that there is simply no reason for such feature, as you can see your 2nd method already handles everything properly, with addition of 1 if case, which even if this feature exist would have to exist because compiler would need to know whether value in null or not in other to know which method to call anyway.

Common approach that I have seen so far is adding NotNull suffix to your method, for example in your case it would be parseNotNull in case where you don't allow nullable types, this way even when calling code from Java it is clear that parameter shouldn't be null.