Better fix: skip bottom types in mapReduceOr

Author: odersky

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

@@ -459,9 +459,14 @@ object Types {
       case _ => f(this)
     }
 
-    /** Map function `f` over elements of an OrType, rebuilding with function `g` */
+    /** Map function `f` over elements of an OrType, rebuilding with function `g`
+     *  Bottom types are skipped.
+     */
     final def mapReduceOr[T](f: Type => T)(g: (T, T) => T)(using Context): T = stripTypeVar match {
-      case OrType(tp1, tp2) => g(tp1.mapReduceOr(f)(g), tp2.mapReduceOr(f)(g))
+      case OrType(tp1, tp2) =>
+        if tp1.isBottomType then tp2.mapReduceOr(f)(g)
+        else if tp2.isBottomType then tp1.mapReduceOr(f)(g)
+        else g(tp1.mapReduceOr(f)(g), tp2.mapReduceOr(f)(g))
       case _ => f(this)
     }
 
@@ -3148,10 +3153,7 @@ object Types {
     /** Replace or type by the closest non-or type above it */
     def join(using Context): Type = {
       if (myJoinPeriod != ctx.period) {
-        myJoin =
-          if tp1 frozen_<:< tp2 then tp2
-          else if tp2 frozen_<:< tp1 then tp1
-          else TypeOps.orDominator(this)
+        myJoin = TypeOps.orDominator(this)
         core.println(i"join of $this == $myJoin")
         assert(myJoin != this)
         myJoinPeriod = ctx.period

tests/pos/i11968a.scala

@@ -0,0 +1,48 @@
+
+class A {
+  def get(): Int = 0
+}
+
+class B extends A {}
+
+class C extends A {}
+
+def test1 = {
+  val s: String | Null = ???
+  val l = s.length
+
+  val a: A | Null = new A
+  a.get()
+
+  val bc: B | C = new B
+  bc.get()
+
+  val bcn: B | (C | Null) = new C
+  bcn.get()
+
+  val bnc: (B | Null) | C = null
+  bnc.get()
+
+  val abcn: A | B | C | Null = new A
+  abcn.get()
+}
+
+def test2 = {
+  val s: String | Nothing = ???
+  val l = s.length
+
+  val a: A | Nothing = new A
+  a.get()
+
+  val bc: B | C = new B
+  bc.get()
+
+  val bcn: B | (C | Nothing) = new C
+  bcn.get()
+
+  val bnc: (B | Nothing) | C = new B
+  bnc.get()
+
+  val abcn: A | B | C | Nothing = new A
+  abcn.get()
+}

tests/pos/i11981.scala

@@ -0,0 +1,21 @@
+object Main:
+    class Null
+    type Optional[A] = A | Null
+
+    val maybeInt: Optional[Int] = 1
+
+    // simplest typeclass
+    trait TC[F[_]]
+
+    // given instances for our Optional and standard Option[_]
+    given g1: TC[Optional] = ???
+    given g2: TC[Option] = ???
+
+    def summonTC[F[_], A](f: F[A])(using TC[F]): Unit = ???
+
+    summonTC(Option(42))  // OK
+
+    summonTC[Optional, Int](maybeInt) // OK
+
+    summonTC(maybeInt)
+