ambiguous overload of two methods only in a certain combination with other apparently unrelated method

[sjbiaga]

Compiler version

3.8.0-RC4

Minimized example

class C[T]

object X:
  def apply(xs: Int*)(d: Double) = Nil
  def apply[T](xs: Int*)(t: C[T])(d: Double) = Nil
  def apply()(d: Double) = List(List(d))
  def apply[T]()(t: C[T])(d: Double) = List(List(d))

for
  List(x) <- X()(.0)
yield
  x

Output Error/Warning message

-- [E051] Reference Error: -----------------------------------------------------
2 |  List(x) <- X()(.0)
  |             ^
  |Ambiguous overload. The overloaded alternatives of method apply in object X with types
  | ()(d: Double): List[List[Double]]
  | (xs: Int*)(d: Double): scala.collection.immutable.Nil.type
  |both match arguments ()((0.0d : Double))
  |
  | longer explanation available when compiling with `-explain`
1 error found

However, if the first apply method were commented out:

class C[T]

object X:
  //def apply(xs: Int*)(d: Double) = Nil
  def apply[T](xs: Int*)(t: C[T])(d: Double) = Nil
  def apply()(d: Double) = List(List(d))
  def apply[T]()(t: C[T])(d: Double) = List(List(d))

for
   List(x) <- X()(.0)
yield
   x

or the fourth apply method were commented out:

class C[T]

object X:
  def apply(xs: Int*)(d: Double) = Nil
  def apply[T](xs: Int*)(t: C[T])(d: Double) = Nil
  def apply()(d: Double) = List(List(d))
  //def apply[T]()(t: C[T])(d: Double) = List(List(d))

for
  List(x) <- X()(.0)
yield
  x

there would be no error. There is no error also if the first method were used instead:

class C[T]

object X:
  def apply(xs: Int*)(d: Double) = Nil
  def apply[T](xs: Int*)(t: C[T])(d: Double) = Nil
  def apply()(d: Double) = List(List(d))
  def apply[T]()(t: C[T])(d: Double) = List(List(d))

for
  List(x) <- X(1, 2, 3)(.0)
yield
  x

[som-snytt]

The incorrect expectation is that overload resolution looks at each parameter list in turn, as a series of "rounds", wherein only alternatives that "survive a round" are considered subsequently.

However the spec is that

resolution [is] re-tried using n + 1 argument lists

It does not say, "using the nth + 1 argument list."

Here is a duplicate issue where the complicating or motivating factor is that the overload is an extension method, and there is a stronger intuition that the first parameter list (the receiver) ought to exclude other alternatives.

Apparently, this is not expressed in the tests, since the proposed fix should fail more of them.

[som-snytt]

Worth adding,

other apparently unrelated methods, except for having the same name

There is a holiday tv movie with the premise that a woman happens to be named "Krissie Kringle".