Merge pull request #5343 from milessabin/topic/si-2712-backport

SI-2712 Add support for higher order unification

18 files changed, 206 insertions, 0 deletions

diff --git a/test/files/pos/t2712-1.flags b/test/files/pos/t2712-1.flags
new file mode 100644
index 0000000000..41565c7e32
--- /dev/null
+++ b/test/files/pos/t2712-1.flags
@@ -0,0 +1 @@
+-Ypartial-unification
diff --git a/test/files/pos/t2712-1.scala b/test/files/pos/t2712-1.scala
new file mode 100644
index 0000000000..4f84c9df5e
--- /dev/null
+++ b/test/files/pos/t2712-1.scala
@@ -0,0 +1,9 @@
+package test
+
+// Original test case from,
+//
+//   https://issues.scala-lang.org/browse/SI-2712
+object Test {
+  def meh[M[_], A](x: M[A]): M[A] = x
+  meh{(x: Int) => x} // solves ?M = [X] Int => X and ?A = Int ...
+}
diff --git a/test/files/pos/t2712-2.flags b/test/files/pos/t2712-2.flags
new file mode 100644
index 0000000000..7d49efbb8e
--- /dev/null
+++ b/test/files/pos/t2712-2.flags
@@ -0,0 +1,2 @@
+-Ypartial-unification
+
diff --git a/test/files/pos/t2712-2.scala b/test/files/pos/t2712-2.scala
new file mode 100644
index 0000000000..39f22dd92a
--- /dev/null
+++ b/test/files/pos/t2712-2.scala
@@ -0,0 +1,25 @@
+package test
+
+// See: https://github.com/milessabin/si2712fix-demo/issues/3
+object Test {
+  trait A[T1, T2] { }
+  trait B[T1, T2] { }
+  class C[T] extends A[T, Long] with B[T, Double]
+  class CB extends A[Boolean, Long] with B[Boolean, Double]
+
+  trait A2[T]
+  trait B2[T]
+  class C2[T] extends A2[T] with B2[T]
+  class CB2 extends A2[Boolean] with B2[Boolean]
+
+  def meh[M[_], A](x: M[A]): M[A] = x
+
+  val m0 = meh(new C[Boolean])
+  m0: C[Boolean]
+  val m1 = meh(new CB)
+  m1: A[Boolean, Long]
+  val m2 = meh(new C2[Boolean])
+  m2: C2[Boolean]
+  val m3 = meh(new CB2)
+  m3: A2[Boolean]
+}
diff --git a/test/files/pos/t2712-3.flags b/test/files/pos/t2712-3.flags
new file mode 100644
index 0000000000..7d49efbb8e
--- /dev/null
+++ b/test/files/pos/t2712-3.flags
@@ -0,0 +1,2 @@
+-Ypartial-unification
+
diff --git a/test/files/pos/t2712-3.scala b/test/files/pos/t2712-3.scala
new file mode 100644
index 0000000000..46445f9289
--- /dev/null
+++ b/test/files/pos/t2712-3.scala
@@ -0,0 +1,24 @@
+package test
+
+object Test1 {
+  class Foo[T, F[_]]
+  def meh[M[_[_]], F[_]](x: M[F]): M[F] = x
+  meh(new Foo[Int, List]) // solves ?M = [X[_]]Foo[Int, X[_]] ?A = List ...
+}
+
+object Test2 {
+  trait TC[T]
+  class Foo[F[_], G[_]]
+  def meh[G[_[_]]](g: G[TC]) = ???
+  meh(new Foo[TC, TC]) // solves ?G = [X[_]]Foo[TC, X]
+}
+
+object Test3 {
+  trait TC[F[_]]
+  trait TC2[F[_]]
+  class Foo[F[_[_]], G[_[_]]]
+  new Foo[TC, TC2]
+
+  def meh[G[_[_[_]]]](g: G[TC2]) = ???
+  meh(new Foo[TC, TC2]) // solves ?G = [X[_[_]]]Foo[TC, X]
+}
diff --git a/test/files/pos/t2712-4.flags b/test/files/pos/t2712-4.flags
new file mode 100644
index 0000000000..7d49efbb8e
--- /dev/null
+++ b/test/files/pos/t2712-4.flags
@@ -0,0 +1,2 @@
+-Ypartial-unification
+
diff --git a/test/files/pos/t2712-4.scala b/test/files/pos/t2712-4.scala
new file mode 100644
index 0000000000..3e2e5cddae
--- /dev/null
+++ b/test/files/pos/t2712-4.scala
@@ -0,0 +1,17 @@
+package test
+
+object Test1 {
+  trait X
+  trait Y extends X
+  class Foo[T, U <: X]
+  def meh[M[_ <: A], A](x: M[A]): M[A] = x
+  meh(new Foo[Int, Y])
+}
+
+object Test2 {
+  trait X
+  trait Y extends X
+  class Foo[T, U >: Y]
+  def meh[M[_ >: A], A](x: M[A]): M[A] = x
+  meh(new Foo[Int, X])
+}
diff --git a/test/files/pos/t2712-5.flags b/test/files/pos/t2712-5.flags
new file mode 100644
index 0000000000..41565c7e32
--- /dev/null
+++ b/test/files/pos/t2712-5.flags
@@ -0,0 +1 @@
+-Ypartial-unification
diff --git a/test/files/pos/t2712-5.scala b/test/files/pos/t2712-5.scala
new file mode 100644
index 0000000000..ed96d4c06f
--- /dev/null
+++ b/test/files/pos/t2712-5.scala
@@ -0,0 +1,29 @@
+package test
+
+import scala.language.higherKinds
+
+trait Functor[F[_]] {
+  def map[A, B](f: A => B, fa: F[A]): F[B]
+}
+
+object Functor {
+  implicit def function[A]: Functor[({ type l[B] = A => B })#l] =
+    new Functor[({ type l[B] = A => B })#l] {
+      def map[C, B](cb: C => B, ac: A => C): A => B = cb compose ac
+    }
+}
+
+object FunctorSyntax {
+  implicit class FunctorOps[F[_], A](fa: F[A])(implicit F: Functor[F]) {
+    def map[B](f: A => B): F[B] = F.map(f, fa)
+  }
+}
+
+object Test {
+
+  val f: Int => String = _.toString
+
+  import FunctorSyntax._
+
+  f.map((s: String) => s.reverse)
+}
diff --git a/test/files/pos/t2712-6.flags b/test/files/pos/t2712-6.flags
new file mode 100644
index 0000000000..41565c7e32
--- /dev/null
+++ b/test/files/pos/t2712-6.flags
@@ -0,0 +1 @@
+-Ypartial-unification
diff --git a/test/files/pos/t2712-6.scala b/test/files/pos/t2712-6.scala
new file mode 100644
index 0000000000..eefe769ad6
--- /dev/null
+++ b/test/files/pos/t2712-6.scala
@@ -0,0 +1,12 @@
+package test
+
+object Tags {
+  type Tagged[A, T] = {type Tag = T; type Self = A}
+
+  type @@[T, Tag] = Tagged[T, Tag]
+
+  trait Disjunction
+
+  def meh[M[_], A](ma: M[A]): M[A] = ma
+  meh(null.asInstanceOf[Int @@ Disjunction])
+}
diff --git a/test/files/pos/t2712-7.flags b/test/files/pos/t2712-7.flags
new file mode 100644
index 0000000000..41565c7e32
--- /dev/null
+++ b/test/files/pos/t2712-7.flags
@@ -0,0 +1 @@
+-Ypartial-unification
diff --git a/test/files/pos/t2712-7.scala b/test/files/pos/t2712-7.scala
new file mode 100644
index 0000000000..d9c5243f13
--- /dev/null
+++ b/test/files/pos/t2712-7.scala
@@ -0,0 +1,15 @@
+package test
+
+// Cats Xor, Scalaz \/, scala.util.Either
+sealed abstract class Xor[+A, +B] extends Product with Serializable
+object Xor {
+  final case class Left[+A](a: A) extends (A Xor Nothing)
+  final case class Right[+B](b: B) extends (Nothing Xor B)
+}
+
+object TestXor {
+  import Xor._
+  def meh[F[_], A, B](fa: F[A])(f: A => B): F[B] = ???
+  meh(new Right(23): Xor[Boolean, Int])(_ < 13)
+  meh(new Left(true): Xor[Boolean, Int])(_ < 13)
+}
diff --git a/test/files/pos/t5683.flags b/test/files/pos/t5683.flags
new file mode 100644
index 0000000000..41565c7e32
--- /dev/null
+++ b/test/files/pos/t5683.flags
@@ -0,0 +1 @@
+-Ypartial-unification
diff --git a/test/files/pos/t5683.scala b/test/files/pos/t5683.scala
new file mode 100644
index 0000000000..05ab035792
--- /dev/null
+++ b/test/files/pos/t5683.scala
@@ -0,0 +1,23 @@
+object Test {
+  trait NT[X]
+  trait W[W, A] extends NT[Int]
+  type StringW[T] = W[String, T]
+  trait K[M[_], A, B]
+
+  def k[M[_], B](f: Int => M[B]): K[M, Int, B] = null
+
+  val okay1: K[StringW,Int,Int] = k{ (y: Int) => null: StringW[Int] }
+  val okay2 = k[StringW,Int]{ (y: Int) => null: W[String, Int] }
+
+  val crash: K[StringW,Int,Int] = k{ (y: Int) => null: W[String, Int] }
+
+  // remove `extends NT[Int]`, and the last line gives an inference error
+  // rather than a crash.
+  //   test/files/pos/t5683.scala:12: error: no type parameters for method k: (f: Int => M[B])Test.K[M,Int,B] exist so that it can be applied to arguments (Int => Test.W[String,Int])
+  //  --- because ---
+  // argument expression's type is not compatible with formal parameter type;
+  //  found   : Int => Test.W[String,Int]
+  //  required: Int => ?M[?B]
+  //   val crash: K[StringW,Int,Int] = k{ (y: Int) => null: W[String, Int] }
+  //                                   ^
+}
diff --git a/test/files/pos/t6895b.flags b/test/files/pos/t6895b.flags
new file mode 100644
index 0000000000..7d49efbb8e
--- /dev/null
+++ b/test/files/pos/t6895b.flags
@@ -0,0 +1,2 @@
+-Ypartial-unification
+
diff --git a/test/files/pos/t6895b.scala b/test/files/pos/t6895b.scala
new file mode 100644
index 0000000000..c465065011
--- /dev/null
+++ b/test/files/pos/t6895b.scala
@@ -0,0 +1,39 @@
+trait Foo[F[_]]
+trait Bar[F[_], A]
+
+trait Or[A, B]
+
+class Test {
+  implicit def orFoo[A]: Foo[({type L[X] = Or[A, X]})#L] = ???
+  implicit def barFoo[F[_]](implicit f: Foo[F]): Foo[({type L[X] = Bar[F, X]})#L] = ???
+
+  // Now we can define a couple of type aliases:
+  type StringOr[X] = Or[String, X]
+  type BarStringOr[X] = Bar[StringOr, X]
+
+  // ok
+  implicitly[Foo[BarStringOr]]
+  barFoo[StringOr](null) : Foo[BarStringOr]
+  barFoo(null) : Foo[BarStringOr]
+
+  // nok
+  implicitly[Foo[({type L[X] = Bar[StringOr, X]})#L]]
+  // Let's write the application explicitly, and then
+  // compile with just this line enabled and -explaintypes.
+  barFoo(null) : Foo[({type L[X] = Bar[StringOr, X]})#L]
+
+  // Foo[[X]Bar[F,X]] <: Foo[[X]Bar[[X]Or[String,X],X]]?
+  //   Bar[[X]Or[String,X],X] <: Bar[F,X]?
+  //     F[_] <: Or[String,_]?
+  //     false
+  //   false
+  // false
+
+  // Note that the type annotation above is typechecked as
+  // Foo[[X]Bar[[X]Or[String,X],X]], ie the type alias `L`
+  // is eta expanded.
+  //
+  // This is done so that it does not escape its defining scope.
+  // However, one this is done, higher kinded inference
+  // no longer is able to unify F with `StringOr` (SI-2712)
+}