When does overload occur when using inline functions?

Overloading inline functions in Kotlin does not occur in the traditional sense of runtime polymorphism. An inline function is embedded at the call site during compilation. Therefore, when we talk about "overloading" in relation to inline functions, we more often mean the compiler's ability to generate multiple versions of the inlined code for different call contexts, especially when using generics.

Key points:

• Compile-time specialization: For inline functions with generics (reified), the compiler generates specialized code versions for each specific type substituted for the type parameter. This happens at compile time, not runtime.
• Avoiding additional overhead: The goal of inlining is to eliminate the overhead of function calls. Specialization for generics avoids boxing primitive types and other overheads associated with type erasure in Java.
• Not polymorphism: This is not classical polymorphism where an overridden method is called depending on the actual object type at runtime. Here, the choice of the "version" of the function occurs at compile time.

Example of using reified with an inline function:

inline fun <reified T> printType(value: T) {
    // The compiler will generate separate code for each T (Int, String, etc.)
    println("Type is: ${T::class.java.name}")
}

fun main() {
    printType(123) // Code generated for T = Int
    printType("Hello") // Code generated for T = String
}

In this case, although syntactically we call a single function printType, the compiler generates two different versions of the inlined code: one for Int and one for String. This can be viewed as a form of "overloading" or, more precisely, compile-time specialization, which occurs thanks to the inlining mechanism rather than runtime polymorphism.