Conflicting overloads are not resolved for functions

[Schahen]

Following code

declare function addListener(event: "disconnect", listener: (worker: Vorker) => void): Kluster;
declare function addListener(event: "online", listener: (worker: Vorker) => void): Kluster;

is translated to:

external fun addListener(event: String /* "disconnect" */, listener: (worker: Vorker) -> Unit): Kluster
external fun addListener(event: String /* "online" */, listener: (worker: Vorker) -> Unit): Kluster

And actually those two declarations are equivalent and won't compile without CONFLICTING_OVERLOADS annotation. This particular annotation exists for historical reasons and and actually was used in ts2kt as well. Actually we consistently eliminating places in code whe thing like conflicting overloads can happen.

For instance:

declare class DisposableNetworkEvent {
  once(event: string, listener: (...args: any[]) => void): this;
  once(event: "disconnect", listener: () => void): this;
  once(event: "error", listener: (error: Error) => void): this;
  once(event: "exit", listener: (code: number, signal: string) => void): this;
  once(event: "online", listener: () => void): this;
}

Is converted to:

external open class DisposableNetworkEvent {
    open fun once(event: String, listener: (args: Array<Any>) -> Unit): DisposableNetworkEvent /* this */
    open fun once(event: String, listener: () -> Unit): DisposableNetworkEvent /* this */
    open fun once(event: String /* "error" */, listener: (error: Error) -> Unit): DisposableNetworkEvent /* this */
    open fun once(event: String /* "exit" */, listener: (code: Number, signal: String) -> Unit): DisposableNetworkEvent /* this */
}

Still because of the CONFLICTING_OVERLOADS I've felt relatively safe, realising that there can be some scenarios where this was missed.

However in IR this particular annotation is not supported and won't be supported, since it's a sin and we tend not to sin in IR.