Incomplete substitution of type parameters in extension methods

[joroKr21]

This occurs when combining AnyVal extension methods and the Aux pattern for dependent types.

trait DepFn[A] { type B; def apply(a: A): B }
object DepFn { type Aux[A, C] = DepFn[A] { type B = C } }

class Syntax(val i: Int) extends AnyVal {
  def foo[A](e: Either[Int => A, DepFn.Aux[Int, A]]) = e.fold(_(i), _(i))
}

// Exiting paste mode, now interpreting.

  def foo[A](e: Either[Int => A, DepFn.Aux[Int, A]]) = e.fold(_(i), _(i))
                                                                     ^
<pastie>:4: error: type mismatch;
 found   : A
 required: A(in method foo$extension)

Note that surprisingly this compiles (the only difference is a type ascription):

class Syntax(val i: Int) extends AnyVal {
  def foo[A](e: Either[Int => A, DepFn.Aux[Int, A]]) = e.fold(_(i), _(i): A)
}

// Exiting paste mode, now interpreting.

defined class Syntax

And now the punchline (try it with a List[A]):

class Syntax(val i: Int) extends AnyVal {
  def foo[A](e: Either[Int => List[A], DepFn.Aux[Int, List[A]]]) = e.fold(_(i), _(i))
}

// Exiting paste mode, now interpreting.

  def foo[A](e: Either[Int => List[A], DepFn.Aux[Int, List[A]]]) = e.fold(_(i), _(i))
                                                                                 ^
<pastie>:4: error: type mismatch;
 found   : List[A]
 required: List[A]

huh? At this point the compiler looks silly 😆

[milessabin]

Works in Dotty.

[joroKr21]

The problem is that the second _(i) is typed as B where B is a type alias to A in foo. substituteSymbols is supposed to substitute A in foo with A in foo$extension but it does not follow the type alias. What should happen?

[joroKr21]

Maybe same issue as #9222?

[hrhino]

Found this today, which I suspect is a similar cause:

trait R[T] { def toX[U >: T]: X[U] }
trait X[A]
class Lose(val dumbo: Int) extends AnyVal {
  def fail[Q](foo: R[_ <: Q]): X[Q] = foo.toX
}

in which the Q in foo's type in fail$extension apparently doesn't get updated to point at the extension method's type parameter.