Resolve the ambiguity of kotlin's reference to overloaded functions or fields

In kotlin, reference fields or overloaded functions may be ambiguous. For example:

object a {
    val a = 1
    fun a(){}
    fun a(p: Int) = p

fun main() {
    a::a // error

Anyway, specifying the type explicitly can eliminate this ambiguity, like:

fun main() {
    val t: kotlin.reflect.KProperty<Int> = a::a
    val t1: a.()->Unit = a::a
    val t2: a.(Int)->Int = a::a

However, this behavior is very complex, and local variable are also defined. At the same time, the return value type of the function does not need to be specified, which does not use the type derivation of kotlin. Therefore, reflection may be easier in this case. But this erasing type is obviously not the original intention of the kotlin design:: operator

So why not use the syntax of type parameters to resolve this ambiguity? I think the following functions are easier to write

fun main() {
    a::a // The kotlin compiler can consider that it is a property
    a::a<> // fun a()
    a::a<Int> // fun a(Int): Int

I don’t know if this will break the structure of kotlin, but it may be a good idea