Union types: deduplication + Nothing type members absorption

Added the following simplification rules to OrType:
- deduplication without subtype comparisons by the means of object equality/hash code
- absorption of Nothing types (T | Nothing == T)

Author: mucciolo

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

@@ -156,15 +156,18 @@ object TypeOps:
         tp.derivedAlias(simplify(tp.alias, theMap))
       case AndType(l, r) if !ctx.mode.is(Mode.Type) =>
         simplify(l, theMap) & simplify(r, theMap)
-      case tp @ OrType(l, r)
-      if !ctx.mode.is(Mode.Type)
-         && (tp.isSoft || l.isBottomType || r.isBottomType) =>
-        // Normalize A | Null and Null | A to A even if the union is hard (i.e.
-        // explicitly declared), but not if -Yexplicit-nulls is set. The reason is
-        // that in this case the normal asSeenFrom machinery is not prepared to deal
-        // with Nulls (which have no base classes). Under -Yexplicit-nulls, we take
-        // corrective steps, so no widening is wanted.
-        simplify(l, theMap) | simplify(r, theMap)
+      case tp @ OrType(l, r) =>
+        if !ctx.mode.is(Mode.Type) && (tp.isSoft || l.isBottomType || r.isBottomType) then
+          // Normalize A | Null and Null | A to A even if the union is hard (i.e.
+          // explicitly declared), but not if -Yexplicit-nulls is set. The reason is
+          // that in this case the normal asSeenFrom machinery is not prepared to deal
+          // with Nulls (which have no base classes). Under -Yexplicit-nulls, we take
+          // corrective steps, so no widening is wanted.
+          simplify(l, theMap) | simplify(r, theMap)
+        else if r.isNothingType || (l eq r) then l
+        else if l.isOrType || r.isOrType then tp.deduplicatedAbsorbingNothingTypes
+        else if l.isNothingType then r
+        else mapOver
       case tp @ CapturingType(parent, refs) =>
         if !ctx.mode.is(Mode.Type)
             && refs.subCaptures(parent.captureSet, frozen = true).isOK

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

@@ -446,6 +446,9 @@ object Types {
     final def containsWildcardTypes(using Context) =
       existsPart(_.isInstanceOf[WildcardType], StopAt.Static, forceLazy = false)
 
+    /** Is this a union type? */
+    final def isOrType: Boolean = this.isInstanceOf[OrType]
+
 // ----- Higher-order combinators -----------------------------------
 
     /** Returns true if there is a part of this type that satisfies predicate `p`.
@@ -3466,6 +3469,50 @@ object Types {
       case that: OrType => tp1.eq(that.tp1) && tp2.eq(that.tp2) && isSoft == that.isSoft
       case _ => false
     }
+
+    /** Returns the set of non-union (leaf) types composing this union tree with Nothing types
+     *  absorbed by other types, if present.
+     *  For example:
+     *  {{{A | B | C | B | (A & (B | C)) | Nothing}}}
+     *  returns
+     *  {{{Set(A, B, C, (A & (B | C)))}}}
+     */
+    private def gatherTreeUniqueMembersAbsorbingNothingTypes(using Context): Set[Type] = {
+      (tp1, tp2) match
+        case (l: OrType, r: OrType) =>
+          l.gatherTreeUniqueMembersAbsorbingNothingTypes ++ r.gatherTreeUniqueMembersAbsorbingNothingTypes
+        case (l: OrType, r) =>
+          if r.isNothingType
+          then l.gatherTreeUniqueMembersAbsorbingNothingTypes
+          else l.gatherTreeUniqueMembersAbsorbingNothingTypes + r
+        case (l, r: OrType) =>
+          if l.isNothingType
+          then r.gatherTreeUniqueMembersAbsorbingNothingTypes
+          else r.gatherTreeUniqueMembersAbsorbingNothingTypes + l
+        case (l, r) =>
+          if r.isNothingType then Set(l)
+          else if l.isNothingType then Set(r)
+          else Set(l, r)
+    }
+
+    /** Returns an equivalent union tree without repeated members and with Nothing types absorbed
+     *  by other types, if present. Weaker than LUB.
+     */
+    def deduplicatedAbsorbingNothingTypes(using Context): Type = {
+      val uniqueTreeMembers = this.gatherTreeUniqueMembersAbsorbingNothingTypes
+      val factorCount = orFactorCount(isSoft)
+
+      uniqueTreeMembers.size match {
+        case 1 =>
+          uniqueTreeMembers.head
+        case uniqueMembersCount if uniqueMembersCount < factorCount =>
+          val uniqueMembers = uniqueTreeMembers.iterator
+          val startingUnion = OrType(uniqueMembers.next(), uniqueMembers.next(), isSoft)
+          uniqueMembers.foldLeft(startingUnion)(OrType(_, _, isSoft))
+        case _ =>
+          this
+      }
+    }
   }
 
   final class CachedOrType(tp1: Type, tp2: Type, override val isSoft: Boolean) extends OrType(tp1, tp2)

tests/neg/i11694.scala

@@ -5,8 +5,8 @@ def test1 = {
   def f21: (Int => Int) | Null = x => x + 1
   def f22: Null | (Int => Int) = x => x + 1
 
-  def f31: (Int => Int) | (Int => Int) = x => x + 1  // error
-  def f32: (Int => Int) | (Int => Int) | Unit = x => x + 1 // error
+  def f31: (Int => Int) | (Int => Int) = x => x + 1
+  def f32: (Int => Int) | (Int => Int) | Unit = x => x + 1
 
   def f41: (Int => Int) & (Int => Int) = x => x + 1
   def f42: (Int => Int) & (Int => Int) & Any = x => x + 1

tests/neg/i14823a.scala

@@ -13,8 +13,8 @@ object Foo {
   case class A[T]() extends Foo[T]
 }
 
-val foo = summon[Mirror.Of[Box[Int] | Box[Int]]] // error
-val bar = summon[MirrorK1.Of[[X] =>> Box[Int] | Box[Int]]] // error
-def baz = summon[deriving.Mirror.Of[Foo[String] | Foo[String]]] // error
+val foo = summon[Mirror.Of[Box[Int] | Box[String]]] // error
+val bar = summon[MirrorK1.Of[[X] =>> Box[Int] | Box[String]]] // error
+def baz = summon[deriving.Mirror.Of[Foo[Int] | Foo[String]]] // error
 
 def qux = summon[deriving.Mirror.Of[Option[Int] | Option[String]]] // error

tests/printing/i10693.check

@@ -0,0 +1,23 @@
+[[syntax trees at end of                     typer]] // tests/printing/i10693.scala
+package <empty> {
+  final lazy module val i10693$package: i10693$package = new i10693$package()
+  final module class i10693$package() extends Object() { 
+    this: i10693$package.type =>
+    def test[A >: Nothing <: Any, B >: Nothing <: Any](a: A, b: B): A | B = a
+    val v0: String | Int = test[String, Int]("string", 1)
+    val v1: Int | String = test[Int, String](1, "string")
+    val v2: String | Int = test[(String | Int), (Int | String)](v0, v1)
+    val v3: Int | String = test[(Int | String), (String | Int)](v1, v0)
+    val v4: String | Int = test[(String | Int), (Int | String)](v2, v3)
+    val v5: Int | String = test[(Int | String), (String | Int)](v3, v2)
+    val v6: String | Int = test[(String | Int), (Int | String)](v4, v5)
+    val t0: List[Int] = Tuple1.apply[Int](1).toList
+    val t1: List[Int] = Tuple2.apply[Int, Int](1, 2).toList
+    val t2: List[Int] = Tuple3.apply[Int, Int, Int](1, 2, 3).toList
+    val t3: List[Int | String] = 
+      Tuple3.apply[String, Int, Int]("A", 2, 3).toList
+    val t4: List[String | Int] = 
+      Tuple3.apply[Int, String, String](1, "B", "C").toList
+  }
+}
+

tests/printing/i10693.scala

@@ -0,0 +1,16 @@
+// minimized code
+def test[A, B](a: A, b: B): A | B = a
+val v0 = test("string", 1)
+val v1 = test(1, "string")
+val v2 = test(v0, v1)
+val v3 = test(v1, v0)
+val v4 = test(v2, v3)
+val v5 = test(v3, v2)
+val v6 = test(v4, v5)
+
+// issue comments section examples
+val t0 = Tuple1(1).toList
+val t1 = (1, 2).toList
+val t2 = (1, 2, 3).toList
+val t3 = ("A", 2, 3).toList
+val t4 = (1, "B", "C").toList