Re-enable distributeAnd until source version 3.8

Author: EugeneFlesselle

compiler/src/dotty/tools/dotc/config/SourceVersion.scala

@@ -43,6 +43,8 @@ enum SourceVersion:
   def enablesNewGivens = isAtLeast(`3.6`)
   def enablesNamedTuples = isAtLeast(`3.7`)
   def enablesBetterFors(using Context) = isAtLeast(`3.7`) && isPreviewEnabled
+  /** See PR #23441 and tests/neg/i23435-min */
+  def enablesDistributeAnd = !isAtLeast(`3.8`)
 
   def requiresNewSyntax = isAtLeast(future)
 

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

@@ -8,6 +8,7 @@ import Symbols.*
 import SymDenotations.LazyType
 import Decorators.*
 import util.Stats.*
+import config.Feature.sourceVersion
 import Names.*
 import StdNames.nme
 import Flags.{Module, Provisional}
@@ -482,9 +483,10 @@ class TypeApplications(val self: Type) extends AnyVal {
             if tp.tp1.isBottomType then elemType(tp.tp2)
             else if tp.tp2.isBottomType then elemType(tp.tp1)
             else tp.derivedOrType(elemType(tp.tp1), elemType(tp.tp2))
-          case AndType(tp1, tp2) =>
-            // see #23435 for why this is not `tp.derivedAndType(elemType(tp1), ...)`
-            OrType(elemType(tp1), elemType(tp2), soft = false)
+          case tp @ AndType(tp1, tp2) =>
+            if sourceVersion.enablesDistributeAnd
+            then tp.derivedAndType(elemType(tp1), elemType(tp2))
+            else OrType(elemType(tp1), elemType(tp2), soft = false)
           case _ =>
             tp.baseType(from).argInfos.headOption.getOrElse(defn.NothingType)
         end elemType

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

@@ -2458,6 +2458,29 @@ class TypeComparer(@constructorOnly initctx: Context) extends ConstraintHandling
     isSubRef(tp1, tp2) && isSubRef(tp2, tp1)
   }
 
+  /** If the range `tp1..tp2` consist of a single type, that type, otherwise NoType`.
+   *  This is the case if `tp1 =:= tp2`, but also if `tp1 <:< tp2`, `tp1` is a singleton type,
+   *  and `tp2` derives from `scala.Singleton` and `sourceVersion.enablesDistributeAnd` (or vice-versa).
+   *  Examples of the latter case:
+   *
+   *     "name".type .. Singleton
+   *     "name".type .. String & Singleton
+   *     Singleton .. "name".type
+   *     String & Singleton .. "name".type
+   *
+   *  All consist of the single type `"name".type`.
+   */
+  def singletonInterval(tp1: Type, tp2: Type): Type = {
+    def isSingletonBounds(lo: Type, hi: Type) =
+      lo.isSingleton && hi.derivesFrom(defn.SingletonClass) && isSubTypeWhenFrozen(lo, hi)
+    if (isSameTypeWhenFrozen(tp1, tp2)) tp1
+    else if sourceVersion.enablesDistributeAnd then
+      if (isSingletonBounds(tp1, tp2)) tp1
+      else if (isSingletonBounds(tp2, tp1)) tp2
+      else NoType
+    else NoType
+  }
+
   /** The greatest lower bound of two types */
   def glb(tp1: Type, tp2: Type): Type = // trace(s"glb(${tp1.show}, ${tp2.show})", subtyping, show = true):
     if tp1 eq tp2 then tp1
@@ -2563,7 +2586,7 @@ class TypeComparer(@constructorOnly initctx: Context) extends ConstraintHandling
       case tparam :: tparamsRest =>
         val arg1 :: args1Rest = args1: @unchecked
         val arg2 :: args2Rest = args2: @unchecked
-        val common = if isSameTypeWhenFrozen(arg1, arg2) then arg1 else NoType
+        val common = singletonInterval(arg1, arg2)
         val v = tparam.paramVarianceSign
         val lubArg =
           if (common.exists) common
@@ -2595,7 +2618,7 @@ class TypeComparer(@constructorOnly initctx: Context) extends ConstraintHandling
       case tparam :: tparamsRest =>
         val arg1 :: args1Rest = args1: @unchecked
         val arg2 :: args2Rest = args2: @unchecked
-        val common = if isSameTypeWhenFrozen(arg1, arg2) then arg1 else NoType
+        val common = singletonInterval(arg1, arg2)
         val v = tparam.paramVarianceSign
         val glbArg =
           if (common.exists) common
@@ -2748,10 +2771,19 @@ class TypeComparer(@constructorOnly initctx: Context) extends ConstraintHandling
   }
 
   /** Try to distribute `&` inside type, detect and handle conflicts
-   *  Note that an intersection cannot be pushed into an applied type, see tests/neg/i23435-min.
    *  @pre !(tp1 <: tp2) && !(tp2 <:< tp1) -- these cases were handled before
    */
   private def distributeAnd(tp1: Type, tp2: Type): Type = tp1 match {
+    case tp1 @ AppliedType(tycon1, args1) if sourceVersion.enablesDistributeAnd =>
+      tp2 match {
+        case AppliedType(tycon2, args2)
+        if tycon1.typeSymbol == tycon2.typeSymbol && tycon1 =:= tycon2 =>
+          val jointArgs = glbArgs(args1, args2, tycon1.typeParams)
+          if (jointArgs.forall(_.exists)) (tycon1 & tycon2).appliedTo(jointArgs)
+          else NoType
+        case _ =>
+          NoType
+      }
     case tp1: RefinedType =>
       // opportunistically merge same-named refinements
       // this does not change anything semantically (i.e. merging or not merging

tests/neg/i23435-min.scala

@@ -1,3 +1,4 @@
+//> using options -source:3.8
 
 type Or[+A, +B] = A | B
 

tests/neg/i23435.scala

@@ -1,3 +1,4 @@
+//> using options -source:3.8
 
 trait L[+A]{val a:A}
 trait R[+B]{val b: B}

tests/neg/singletonInterval.scala

@@ -1,3 +1,4 @@
+//> using options -source:3.8
 
 /** Why the singletonInterval logic cannot be applied for lubArgs and glbArgs in TypeComparer. */
 

tests/pos/i23435-min-3.7.scala

@@ -0,0 +1,7 @@
+//> using options -source:3.7
+
+type Or[+A, +B] = A | B
+
+val x: Or[Int, String] & Or[String, Int] = 3
+val y: Or[Int & String, String & Int] = x // ok in 3.7, error in 3.8
+val z: String = y