scala
diff --git a/‎test/junit/scala/reflect/internal/TypesTest.scala
Lines changed: 193 additions & 1 deletion b/‎test/junit/scala/reflect/internal/TypesTest.scala
Lines changed: 193 additions & 1 deletion
@@ -1,7 +1,7 @@
 package scala.reflect.internal
 
 import org.junit.Assert._
-import org.junit.{Assert, Test}
+import org.junit.{After, Assert, Before, Test}
 import org.junit.runner.RunWith
 import org.junit.runners.JUnit4
 import scala.collection.mutable
@@ -139,4 +139,196 @@ class TypesTest {
     assert(ts.forall(_ <:< merged2))
     assert(merged1 =:= merged2)
   }
+
+
+
+  class Foo[A]
+  class Bar[+T, A]
+  class Baz {
+    def f[F[_]] = ()
+    def g[G[_, _]] = ()
+  }
+
+  var storedYhkTypevarUnification = false
+  @Before
+  def storeYhkTypevarUnification: Unit = {
+    storedYhkTypevarUnification = settings.YhkTypevarUnification
+  }
+  @After
+  def restoreYhkTypevarUnification: Unit = {
+    settings.YhkTypevarUnification.value = storedYhkTypevarUnification
+  }
+
+  @Test
+  def testHigherKindedTypeVarUnification(): Unit = {
+    import rootMirror.EmptyPackageClass
+    import Flags._
+
+    val FooTpe = typeOf[Foo[Int]] match {
+      case TypeRef(pre, sym, _) =>
+        sym.typeParams // doing it for the side effect
+        TypeRef(pre, sym, Nil)
+    }
+    val BarTpe = typeOf[Bar[Int, Int]] match {
+      case TypeRef(pre, sym, _) =>
+        sym.typeParams // doing it for the side effect
+        TypeRef(pre, sym, Nil)
+    }
+
+    // apply Foo to type arugment A
+    def Foo(A: Type) = FooTpe match {
+      case TypeRef(pre, sym, Nil) => TypeRef(pre, sym, A :: Nil)
+    }
+
+    // apply Bar to type arguments A, B
+    def Bar(A: Type, B: Type) = BarTpe match {
+      case TypeRef(pre, sym, Nil) => TypeRef(pre, sym, A :: B :: Nil)
+    }
+
+    val F0 = typeOf[Baz].member(TermName("f")).typeSignature.typeParams.head
+    val G0 = typeOf[Baz].member(TermName("g")).typeSignature.typeParams.head
+
+    // since TypeVars are mutable, we will be creating fresh ones
+    def F() = TypeVar(F0)
+    def G() = TypeVar(G0)
+
+    def polyType(f: TypeVar => Type, flags: Long = 0L): Type = {
+      val A = EmptyPackageClass.newTypeParameter(newTypeName("A"), newFlags = flags)
+      A.setInfo(TypeBounds.empty)
+      val A_ = TypeVar(A)
+      PolyType(A :: Nil, f(A_))
+    }
+
+    def coPolyType(f: TypeVar => Type): Type =
+      polyType(f, COVARIANT)
+
+    def polyType2(f: (TypeVar, TypeVar) => Type): Type = {
+      val A = EmptyPackageClass.newTypeParameter(newTypeName("A"))
+      val B = EmptyPackageClass.newTypeParameter(newTypeName("B"))
+      A.setInfo(TypeBounds.empty)
+      B.setInfo(TypeBounds.empty)
+      val A_ = TypeVar(A)
+      val B_ = TypeVar(B)
+      PolyType(A :: B :: Nil, f(A_, B_))
+    }
+
+    val Any = typeOf[Any]
+    val Int = typeOf[Int]
+
+    settings.YhkTypevarUnification.value = true
+
+    // test that ?F unifies with Foo
+    assert(F() <:< FooTpe)
+    assert(FooTpe <:< F())
+    assert(F() =:= FooTpe)
+    assert(FooTpe =:= F)
+
+    // test that ?F unifies with [A]Foo[A]
+    assert(F() <:< polyType(A => Foo(A)))
+    assert(polyType(A => Foo(A)) <:< F())
+    assert(F() =:= polyType(A => Foo(A)))
+    assert(polyType(A => Foo(A)) =:= F())
+
+    // test that ?F unifies with [A]Bar[Int, A]
+    assert(F<
9E88
/span>() <:< polyType(A => Bar(Int, A)))
+    assert(polyType(A => Bar(Int, A)) <:< F())
+    assert(F() =:= polyType(A => Bar(Int, A)))
+    assert(polyType(A => Bar(Int, A)) =:= F())
+
+    // test that ?F unifies with [A]Bar[A, Int]
+    assert(F() <:< polyType(A => Bar(A, Int)))
+    assert(polyType(A => Bar(A, Int)) <:< F())
+    assert(F() =:= polyType(A => Bar(A, Int)))
+    assert(polyType(A => Bar(A, Int)) =:= F())
+
+    // test that ?F unifies with [+A]Bar[A, Int]
+    assert(F() <:< coPolyType(A => Bar(A, Int)))
+    assert(coPolyType(A => Bar(A, Int)) <:< F())
+    assert(F() =:= coPolyType(A => Bar(A, Int)))
+    assert(coPolyType(A => Bar(A, Int)) =:= F())
+
+    // test that ?F unifies with [A]Foo[Foo[A]]
+    assert(F() <:< polyType(A => Foo(Foo(A))))
+    assert(polyType(A => Foo(Foo(A))) <:< F())
+    assert(F() =:= polyType(A => Foo(Foo(A))))
+    assert(polyType(A => Foo(Foo(A))) =:= F())
+
+    // test that ?F unifies with [A]Foo[Bar[A, A]]
+    assert(F() <:< polyType(A => Foo(Bar(A, A))))
+    assert(polyType(A => Foo(Bar(A, A))) <:< F())
+    assert(F() =:= polyType(A => Foo(Bar(A, A))))
+    assert(polyType(A => Foo(Bar(A, A))) =:= F())
+
+    // test that ?F unifies with [A]Bar[Foo[A], Foo[A]]
+    assert(F() <:< polyType(A => Bar(Foo(A), Foo(A))))
+    assert(polyType(A => Bar(Foo(A), Foo(A))) <:< F())
+    assert(F() =:= polyType(A => Bar(Foo(A), Foo(A))))
+    assert(polyType(A => Bar(Foo(A), Foo(A))) =:= F())
+
+    // test that ?F unifies with [A]A
+    assert(F() <:< polyType(A => A))
+    assert(polyType(A => A) <:< F())
+    assert(F() =:= polyType(A => A))
+    assert(polyType(A => A) =:= F())
+
+    // test that ?F unifies with [A]Int
+    assert(F() <:< polyType(A => Int))
+    assert(polyType(A => Int) <:< F())
+    assert(F() =:= polyType(A => Int))
+    assert(polyType(A => Int) =:= F())
+
+    // test that ?F unifies with [A]Foo[Int]
+    assert(F() <:< polyType(A => Foo(Int)))
+    assert(polyType(A => Foo(Int)) <:< F())
+    assert(F() =:= polyType(A => Foo(Int)))
+    assert(polyType(A => Foo(Int)) =:= F())
+
+    // test that ?G unifies with Bar
+    assert(G() <:< BarTpe)
+    assert(BarTpe <:< G())
+    assert(G() =:= BarTpe)
+    assert(BarTpe =:= G())
+
+    // test that ?G unifies with [A, B]Bar[A, B]
+    assert(G() <:< polyType2((A, B) => Bar(A, B)))
+    assert(polyType2((A, B) => Bar(A, B)) <:< G())
+    assert(G() =:= polyType2((A, B) => Bar(A, B)))
+    assert(polyType2((A, B) => Bar(A, B)) =:= G())
+
+    // test that ?G unifies with [A, B]Bar[B, A]
+    assert(G() <:< polyType2((A, B) => Bar(B, A)))
+    assert(polyType2((B, A) => Bar(A, B)) <:< G())
+    assert(G() =:= polyType2((A, B) => Bar(B, A)))
+    assert(polyType2((B, A) => Bar(A, B)) =:= G())
+
+    // test that ?G unifies with [A, B]Bar[Bar[B, A], A]
+    assert(G() <:< polyType2((A, B) => Bar(Bar(B, A), A)))
+    assert(polyType2((A, B) => Bar(Bar(B, A), A)) <:< G())
+    assert(G() =:= polyType2((A, B) => Bar(Bar(B, A), A)))
+    assert(polyType2((A, B) => Bar(Bar(B, A), A)) =:= G())
+
+    // test that ?G doesn't unify with [A]Bar[A, A]
+    assertFalse(G() <:< polyType(A => Bar(A, A)))
+    assertFalse(polyType(A => Bar(A, A)) <:< G())
+    // These fail, but shouldn't.
+    // Probably a bug in TypeVar#registerTypeEquality: not checking the number of type parameters.
+    //assertFalse(G() =:= polyType(A => Bar(A, A)))
+    //assertFalse(polyType(A => Bar(A, A)) =:= G())
+
+    // test that [A]Bar[Int, A] <:< ?F <:< [A]Bar[Any, A]
+    F() match { case _F =>
+      assert(polyType(A => Bar(Int, A)) <:< _F && _F <:< polyType(A => Bar(Any, A)))
+    }
+
+    // Test that both
+    //   Foo <:< ?F
+    //   ?F <:< [A]Bar[Int, A]
+    // but not at the same time, which by transitivity would mean
+    //   Foo <:< [A]Bar[Int, A]
+    // which is wrong.
+    assert(FooTpe <:< F() && F() <:< polyType(A => Bar(Int, A)))
+    F() match { case _F =>
+      assertFalse(FooTpe <:< _F && _F <:< polyType(A => Bar(Int, A)))
+    }
+  }
 }