Type inference (with -Ypartial-unification) doesn't work for default arguments

[TomasMikula]

Try to compile the following code with scalac 2.12.1 with -language:higherKinds -Ypartial-unification

case class Foo[F[_]]()

class Bar[A, B]

object Test {

  // OK. For a local variable, type inference works.
  def test1[A]: Unit = {
    val m: Foo[({ type Out[α] = Bar[A, α] })#Out] = Foo()
  }

  // ERROR. Type inference doesn't work so well for default arguments.
  def test2[A](
    m: Foo[({ type Out[α] = Bar[A, α] })#Out] = Foo()
  ): Unit = ()

}

It gives the following error:

test.scala:14: error: no type parameters for method apply: ()Foo[F] in object Foo exist so that it can be applied to arguments ()
 --- because ---
undetermined type
    m: Foo[({ type Out[α] = Bar[A, α] })#Out] = Foo()
                                                ^
test.scala:14: error: type mismatch;
 found   : Foo[F]
 required: Foo[[α]Bar[?,α]]
    m: Foo[({ type Out[α] = Bar[A, α] })#Out] = Foo()
                                                   ^
two errors found

My expectation would be that type inference works the same in these two cases.

[lrytz]

This is the consequence of a special-case in type-checking defaults. The idea is to enable this:

scala> def f[T](x: T = 1) = x
f: [T](x: T)T

scala> f()
res3: Int = 1

http://www.scala-lang.org/files/archive/spec/2.12/04-basic-declarations-and-definitions.html#default-arguments says

The default argument expression e is type-checked with an expected type T' obtained by replacing all occurrences of the function's type parameters in T by the undefined type

So the following still gives an error:

scala> def f[T](x: Option[T] = 1) = x
<console>:11: error: type mismatch;
 found   : Int(1)
 required: Option[?]
       def f[T](x: Option[T] = 1) = x
                               ^

Maybe that feature is questionable, it's a bit of a hack that hasn't been discussed in very much detail. Another example that might be surprising:

scala> case class C[T]()
defined class C

scala> def f[T](x: C[T] = C()) = 0
f: [T](x: C[T])Int

scala> f[String]()
<console>:13: error: type mismatch;
 found   : C[Nothing]
 required: C[String]
Note: Nothing <: String, but class C is invariant in type T.
You may wish to define T as +T instead. (SLS 4.5)
Error occurred in an application involving default arguments.
       f[String]()
        ^

[TomasMikula]

Thanks for the explanation. The feature seems a little odd. I wonder if it has a good use (the example from the spec is not very useful).

[SethTisue]

if (in 2.13.0-M5 or 2.13.x HEAD) there's still an issue here that deserves a ticket, please open one in scala/bug