Multiple type applications on overloaded method crashes scalac

[diesalbla]

There is a corner case that occurs in the intersection of type application and method overloading.

The following program shows an object A with an overloaded method a, in both cases with a simple type parameter F, with different arguments.

object A {
    def a[F](x: Int) = 0
    def a[F](x: String) = 0
}
A.a[Int][String](0)

In the final line, when the method is applied with two lists of type arguments, the compiler crashes with a java.lang.ClassCastException.

Note that, as explained in #6729, this is not a syntax problem. There can be applications with several lists of type parameters, such as when the result of one is an object with an def apply[F] method.

Similar programs that do not crash the compiler are the following ones:

• If you remove the type parameters F.
• If you only have one method a (no overloading)
• If you apply the method a to a single list of several parameters A.a[Int, String](42) .

[hrhino]

The stack trace is telling:

scala> A.a[Int][Int](0)
java.lang.ClassCastException: scala.reflect.internal.Types$PolyType cannot be cast to scala.reflect.internal.Types$OverloadedType
        at scala.reflect.internal.Symbols$Symbol.alternatives(Symbols.scala:1941)
        at scala.reflect.internal.Symbols$Symbol.filter(Symbols.scala:1947)
        at scala.tools.nsc.typechecker.Infer$Inferencer.inferPolyAlternatives(Infer.scala:1423)
        at scala.tools.nsc.typechecker.Typers$Typer.typedTypeApply(Typers.scala:4025)
        at scala.tools.nsc.typechecker.Typers$Typer.typedTypeApply$1(Typers.scala:5344)
        at scala.tools.nsc.typechecker.Typers$Typer.typedOutsidePatternMode$1(Typers.scala:5507)

Nice find!

[Jasper-M]

This also crashes the compiler in cases that should compile.

scala> :pa
// Entering paste mode (ctrl-D to finish)

class Apply { def apply[A](x: Int) = 1 }

object A {
    def a[F] = new Apply
    def a[F](x: String) = 0
}

// Exiting paste mode, now interpreting.

defined class Apply
defined object A

scala> A.a[String]("a")
res2: Int = 0

scala> A.a[String](3)
res3: Int = 1

scala> A.a[String][Int](3)
java.lang.ClassCastException

[dimitarg]

This caused some considerable head scratching today, I wrote

val paymentTermCodec = enumOf[PaymentTerm][42]

💥

whereas I meant to write

val paymentTermCodec = enumOf[PaymentTerm](42)

(where enumOf has overloads with len: Int and underlying: Codec)

Not sure how Diego came up with their example, but above is at least one piece of anecdotal evidence it can come up in practice.