Fix #4032: Fix direction of instantiation.

This is an altogether unsatisfying scenario. In #4032 there's an unconstrained
type variable that should be interpolated and it's a coin flip whether we instantiate
it to the lower or upper bound. A completely unrelated change in #3981 meant that
we instantiated the variable to the upper instead of the lower bound which caused
the program to fail. We now fix it by adding another condition which is also more
or less arbitrary: if neither lower bound nor upper bound is defined, we now prefer
again the lower bound. But all of this is quite arbitrary. The fact is that we do
cut off some parts of the search space in arbitrary ways and programs have come on
rely on the specific arbitrary way in which we do it.

Author: odersky

compiler/src/dotty/tools/dotc/core/Types.scala

@@ -3400,6 +3400,10 @@ object Types {
     def hasLowerBound(implicit ctx: Context) =
       !ctx.typerState.constraint.entry(origin).loBound.isBottomType
 
+    /** For uninstantiated type variables: Is the lower bound different from Nothing? */
+    def hasUpperBound(implicit ctx: Context) =
+      !ctx.typerState.constraint.entry(origin).hiBound.isTopType
+
     /** Unwrap to instance (if instantiated) or origin (if not), until result
      *  is no longer a TypeVar
      */

compiler/src/dotty/tools/dotc/typer/Inferencing.scala

@@ -389,7 +389,7 @@ trait Inferencing { this: Typer =>
         if (!(vs contains tvar) && qualifies(tvar)) {
           typr.println(s"instantiating non-occurring ${tvar.show} in ${tp.show} / $tp")
           ensureConstrained()
-          tvar.instantiate(fromBelow = tvar.hasLowerBound)
+          tvar.instantiate(fromBelow = tvar.hasLowerBound || !tvar.hasUpperBound)
         }
     }
     if (constraint.uninstVars exists qualifies) interpolate()

tests/neg-tailcall/tailrec.scala

@@ -56,7 +56,7 @@ class Failures {
   }
 
   // unsafe
-  @tailrec final def fail3[T](x: Int): Int = fail3(x - 1) // error // error: recursive application has different type arguments
+  @tailrec final def fail3[T](x: Int): Int = fail3(x - 1)
 
   // unsafe
   class Tom[T](x: Int) {

tests/pos/i4032.scala

@@ -0,0 +1,19 @@
+import scala.concurrent.Future
+
+class Gen[+T] {
+  def map[U](f: T => U): Gen[U] = ???
+}
+
+object Gen {
+  def oneOf[T](t0: T, t1: T): Gen[T] = ??? // Compile with this line commented
+  def oneOf[T](g0: Gen[T], g1: Gen[T]): Gen[T] = ???
+}
+
+class Arbitrary[T]
+
+object Arbitrary {
+  def arbitrary[T]: Gen[T] = ???
+
+  def arbFuture[X]: Gen[Future[X]] =
+    Gen.oneOf(arbitrary[Future[X]], arbitrary[Throwable].map(Future.failed))
+}