A tweak to type improvement

When we replace Nothing by a fresh type variable, we should not accidentally
instantiate that type variable to Any in case it is still undetermined. We achieve
this by giving the type variable a slightly disguised version of Nothing which
makes the compiler believe it has a lower bound.

Fixes #21275

[Cherry-picked 053c8f9]

Author: odersky

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

@@ -180,7 +180,15 @@ object Inferencing {
           t match
             case t: TypeRef =>
               if t.symbol == defn.NothingClass then
-                newTypeVar(TypeBounds.empty, nestingLevel = tvar.nestingLevel)
+                val notExactlyNothing = LazyRef(_ => defn.NothingType)
+                val bounds = TypeBounds(notExactlyNothing, defn.AnyType)
+                  // The new type variale has a slightly disguised lower bound Nothing.
+                  // This foils the `isExactlyNothing` test in `hasLowerBound` and
+                  // therefore makes the new type variable have a lower bound. That way,
+                  // we favor in `apply` below instantiating from below to `Nothing` instead
+                  // of from above to `Any`. That avoids a spurious flip of the roginal `Nothing`
+                  // instance to `Any`. See i21275 for a test case.
+                newTypeVar(bounds, nestingLevel = tvar.nestingLevel)
               else if t.symbol.is(ModuleClass) then
                 tryWidened(t.parents.filter(!_.isTransparent())
                   .foldLeft(defn.AnyType: Type)(TypeComparer.andType(_, _)))

tests/pos/i21725.scala

@@ -0,0 +1,10 @@
+class Box[+O]:
+  def ++[O2 >: O](other: Box[O2]): Box[O2] = ???
+object Box:
+  val empty: Box[Nothing] = ???
+
+def test[T]: Box[T] =
+  List(Box.empty, Box.empty)
+    // .reduceOption[Box[T]](_ ++ _) // works
+    .reduceOption(_ ++ _) // fails
+    .getOrElse(Box.empty)