Better fix: baseclasses intersection that takes bottom types into account

Author: odersky

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

@@ -194,12 +194,16 @@ object TypeOps:
    */
   def orDominator(tp: Type)(using Context): Type = {
 
-    /** a faster version of cs1 intersect cs2 */
-    def intersect(cs1: List[ClassSymbol], cs2: List[ClassSymbol]): List[ClassSymbol] = {
-      val cs2AsSet = new util.HashSet[ClassSymbol](128)
-      cs2.foreach(cs2AsSet += _)
-      cs1.filter(cs2AsSet.contains)
-    }
+    /** a faster version of cs1 intersect cs2 that treats bottom types correctly */
+    def intersect(cs1: List[ClassSymbol], cs2: List[ClassSymbol]): List[ClassSymbol] =
+      if cs1.head == defn.NothingClass then cs2
+      else if cs2.head == defn.NothingClass then cs1
+      else if cs1.head == defn.NullClass && !ctx.explicitNulls && cs2.head.derivesFrom(defn.ObjectClass) then cs2
+      else if cs2.head == defn.NullClass && !ctx.explicitNulls && cs1.head.derivesFrom(defn.ObjectClass) then cs1
+      else
+        val cs2AsSet = new util.HashSet[ClassSymbol](128)
+        cs2.foreach(cs2AsSet += _)
+        cs1.filter(cs2AsSet.contains)
 
     /** The minimal set of classes in `cs` which derive all other classes in `cs` */
     def dominators(cs: List[ClassSymbol], accu: List[ClassSymbol]): List[ClassSymbol] = (cs: @unchecked) match {

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

@@ -3148,10 +3148,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)
+