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.

The commit is broken out separately into PR #7130.

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/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")
+}