Overload resolution with expected type prematurely discards matching alternative

[szeiger]

In the following piece of code the call to f at the end relies on the implicit conversion arrToIt to convert the result of one of the arr calls to an It[T]. This results in an expected type of It[?] for selecting among the 3 arr methods. As can be seen from the error message the correct one is not even considered.

class Arr[T]

class It[T]

implicit def arrToIt[T](xs: Arr[T]): It[T] = new It[T]

def arr[T](x: T, y: T): Arr[T] = new Arr[T]
def arr(x: Int, y: Int): Arr[Int] = new Arr[Int]
def arr(x: Byte, y: Byte): Arr[Byte] = new Arr[Byte]

def f[T](ys: It[T]): Unit = ()

f(arr("", null))

This fails to compile with

error: overloaded method value arr with alternatives:
  (x: Byte,y: Byte)this.Arr[Byte] <and>
  (x: Int,y: Int)this.Arr[Int]
 cannot be applied to (String, Null)
f(arr("", null))
  ^

If the single arrtoIt is replaced by

implicit def refArrToIt[T <: AnyRef](xs: Arr[T]): It[T] = new It[T]
implicit def byteArrToIt(xs: Arr[Byte]): It[Byte] = new It[Byte]
implicit def intArrToIt(xs: Arr[Int]): It[Int] = new It[Int]

it compiles successfully.

The situation looks similar to other overload-related bugs like #10576 but is probably not the same because in this case the correct alternative is prematurely discarded, which does not seem to play a part in the other bugs.

Tested with Scala 2.12.2 and 2.13.0-M3