Incomplete error message for higher-kinded bounds violations

[smarter]

class Foo[X]
object Test {
  def bla[M <: [X] => Foo[X]] = ???
  bla[Foo] // OK
  bla[[X <: Int] => Foo[X]] // error
}

-- [E057] Type Mismatch Error: try/i4160.scala:5:17 ----------------------------
5 |  bla[[X <: Int] => Foo[X]] // error
  |                 ^
  |                 Type argument Foo does not conform to upper bound Foo 

The type argument is incorrectly reduced to Foo leading to a meaningless error message.

[Blaisorblade]

A few more testcases (assuming #4108 goes in), not sure if they need to be tested separately. This is right:

scala> trait Foo[F <: AnyKind]
scala> type Bar1 = [F <: AnyKind] => Foo[F]
// defined alias type Bar1 = Foo

but this is not:

scala> type Bar2 = [F] => Foo[F]
// defined alias type Bar2 = Foo
scala> type Bar3 = [F <: Any] => Foo[F]
// defined alias type Bar3 = Foo

since Bar2/Bar3 and Foo have different argument bounds. Luckily this only affects the output:

scala> val v: Bar1[Bar1] = null
val v: Foo[Bar1] = null
scala> val v: Bar2[Bar2] = null
1 |val v: Bar2[Bar2] = null
  |            ^^^^
  |            Type argument Bar2 has not the same kind as its bound
scala> val v: Bar3[Bar3] = null
1 |val v: Bar3[Bar3] = null
  |            ^^^^
  |            Type argument Bar3 has not the same kind as its bound

[bishabosha]

I believe this is fixed:

scala> class Foo[X]                                                                                                     
     | object Test {
     |   def bla[M <: [X] =>> Foo[X]] = ???
     |   bla[Foo] // OK
     |   bla[[X <: Int] =>> Foo[X]] // error
     | }
5 |  bla[[X <: Int] =>> Foo[X]] // error
  |                 ^
  |   Type argument [X <: Int] =>> Foo[X] does not conform to upper bound Foo