Don't interpolate downwards to a bottom type

If the result of a covariant type variable interpolation would be a bottom type,
wait instead. This could make the variable be inferred to its upper bound after all,
if we do not need a fully instantiated type right away.

This makes a difference for indentation whereever we have a situation like this:
```
  def foo: T =
    bla.asInstanceOf
```
With indentation on, this is now equivalent to
```
  def foo: T = {
    bla.asInstanceof
  }
```
This means there is now an added opportunity for an interpolation step, of
the asInstanceOf, which would go downwards to Nothing. So indentation changes
the inferred type, which is very bad. With the commit the problem is
avoided.

Two tests are reclassified:

i536.scala previously compiled since the type argument was inferred to be Nothing.
But that inference is useless; it just hides a runtime failure. The issue #536
only complained that the compiler crashed, so having a negative outcome
is permissible.

enum-interop is similar except that the example makes even less sense and compiles only
because Nothing was inferred by accedient.

Author: odersky

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

@@ -434,7 +434,14 @@ trait Inferencing { this: Typer =>
             else if (!hasUnreportedErrors)
               if (v.intValue != 0) {
                 typr.println(i"interpolate $tvar in $state in $tree: $tp, fromBelow = ${v.intValue == 1}, $constraint")
-                tvar.instantiate(fromBelow = v.intValue == 1)
+                if (true) {
+                  val fromBelow = v.intValue == 1
+                  val instType = ctx.typeComparer.instanceType(tvar.origin, fromBelow)
+                  if (!(fromBelow && instType.isRef(defn.NothingClass)))
+                    tvar.instantiateWith(instType)
+                }
+                else
+                  tvar.instantiate(fromBelow = v.intValue == 1)
               }
               else typr.println(i"no interpolation for nonvariant $tvar in $state")
           }

tests/pos/i536.scala renamed to tests/neg/i536.scala

@@ -8,5 +8,5 @@ object Max {
   val m1 = max(xs)
   val m2 = max(null)
 
-  java.util.Collections.max(null)
+  java.util.Collections.max(null)  // error: Type argument Comparable[_] does not conform to upper bound Comparable[_ >: LazyRef(Comparable[_])]
 }

tests/pos/enum-interop.scala renamed to tests/pending/pos/enum-interop.scala

@@ -0,0 +1,7 @@
+object Test extends App {
+  def foo: String = {
+    "abc".asInstanceOf
+  }
+
+  assert(foo == "abc")
+}